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@1:b38ebb8ea286, 2015-10-16 (annotated)

Committer:
Davidroid
Date:
Fri Oct 16 13:30:06 2015 +0000
Revision:
1:b38ebb8ea286
Parent:
0:2887415a46cd
Child:
2:de6d31fa3709
Child:
4:83a1eb397a65
+ Removed Timer Serivce Routine's flag and restored direct callback.; + Restored "L6474_WaitWhileActive()" function.;

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 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 1:b38ebb8ea286 81 /* Methods -------------------------------------------------------------------*/
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 1:b38ebb8ea286 147 *id = deviceInstance;
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 1:b38ebb8ea286 517 * @brief Locks until the device state becomes Inactive
Davidroid 1:b38ebb8ea286 518 * @retval None
Davidroid 1:b38ebb8ea286 519 **********************************************************/
Davidroid 1:b38ebb8ea286 520 void L6474::L6474_WaitWhileActive(void)
Davidroid 1:b38ebb8ea286 521 {
Davidroid 1:b38ebb8ea286 522 /* Wait while motor is running */
Davidroid 1:b38ebb8ea286 523 while (L6474_GetDeviceState() != INACTIVE);
Davidroid 1:b38ebb8ea286 524 }
Davidroid 1:b38ebb8ea286 525
Davidroid 1:b38ebb8ea286 526 /******************************************************//**
Davidroid 0:2887415a46cd 527 * @brief Issue the Disable command to the L6474 of the specified device
Davidroid 0:2887415a46cd 528 * @retval None
Davidroid 0:2887415a46cd 529 **********************************************************/
Davidroid 0:2887415a46cd 530 void L6474::L6474_CmdDisable(void)
Davidroid 0:2887415a46cd 531 {
Davidroid 0:2887415a46cd 532 L6474_SendCommand(L6474_DISABLE);
Davidroid 0:2887415a46cd 533 }
Davidroid 0:2887415a46cd 534
Davidroid 0:2887415a46cd 535 /******************************************************//**
Davidroid 0:2887415a46cd 536 * @brief Issues the Enable command to the L6474 of the specified device
Davidroid 0:2887415a46cd 537 * @retval None
Davidroid 0:2887415a46cd 538 **********************************************************/
Davidroid 0:2887415a46cd 539 void L6474::L6474_CmdEnable(void)
Davidroid 0:2887415a46cd 540 {
Davidroid 0:2887415a46cd 541 L6474_SendCommand(L6474_ENABLE);
Davidroid 0:2887415a46cd 542 }
Davidroid 0:2887415a46cd 543
Davidroid 0:2887415a46cd 544 /******************************************************//**
Davidroid 0:2887415a46cd 545 * @brief Issues the GetParam command to the L6474 of the specified device
Davidroid 0:2887415a46cd 546 * @param[in] param Register adress (L6474_ABS_POS, L6474_MARK,...)
Davidroid 0:2887415a46cd 547 * @retval Register value
Davidroid 0:2887415a46cd 548 **********************************************************/
Davidroid 0:2887415a46cd 549 uint32_t L6474::L6474_CmdGetParam(uint32_t param)
Davidroid 0:2887415a46cd 550 {
Davidroid 0:2887415a46cd 551 uint32_t i;
Davidroid 0:2887415a46cd 552 uint32_t spiRxData;
Davidroid 0:2887415a46cd 553 uint8_t maxArgumentNbBytes = 0;
Davidroid 0:2887415a46cd 554 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 555
Davidroid 0:2887415a46cd 556 do
Davidroid 0:2887415a46cd 557 {
Davidroid 0:2887415a46cd 558 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 559 if (itDisable)
Davidroid 0:2887415a46cd 560 {
Davidroid 0:2887415a46cd 561 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 562 L6474_EnableIrq();
Davidroid 0:2887415a46cd 563 itDisable = FALSE;
Davidroid 0:2887415a46cd 564 }
Davidroid 0:2887415a46cd 565
Davidroid 0:2887415a46cd 566 spiTxBursts[0] = L6474_NOP;
Davidroid 0:2887415a46cd 567 spiTxBursts[1] = L6474_NOP;
Davidroid 0:2887415a46cd 568 spiTxBursts[2] = L6474_NOP;
Davidroid 0:2887415a46cd 569 spiTxBursts[3] = L6474_NOP;
Davidroid 0:2887415a46cd 570 spiRxBursts[1] = 0;
Davidroid 0:2887415a46cd 571 spiRxBursts[2] = 0;
Davidroid 0:2887415a46cd 572 spiRxBursts[3] = 0;
Davidroid 0:2887415a46cd 573
Davidroid 0:2887415a46cd 574 switch (param)
Davidroid 0:2887415a46cd 575 {
Davidroid 0:2887415a46cd 576 case L6474_ABS_POS: ;
Davidroid 0:2887415a46cd 577 case L6474_MARK:
Davidroid 0:2887415a46cd 578 spiTxBursts[0] = ((uint8_t)L6474_GET_PARAM )| (param);
Davidroid 0:2887415a46cd 579 maxArgumentNbBytes = 3;
Davidroid 0:2887415a46cd 580 break;
Davidroid 0:2887415a46cd 581 case L6474_EL_POS: ;
Davidroid 0:2887415a46cd 582 case L6474_CONFIG: ;
Davidroid 0:2887415a46cd 583 case L6474_STATUS:
Davidroid 0:2887415a46cd 584 spiTxBursts[1] = ((uint8_t)L6474_GET_PARAM )| (param);
Davidroid 0:2887415a46cd 585 maxArgumentNbBytes = 2;
Davidroid 0:2887415a46cd 586 break;
Davidroid 0:2887415a46cd 587 default:
Davidroid 0:2887415a46cd 588 spiTxBursts[2] = ((uint8_t)L6474_GET_PARAM )| (param);
Davidroid 0:2887415a46cd 589 maxArgumentNbBytes = 1;
Davidroid 0:2887415a46cd 590 }
Davidroid 0:2887415a46cd 591
Davidroid 0:2887415a46cd 592 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 593 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 594 L6474_DisableIrq();
Davidroid 0:2887415a46cd 595 itDisable = TRUE;
Davidroid 0:2887415a46cd 596 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 597
Davidroid 0:2887415a46cd 598 for (i = L6474_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
Davidroid 0:2887415a46cd 599 i < L6474_CMD_ARG_MAX_NB_BYTES;
Davidroid 0:2887415a46cd 600 i++)
Davidroid 0:2887415a46cd 601 {
Davidroid 0:2887415a46cd 602 L6474_WriteBytes(&spiTxBursts[i], &spiRxBursts[i]);
Davidroid 0:2887415a46cd 603 }
Davidroid 0:2887415a46cd 604
Davidroid 0:2887415a46cd 605 spiRxData = ((uint32_t)spiRxBursts[1] << 16) |
Davidroid 0:2887415a46cd 606 (spiRxBursts[2] << 8) |
Davidroid 0:2887415a46cd 607 (spiRxBursts[3]);
Davidroid 0:2887415a46cd 608
Davidroid 0:2887415a46cd 609 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 610 L6474_EnableIrq();
Davidroid 0:2887415a46cd 611
Davidroid 0:2887415a46cd 612 return (spiRxData);
Davidroid 0:2887415a46cd 613 }
Davidroid 0:2887415a46cd 614
Davidroid 0:2887415a46cd 615 /******************************************************//**
Davidroid 0:2887415a46cd 616 * @brief Issues the GetStatus command to the L6474 of the specified device
Davidroid 0:2887415a46cd 617 * @retval Status Register value
Davidroid 0:2887415a46cd 618 * @note Once the GetStatus command is performed, the flags of the status register
Davidroid 0:2887415a46cd 619 * are reset. This is not the case when the status register is read with the
Davidroid 0:2887415a46cd 620 * GetParam command (via the functions L6474ReadStatusRegister or L6474CmdGetParam).
Davidroid 0:2887415a46cd 621 **********************************************************/
Davidroid 0:2887415a46cd 622 uint16_t L6474::L6474_CmdGetStatus(void)
Davidroid 0:2887415a46cd 623 {
Davidroid 0:2887415a46cd 624 uint32_t i;
Davidroid 0:2887415a46cd 625 uint16_t status;
Davidroid 0:2887415a46cd 626 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 627
Davidroid 0:2887415a46cd 628 do
Davidroid 0:2887415a46cd 629 {
Davidroid 0:2887415a46cd 630 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 631 if (itDisable)
Davidroid 0:2887415a46cd 632 {
Davidroid 0:2887415a46cd 633 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 634 L6474_EnableIrq();
Davidroid 0:2887415a46cd 635 itDisable = FALSE;
Davidroid 0:2887415a46cd 636 }
Davidroid 0:2887415a46cd 637
Davidroid 0:2887415a46cd 638 spiTxBursts[0] = L6474_NOP;
Davidroid 0:2887415a46cd 639 spiTxBursts[1] = L6474_NOP;
Davidroid 0:2887415a46cd 640 spiTxBursts[2] = L6474_NOP;
Davidroid 0:2887415a46cd 641 spiRxBursts[1] = 0;
Davidroid 0:2887415a46cd 642 spiRxBursts[2] = 0;
Davidroid 0:2887415a46cd 643 spiTxBursts[0] = L6474_GET_STATUS;
Davidroid 0:2887415a46cd 644
Davidroid 0:2887415a46cd 645 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 646 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 647 L6474_DisableIrq();
Davidroid 0:2887415a46cd 648 itDisable = TRUE;
Davidroid 0:2887415a46cd 649 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 650
Davidroid 0:2887415a46cd 651 for (i = 0; i < L6474_CMD_ARG_NB_BYTES_GET_STATUS + L6474_RSP_NB_BYTES_GET_STATUS; i++)
Davidroid 0:2887415a46cd 652 {
Davidroid 0:2887415a46cd 653 L6474_WriteBytes(&spiTxBursts[i], &spiRxBursts[i]);
Davidroid 0:2887415a46cd 654 }
Davidroid 0:2887415a46cd 655 status = (spiRxBursts[1] << 8) | (spiRxBursts[2]);
Davidroid 0:2887415a46cd 656
Davidroid 0:2887415a46cd 657 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 658 L6474_EnableIrq();
Davidroid 0:2887415a46cd 659
Davidroid 0:2887415a46cd 660 return (status);
Davidroid 0:2887415a46cd 661 }
Davidroid 0:2887415a46cd 662
Davidroid 0:2887415a46cd 663 /******************************************************//**
Davidroid 0:2887415a46cd 664 * @brief Issues the Nop command to the L6474 of the specified device
Davidroid 0:2887415a46cd 665 * @retval None
Davidroid 0:2887415a46cd 666 **********************************************************/
Davidroid 0:2887415a46cd 667 void L6474::L6474_CmdNop(void)
Davidroid 0:2887415a46cd 668 {
Davidroid 0:2887415a46cd 669 L6474_SendCommand(L6474_NOP);
Davidroid 0:2887415a46cd 670 }
Davidroid 0:2887415a46cd 671
Davidroid 0:2887415a46cd 672 /******************************************************//**
Davidroid 0:2887415a46cd 673 * @brief Issues the SetParam command to the L6474 of the specified device
Davidroid 0:2887415a46cd 674 * @param[in] param Register adress (L6474_ABS_POS, L6474_MARK,...)
Davidroid 0:2887415a46cd 675 * @param[in] value Value to set in the register
Davidroid 0:2887415a46cd 676 * @retval None
Davidroid 0:2887415a46cd 677 **********************************************************/
Davidroid 0:2887415a46cd 678 void L6474::L6474_CmdSetParam(uint32_t param, uint32_t value)
Davidroid 0:2887415a46cd 679 {
Davidroid 0:2887415a46cd 680 uint32_t i;
Davidroid 0:2887415a46cd 681 uint8_t maxArgumentNbBytes = 0;
Davidroid 0:2887415a46cd 682 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 683 do
Davidroid 0:2887415a46cd 684 {
Davidroid 0:2887415a46cd 685 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 686 if (itDisable)
Davidroid 0:2887415a46cd 687 {
Davidroid 0:2887415a46cd 688 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 689 L6474_EnableIrq();
Davidroid 0:2887415a46cd 690 itDisable = FALSE;
Davidroid 0:2887415a46cd 691 }
Davidroid 0:2887415a46cd 692
Davidroid 0:2887415a46cd 693 spiTxBursts[0] = L6474_NOP;
Davidroid 0:2887415a46cd 694 spiTxBursts[1] = L6474_NOP;
Davidroid 0:2887415a46cd 695 spiTxBursts[2] = L6474_NOP;
Davidroid 0:2887415a46cd 696 spiTxBursts[3] = L6474_NOP;
Davidroid 0:2887415a46cd 697
Davidroid 0:2887415a46cd 698 switch (param)
Davidroid 0:2887415a46cd 699 {
Davidroid 0:2887415a46cd 700 case L6474_ABS_POS: ;
Davidroid 0:2887415a46cd 701 case L6474_MARK:
Davidroid 0:2887415a46cd 702 spiTxBursts[0] = param;
Davidroid 0:2887415a46cd 703 spiTxBursts[1] = (uint8_t)(value >> 16);
Davidroid 0:2887415a46cd 704 spiTxBursts[2] = (uint8_t)(value >> 8);
Davidroid 0:2887415a46cd 705 maxArgumentNbBytes = 3;
Davidroid 0:2887415a46cd 706 break;
Davidroid 0:2887415a46cd 707 case L6474_EL_POS: ;
Davidroid 0:2887415a46cd 708 case L6474_CONFIG:
Davidroid 0:2887415a46cd 709 spiTxBursts[1] = param;
Davidroid 0:2887415a46cd 710 spiTxBursts[2] = (uint8_t)(value >> 8);
Davidroid 0:2887415a46cd 711 maxArgumentNbBytes = 2;
Davidroid 0:2887415a46cd 712 break;
Davidroid 0:2887415a46cd 713 default:
Davidroid 0:2887415a46cd 714 spiTxBursts[2] = param;
Davidroid 0:2887415a46cd 715 maxArgumentNbBytes = 1;
Davidroid 0:2887415a46cd 716 break;
Davidroid 0:2887415a46cd 717 }
Davidroid 0:2887415a46cd 718 spiTxBursts[3] = (uint8_t)(value);
Davidroid 0:2887415a46cd 719
Davidroid 0:2887415a46cd 720 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 721 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 722 L6474_DisableIrq();
Davidroid 0:2887415a46cd 723 itDisable = TRUE;
Davidroid 0:2887415a46cd 724 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 725
Davidroid 0:2887415a46cd 726 /* SPI transfer */
Davidroid 0:2887415a46cd 727 for (i = L6474_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
Davidroid 0:2887415a46cd 728 i < L6474_CMD_ARG_MAX_NB_BYTES;
Davidroid 0:2887415a46cd 729 i++)
Davidroid 0:2887415a46cd 730 {
Davidroid 0:2887415a46cd 731 L6474_WriteBytes(&spiTxBursts[i],&spiRxBursts[i]);
Davidroid 0:2887415a46cd 732 }
Davidroid 0:2887415a46cd 733 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 734 L6474_EnableIrq();
Davidroid 0:2887415a46cd 735 }
Davidroid 0:2887415a46cd 736
Davidroid 0:2887415a46cd 737 /******************************************************//**
Davidroid 0:2887415a46cd 738 * @brief Reads the Status Register value
Davidroid 0:2887415a46cd 739 * @retval Status register valued
Davidroid 0:2887415a46cd 740 * @note The status register flags are not cleared
Davidroid 0:2887415a46cd 741 * at the difference with L6474CmdGetStatus()
Davidroid 0:2887415a46cd 742 **********************************************************/
Davidroid 0:2887415a46cd 743 uint16_t L6474::L6474_ReadStatusRegister(void)
Davidroid 0:2887415a46cd 744 {
Davidroid 0:2887415a46cd 745 return (L6474_CmdGetParam(L6474_STATUS));
Davidroid 0:2887415a46cd 746 }
Davidroid 0:2887415a46cd 747
Davidroid 0:2887415a46cd 748 /******************************************************//**
Davidroid 0:2887415a46cd 749 * @brief Set the stepping mode
Davidroid 0:2887415a46cd 750 * @param[in] stepMod from full step to 1/16 microstep as specified in enum motorStepMode_t
Davidroid 0:2887415a46cd 751 * @retval None
Davidroid 0:2887415a46cd 752 **********************************************************/
Davidroid 0:2887415a46cd 753 void L6474::L6474_SelectStepMode(motorStepMode_t stepMod)
Davidroid 0:2887415a46cd 754 {
Davidroid 0:2887415a46cd 755 uint8_t stepModeRegister;
Davidroid 0:2887415a46cd 756 L6474_STEP_SEL_t l6474StepMod;
Davidroid 0:2887415a46cd 757
Davidroid 0:2887415a46cd 758 switch (stepMod)
Davidroid 0:2887415a46cd 759 {
Davidroid 0:2887415a46cd 760 case STEP_MODE_FULL:
Davidroid 0:2887415a46cd 761 l6474StepMod = L6474_STEP_SEL_1;
Davidroid 0:2887415a46cd 762 break;
Davidroid 0:2887415a46cd 763 case STEP_MODE_HALF:
Davidroid 0:2887415a46cd 764 l6474StepMod = L6474_STEP_SEL_1_2;
Davidroid 0:2887415a46cd 765 break;
Davidroid 0:2887415a46cd 766 case STEP_MODE_1_4:
Davidroid 0:2887415a46cd 767 l6474StepMod = L6474_STEP_SEL_1_4;
Davidroid 0:2887415a46cd 768 break;
Davidroid 0:2887415a46cd 769 case STEP_MODE_1_8:
Davidroid 0:2887415a46cd 770 l6474StepMod = L6474_STEP_SEL_1_8;
Davidroid 0:2887415a46cd 771 break;
Davidroid 0:2887415a46cd 772 case STEP_MODE_1_16:
Davidroid 0:2887415a46cd 773 default:
Davidroid 0:2887415a46cd 774 l6474StepMod = L6474_STEP_SEL_1_16;
Davidroid 0:2887415a46cd 775 break;
Davidroid 0:2887415a46cd 776 }
Davidroid 0:2887415a46cd 777
Davidroid 0:2887415a46cd 778 /* Eventually deactivate motor */
Davidroid 0:2887415a46cd 779 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 780 {
Davidroid 0:2887415a46cd 781 L6474_HardStop();
Davidroid 0:2887415a46cd 782 }
Davidroid 0:2887415a46cd 783
Davidroid 0:2887415a46cd 784 /* Read Step mode register and clear STEP_SEL field */
Davidroid 0:2887415a46cd 785 stepModeRegister = (uint8_t)(0xF8 & L6474_CmdGetParam(L6474_STEP_MODE)) ;
Davidroid 0:2887415a46cd 786
Davidroid 0:2887415a46cd 787 /* Apply new step mode */
Davidroid 0:2887415a46cd 788 L6474_CmdSetParam(L6474_STEP_MODE, stepModeRegister | (uint8_t)l6474StepMod);
Davidroid 0:2887415a46cd 789
Davidroid 0:2887415a46cd 790 /* Reset abs pos register */
Davidroid 0:2887415a46cd 791 L6474_SetHome();
Davidroid 0:2887415a46cd 792 }
Davidroid 0:2887415a46cd 793
Davidroid 0:2887415a46cd 794 /******************************************************//**
Davidroid 0:2887415a46cd 795 * @brief Specifies the direction
Davidroid 0:2887415a46cd 796 * @param[in] dir FORWARD or BACKWARD
Davidroid 0:2887415a46cd 797 * @note The direction change is only applied if the device
Davidroid 0:2887415a46cd 798 * is in INACTIVE state
Davidroid 0:2887415a46cd 799 * @retval None
Davidroid 0:2887415a46cd 800 **********************************************************/
Davidroid 0:2887415a46cd 801 void L6474::L6474_SetDirection(motorDir_t dir)
Davidroid 0:2887415a46cd 802 {
Davidroid 0:2887415a46cd 803 if (devicePrm.motionState == INACTIVE)
Davidroid 0:2887415a46cd 804 {
Davidroid 0:2887415a46cd 805 devicePrm.direction = dir;
Davidroid 0:2887415a46cd 806 L6474_SetDirectionGpio(dir);
Davidroid 0:2887415a46cd 807 }
Davidroid 0:2887415a46cd 808 }
Davidroid 0:2887415a46cd 809
Davidroid 0:2887415a46cd 810 /******************************************************//**
Davidroid 0:2887415a46cd 811 * @brief Updates the current speed of the device
Davidroid 0:2887415a46cd 812 * @param[in] newSpeed in pps
Davidroid 0:2887415a46cd 813 * @retval None
Davidroid 0:2887415a46cd 814 **********************************************************/
Davidroid 0:2887415a46cd 815 void L6474::L6474_ApplySpeed(uint16_t newSpeed)
Davidroid 0:2887415a46cd 816 {
Davidroid 0:2887415a46cd 817 if (newSpeed < L6474_MIN_PWM_FREQ)
Davidroid 0:2887415a46cd 818 {
Davidroid 0:2887415a46cd 819 newSpeed = L6474_MIN_PWM_FREQ;
Davidroid 0:2887415a46cd 820 }
Davidroid 0:2887415a46cd 821 if (newSpeed > L6474_MAX_PWM_FREQ)
Davidroid 0:2887415a46cd 822 {
Davidroid 0:2887415a46cd 823 newSpeed = L6474_MAX_PWM_FREQ;
Davidroid 0:2887415a46cd 824 }
Davidroid 0:2887415a46cd 825
Davidroid 0:2887415a46cd 826 devicePrm.speed = newSpeed;
Davidroid 0:2887415a46cd 827
Davidroid 0:2887415a46cd 828 L6474_PwmSetFreq(newSpeed);
Davidroid 0:2887415a46cd 829 }
Davidroid 0:2887415a46cd 830
Davidroid 0:2887415a46cd 831 /******************************************************//**
Davidroid 0:2887415a46cd 832 * @brief Computes the speed profile according to the number of steps to move
Davidroid 0:2887415a46cd 833 * @param[in] nbSteps number of steps to perform
Davidroid 0:2887415a46cd 834 * @retval None
Davidroid 0:2887415a46cd 835 * @note Using the acceleration and deceleration of the device,
Davidroid 0:2887415a46cd 836 * this function determines the duration in steps of the acceleration,
Davidroid 0:2887415a46cd 837 * steady and deceleration phases.
Davidroid 0:2887415a46cd 838 * If the total number of steps to perform is big enough, a trapezoidal move
Davidroid 0:2887415a46cd 839 * is performed (i.e. there is a steady phase where the motor runs at the maximum
Davidroid 0:2887415a46cd 840 * speed.
Davidroid 0:2887415a46cd 841 * Else, a triangular move is performed (no steady phase: the maximum speed is never
Davidroid 0:2887415a46cd 842 * reached.
Davidroid 0:2887415a46cd 843 **********************************************************/
Davidroid 0:2887415a46cd 844 void L6474::L6474_ComputeSpeedProfile(uint32_t nbSteps)
Davidroid 0:2887415a46cd 845 {
Davidroid 0:2887415a46cd 846 uint32_t reqAccSteps;
Davidroid 0:2887415a46cd 847 uint32_t reqDecSteps;
Davidroid 0:2887415a46cd 848
Davidroid 0:2887415a46cd 849 /* compute the number of steps to get the targeted speed */
Davidroid 0:2887415a46cd 850 uint16_t minSpeed = devicePrm.minSpeed;
Davidroid 0:2887415a46cd 851 reqAccSteps = (devicePrm.maxSpeed - minSpeed);
Davidroid 0:2887415a46cd 852 reqAccSteps *= (devicePrm.maxSpeed + minSpeed);
Davidroid 0:2887415a46cd 853 reqDecSteps = reqAccSteps;
Davidroid 0:2887415a46cd 854 reqAccSteps /= (uint32_t)devicePrm.acceleration;
Davidroid 0:2887415a46cd 855 reqAccSteps /= 2;
Davidroid 0:2887415a46cd 856
Davidroid 0:2887415a46cd 857 /* compute the number of steps to stop */
Davidroid 0:2887415a46cd 858 reqDecSteps /= (uint32_t)devicePrm.deceleration;
Davidroid 0:2887415a46cd 859 reqDecSteps /= 2;
Davidroid 0:2887415a46cd 860
Davidroid 0:2887415a46cd 861 if(( reqAccSteps + reqDecSteps ) > nbSteps)
Davidroid 0:2887415a46cd 862 {
Davidroid 0:2887415a46cd 863 /* Triangular move */
Davidroid 0:2887415a46cd 864 /* reqDecSteps = (Pos * Dec) /(Dec+Acc) */
Davidroid 0:2887415a46cd 865 uint32_t dec = devicePrm.deceleration;
Davidroid 0:2887415a46cd 866 uint32_t acc = devicePrm.acceleration;
Davidroid 0:2887415a46cd 867
Davidroid 0:2887415a46cd 868 reqDecSteps = ((uint32_t) dec * nbSteps) / (acc + dec);
Davidroid 0:2887415a46cd 869 if (reqDecSteps > 1)
Davidroid 0:2887415a46cd 870 {
Davidroid 0:2887415a46cd 871 reqAccSteps = reqDecSteps - 1;
Davidroid 0:2887415a46cd 872 if(reqAccSteps == 0)
Davidroid 0:2887415a46cd 873 {
Davidroid 0:2887415a46cd 874 reqAccSteps = 1;
Davidroid 0:2887415a46cd 875 }
Davidroid 0:2887415a46cd 876 }
Davidroid 0:2887415a46cd 877 else
Davidroid 0:2887415a46cd 878 {
Davidroid 0:2887415a46cd 879 reqAccSteps = 0;
Davidroid 0:2887415a46cd 880 }
Davidroid 0:2887415a46cd 881 devicePrm.endAccPos = reqAccSteps;
Davidroid 0:2887415a46cd 882 devicePrm.startDecPos = reqDecSteps;
Davidroid 0:2887415a46cd 883 }
Davidroid 0:2887415a46cd 884 else
Davidroid 0:2887415a46cd 885 {
Davidroid 0:2887415a46cd 886 /* Trapezoidal move */
Davidroid 0:2887415a46cd 887 /* accelerating phase to endAccPos */
Davidroid 0:2887415a46cd 888 /* steady phase from endAccPos to startDecPos */
Davidroid 0:2887415a46cd 889 /* decelerating from startDecPos to stepsToTake*/
Davidroid 0:2887415a46cd 890 devicePrm.endAccPos = reqAccSteps;
Davidroid 0:2887415a46cd 891 devicePrm.startDecPos = nbSteps - reqDecSteps - 1;
Davidroid 0:2887415a46cd 892 }
Davidroid 0:2887415a46cd 893 }
Davidroid 0:2887415a46cd 894
Davidroid 0:2887415a46cd 895 /******************************************************//**
Davidroid 0:2887415a46cd 896 * @brief Converts the ABS_POSITION register value to a 32b signed integer
Davidroid 0:2887415a46cd 897 * @param[in] abs_position_reg value of the ABS_POSITION register
Davidroid 0:2887415a46cd 898 * @retval operation_result 32b signed integer corresponding to the absolute position
Davidroid 0:2887415a46cd 899 **********************************************************/
Davidroid 0:2887415a46cd 900 int32_t L6474::L6474_ConvertPosition(uint32_t abs_position_reg)
Davidroid 0:2887415a46cd 901 {
Davidroid 0:2887415a46cd 902 int32_t operation_result;
Davidroid 0:2887415a46cd 903
Davidroid 0:2887415a46cd 904 if (abs_position_reg & L6474_ABS_POS_SIGN_BIT_MASK)
Davidroid 0:2887415a46cd 905 {
Davidroid 0:2887415a46cd 906 /* Negative register value */
Davidroid 0:2887415a46cd 907 abs_position_reg = ~abs_position_reg;
Davidroid 0:2887415a46cd 908 abs_position_reg += 1;
Davidroid 0:2887415a46cd 909
Davidroid 0:2887415a46cd 910 operation_result = (int32_t) (abs_position_reg & L6474_ABS_POS_VALUE_MASK);
Davidroid 0:2887415a46cd 911 operation_result = -operation_result;
Davidroid 0:2887415a46cd 912 }
Davidroid 0:2887415a46cd 913 else
Davidroid 0:2887415a46cd 914 {
Davidroid 0:2887415a46cd 915 operation_result = (int32_t) abs_position_reg;
Davidroid 0:2887415a46cd 916 }
Davidroid 0:2887415a46cd 917 return operation_result;
Davidroid 0:2887415a46cd 918 }
Davidroid 0:2887415a46cd 919
Davidroid 0:2887415a46cd 920 /******************************************************//**
Davidroid 0:2887415a46cd 921 * @brief Error handler which calls the user callback (if defined)
Davidroid 0:2887415a46cd 922 * @param[in] error Number of the error
Davidroid 0:2887415a46cd 923 * @retval None
Davidroid 0:2887415a46cd 924 **********************************************************/
Davidroid 0:2887415a46cd 925 void L6474::L6474_ErrorHandler(uint16_t error)
Davidroid 0:2887415a46cd 926 {
Davidroid 0:2887415a46cd 927 if (errorHandlerCallback != 0)
Davidroid 0:2887415a46cd 928 {
Davidroid 0:2887415a46cd 929 (void) errorHandlerCallback(error);
Davidroid 0:2887415a46cd 930 }
Davidroid 0:2887415a46cd 931 else
Davidroid 0:2887415a46cd 932 {
Davidroid 0:2887415a46cd 933 while(1)
Davidroid 0:2887415a46cd 934 {
Davidroid 0:2887415a46cd 935 /* Infinite loop */
Davidroid 0:2887415a46cd 936 }
Davidroid 0:2887415a46cd 937 }
Davidroid 0:2887415a46cd 938 }
Davidroid 0:2887415a46cd 939
Davidroid 0:2887415a46cd 940 /******************************************************//**
Davidroid 0:2887415a46cd 941 * @brief Handlers of the flag interrupt which calls the user callback (if defined)
Davidroid 0:2887415a46cd 942 * @param None
Davidroid 0:2887415a46cd 943 * @retval None
Davidroid 0:2887415a46cd 944 **********************************************************/
Davidroid 0:2887415a46cd 945 void L6474::L6474_FlagInterruptHandler(void)
Davidroid 0:2887415a46cd 946 {
Davidroid 0:2887415a46cd 947 if (flagInterruptCallback != 0)
Davidroid 0:2887415a46cd 948 {
Davidroid 0:2887415a46cd 949 /* Set isr flag */
Davidroid 0:2887415a46cd 950 isrFlag = TRUE;
Davidroid 0:2887415a46cd 951
Davidroid 0:2887415a46cd 952 flagInterruptCallback();
Davidroid 0:2887415a46cd 953
Davidroid 0:2887415a46cd 954 /* Reset isr flag */
Davidroid 0:2887415a46cd 955 isrFlag = FALSE;
Davidroid 0:2887415a46cd 956 }
Davidroid 0:2887415a46cd 957 }
Davidroid 0:2887415a46cd 958
Davidroid 0:2887415a46cd 959 /******************************************************//**
Davidroid 0:2887415a46cd 960 * @brief Sends a command without arguments to the L6474 via the SPI
Davidroid 0:2887415a46cd 961 * @param[in] param Command to send
Davidroid 0:2887415a46cd 962 * @retval None
Davidroid 0:2887415a46cd 963 **********************************************************/
Davidroid 0:2887415a46cd 964 void L6474::L6474_SendCommand(uint8_t param)
Davidroid 0:2887415a46cd 965 {
Davidroid 0:2887415a46cd 966 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 967
Davidroid 0:2887415a46cd 968 do
Davidroid 0:2887415a46cd 969 {
Davidroid 0:2887415a46cd 970 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 971 if (itDisable)
Davidroid 0:2887415a46cd 972 {
Davidroid 0:2887415a46cd 973 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 974 L6474_EnableIrq();
Davidroid 0:2887415a46cd 975 itDisable = FALSE;
Davidroid 0:2887415a46cd 976 }
Davidroid 0:2887415a46cd 977
Davidroid 0:2887415a46cd 978 spiTxBursts[3] = L6474_NOP;
Davidroid 0:2887415a46cd 979 spiTxBursts[3] = param;
Davidroid 0:2887415a46cd 980
Davidroid 0:2887415a46cd 981 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 982 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 983 L6474_DisableIrq();
Davidroid 0:2887415a46cd 984 itDisable = TRUE;
Davidroid 0:2887415a46cd 985 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 986
Davidroid 0:2887415a46cd 987 L6474_WriteBytes(&spiTxBursts[3], &spiRxBursts[3]);
Davidroid 0:2887415a46cd 988
Davidroid 0:2887415a46cd 989 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 990 L6474_EnableIrq();
Davidroid 0:2887415a46cd 991 }
Davidroid 0:2887415a46cd 992
Davidroid 0:2887415a46cd 993 /******************************************************//**
Davidroid 0:2887415a46cd 994 * @brief Sets the registers of the L6474 to their predefined values
Davidroid 0:2887415a46cd 995 * from l6474_target_config.h
Davidroid 0:2887415a46cd 996 * @retval None
Davidroid 0:2887415a46cd 997 **********************************************************/
Davidroid 0:2887415a46cd 998 void L6474::L6474_SetRegisterToPredefinedValues(void)
Davidroid 0:2887415a46cd 999 {
Davidroid 0:2887415a46cd 1000 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1001 L6474_ABS_POS,
Davidroid 0:2887415a46cd 1002 0);
Davidroid 0:2887415a46cd 1003 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1004 L6474_EL_POS,
Davidroid 0:2887415a46cd 1005 0);
Davidroid 0:2887415a46cd 1006 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1007 L6474_MARK,
Davidroid 0:2887415a46cd 1008 0);
Davidroid 0:2887415a46cd 1009 switch (deviceInstance)
Davidroid 0:2887415a46cd 1010 {
Davidroid 0:2887415a46cd 1011 case 0:
Davidroid 0:2887415a46cd 1012 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1013 L6474_TVAL,
Davidroid 0:2887415a46cd 1014 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_0));
Davidroid 0:2887415a46cd 1015 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1016 L6474_T_FAST,
Davidroid 0:2887415a46cd 1017 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_0 |
Davidroid 0:2887415a46cd 1018 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_0);
Davidroid 0:2887415a46cd 1019 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1020 L6474_TON_MIN,
Davidroid 0:2887415a46cd 1021 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_0)
Davidroid 0:2887415a46cd 1022 );
Davidroid 0:2887415a46cd 1023 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1024 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1025 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_0));
Davidroid 0:2887415a46cd 1026 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1027 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1028 L6474_CONF_PARAM_OCD_TH_DEVICE_0);
Davidroid 0:2887415a46cd 1029 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1030 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1031 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_0 |
Davidroid 0:2887415a46cd 1032 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_0);
Davidroid 0:2887415a46cd 1033 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1034 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1035 L6474_CONF_PARAM_ALARM_EN_DEVICE_0);
Davidroid 0:2887415a46cd 1036 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1037 L6474_CONFIG,
Davidroid 0:2887415a46cd 1038 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_0 |
Davidroid 0:2887415a46cd 1039 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_0 |
Davidroid 0:2887415a46cd 1040 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_0 |
Davidroid 0:2887415a46cd 1041 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_0 |
Davidroid 0:2887415a46cd 1042 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_0);
Davidroid 0:2887415a46cd 1043 break;
Davidroid 0:2887415a46cd 1044 case 1:
Davidroid 0:2887415a46cd 1045 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1046 L6474_TVAL,
Davidroid 0:2887415a46cd 1047 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_1));
Davidroid 0:2887415a46cd 1048 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1049 L6474_T_FAST,
Davidroid 0:2887415a46cd 1050 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_1 |
Davidroid 0:2887415a46cd 1051 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_1);
Davidroid 0:2887415a46cd 1052 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1053 L6474_TON_MIN,
Davidroid 0:2887415a46cd 1054 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_1));
Davidroid 0:2887415a46cd 1055 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1056 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1057 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_1));
Davidroid 0:2887415a46cd 1058 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1059 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1060 L6474_CONF_PARAM_OCD_TH_DEVICE_1);
Davidroid 0:2887415a46cd 1061 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1062 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1063 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_1 |
Davidroid 0:2887415a46cd 1064 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_1);
Davidroid 0:2887415a46cd 1065 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1066 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1067 L6474_CONF_PARAM_ALARM_EN_DEVICE_1);
Davidroid 0:2887415a46cd 1068 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1069 L6474_CONFIG,
Davidroid 0:2887415a46cd 1070 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_1 |
Davidroid 0:2887415a46cd 1071 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_1 |
Davidroid 0:2887415a46cd 1072 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_1 |
Davidroid 0:2887415a46cd 1073 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_1 |
Davidroid 0:2887415a46cd 1074 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_1);
Davidroid 0:2887415a46cd 1075 break;
Davidroid 0:2887415a46cd 1076 case 2:
Davidroid 0:2887415a46cd 1077 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1078 L6474_TVAL,
Davidroid 0:2887415a46cd 1079 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_2));
Davidroid 0:2887415a46cd 1080 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1081 L6474_T_FAST,
Davidroid 0:2887415a46cd 1082 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_2 |
Davidroid 0:2887415a46cd 1083 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_2);
Davidroid 0:2887415a46cd 1084 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1085 L6474_TON_MIN,
Davidroid 0:2887415a46cd 1086 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_2));
Davidroid 0:2887415a46cd 1087 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1088 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1089 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_2));
Davidroid 0:2887415a46cd 1090 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1091 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1092 L6474_CONF_PARAM_OCD_TH_DEVICE_2);
Davidroid 0:2887415a46cd 1093 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1094 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1095 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_2 |
Davidroid 0:2887415a46cd 1096 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_2);
Davidroid 0:2887415a46cd 1097 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1098 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1099 L6474_CONF_PARAM_ALARM_EN_DEVICE_2);
Davidroid 0:2887415a46cd 1100 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1101 L6474_CONFIG,
Davidroid 0:2887415a46cd 1102 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_2 |
Davidroid 0:2887415a46cd 1103 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_2 |
Davidroid 0:2887415a46cd 1104 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_2 |
Davidroid 0:2887415a46cd 1105 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_2 |
Davidroid 0:2887415a46cd 1106 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_2);
Davidroid 0:2887415a46cd 1107 break;
Davidroid 0:2887415a46cd 1108 default: ;
Davidroid 0:2887415a46cd 1109 }
Davidroid 0:2887415a46cd 1110 }
Davidroid 0:2887415a46cd 1111
Davidroid 0:2887415a46cd 1112 /******************************************************//**
Davidroid 0:2887415a46cd 1113 * @brief Sets the parameters of the device to predefined values
Davidroid 0:2887415a46cd 1114 * from l6474_target_config.h
Davidroid 0:2887415a46cd 1115 * @param None
Davidroid 0:2887415a46cd 1116 * @retval None
Davidroid 0:2887415a46cd 1117 **********************************************************/
Davidroid 0:2887415a46cd 1118 void L6474::L6474_SetDeviceParamsToPredefinedValues(void)
Davidroid 0:2887415a46cd 1119 {
Davidroid 0:2887415a46cd 1120 switch (deviceInstance)
Davidroid 0:2887415a46cd 1121 {
Davidroid 0:2887415a46cd 1122 case 0:
Davidroid 0:2887415a46cd 1123 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_0;
Davidroid 0:2887415a46cd 1124 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_0;
Davidroid 0:2887415a46cd 1125 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_0;
Davidroid 0:2887415a46cd 1126 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_0;
Davidroid 0:2887415a46cd 1127 break;
Davidroid 0:2887415a46cd 1128
Davidroid 0:2887415a46cd 1129 case 1:
Davidroid 0:2887415a46cd 1130 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_1;
Davidroid 0:2887415a46cd 1131 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_1;
Davidroid 0:2887415a46cd 1132 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_1;
Davidroid 0:2887415a46cd 1133 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_1;
Davidroid 0:2887415a46cd 1134 break;
Davidroid 0:2887415a46cd 1135
Davidroid 0:2887415a46cd 1136 case 2:
Davidroid 0:2887415a46cd 1137 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_2;
Davidroid 0:2887415a46cd 1138 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_2;
Davidroid 0:2887415a46cd 1139 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_2;
Davidroid 0:2887415a46cd 1140 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_2;
Davidroid 0:2887415a46cd 1141 break;
Davidroid 0:2887415a46cd 1142 }
Davidroid 0:2887415a46cd 1143
Davidroid 0:2887415a46cd 1144 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1145 devicePrm.currentPosition = 0;
Davidroid 0:2887415a46cd 1146 devicePrm.endAccPos = 0;
Davidroid 0:2887415a46cd 1147 devicePrm.relativePos = 0;
Davidroid 0:2887415a46cd 1148 devicePrm.startDecPos = 0;
Davidroid 0:2887415a46cd 1149 devicePrm.stepsToTake = 0;
Davidroid 0:2887415a46cd 1150 devicePrm.speed = 0;
Davidroid 0:2887415a46cd 1151 devicePrm.commandExecuted = NO_CMD;
Davidroid 0:2887415a46cd 1152 devicePrm.direction = FORWARD;
Davidroid 0:2887415a46cd 1153 devicePrm.motionState = INACTIVE;
Davidroid 0:2887415a46cd 1154
Davidroid 0:2887415a46cd 1155 L6474_SetRegisterToPredefinedValues();
Davidroid 0:2887415a46cd 1156 }
Davidroid 0:2887415a46cd 1157
Davidroid 0:2887415a46cd 1158 /******************************************************//**
Davidroid 0:2887415a46cd 1159 * @brief Initialises the bridge parameters to start the movement
Davidroid 0:2887415a46cd 1160 * and enable the power bridge
Davidroid 0:2887415a46cd 1161 * @retval None
Davidroid 0:2887415a46cd 1162 **********************************************************/
Davidroid 0:2887415a46cd 1163 void L6474::L6474_StartMovement(void)
Davidroid 0:2887415a46cd 1164 {
Davidroid 0:2887415a46cd 1165 /* Enable L6474 powerstage */
Davidroid 0:2887415a46cd 1166 L6474_CmdEnable();
Davidroid 0:2887415a46cd 1167 if (devicePrm.endAccPos != 0)
Davidroid 0:2887415a46cd 1168 {
Davidroid 0:2887415a46cd 1169 devicePrm.motionState = ACCELERATING;
Davidroid 0:2887415a46cd 1170 }
Davidroid 0:2887415a46cd 1171 else
Davidroid 0:2887415a46cd 1172 {
Davidroid 0:2887415a46cd 1173 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1174 }
Davidroid 0:2887415a46cd 1175 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1176 devicePrm.relativePos = 0;
Davidroid 0:2887415a46cd 1177 L6474_ApplySpeed(devicePrm.minSpeed);
Davidroid 0:2887415a46cd 1178 }
Davidroid 0:2887415a46cd 1179
Davidroid 0:2887415a46cd 1180 /******************************************************//**
Davidroid 0:2887415a46cd 1181 * @brief Handles the device state machine at each ste
Davidroid 0:2887415a46cd 1182 * @retval None
Davidroid 0:2887415a46cd 1183 * @note Must only be called by the timer ISR
Davidroid 0:2887415a46cd 1184 **********************************************************/
Davidroid 0:2887415a46cd 1185 void L6474::L6474_StepClockHandler(void)
Davidroid 0:2887415a46cd 1186 {
Davidroid 0:2887415a46cd 1187 /* Set isr flag */
Davidroid 0:2887415a46cd 1188 isrFlag = TRUE;
Davidroid 0:2887415a46cd 1189
Davidroid 0:2887415a46cd 1190 /* Incrementation of the relative position */
Davidroid 0:2887415a46cd 1191 devicePrm.relativePos++;
Davidroid 0:2887415a46cd 1192
Davidroid 0:2887415a46cd 1193 switch (devicePrm.motionState)
Davidroid 0:2887415a46cd 1194 {
Davidroid 0:2887415a46cd 1195 case ACCELERATING:
Davidroid 0:2887415a46cd 1196 {
Davidroid 0:2887415a46cd 1197 uint32_t relPos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1198 uint32_t endAccPos = devicePrm.endAccPos;
Davidroid 0:2887415a46cd 1199 uint16_t speed = devicePrm.speed;
Davidroid 0:2887415a46cd 1200 uint32_t acc = ((uint32_t)devicePrm.acceleration << 16);
Davidroid 0:2887415a46cd 1201
Davidroid 0:2887415a46cd 1202 if ((devicePrm.commandExecuted == SOFT_STOP_CMD)||
Davidroid 0:2887415a46cd 1203 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1204 (relPos == devicePrm.startDecPos)))
Davidroid 0:2887415a46cd 1205 {
Davidroid 0:2887415a46cd 1206 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1207 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1208 }
Davidroid 0:2887415a46cd 1209 else if ((speed >= devicePrm.maxSpeed)||
Davidroid 0:2887415a46cd 1210 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1211 (relPos == endAccPos)))
Davidroid 0:2887415a46cd 1212 {
Davidroid 0:2887415a46cd 1213 devicePrm.motionState = STEADY;
Davidroid 0:2887415a46cd 1214 }
Davidroid 0:2887415a46cd 1215 else
Davidroid 0:2887415a46cd 1216 {
Davidroid 0:2887415a46cd 1217 bool speedUpdated = FALSE;
Davidroid 0:2887415a46cd 1218 /* Go on accelerating */
Davidroid 0:2887415a46cd 1219 if (speed == 0) speed =1;
Davidroid 0:2887415a46cd 1220 devicePrm.accu += acc / speed;
Davidroid 0:2887415a46cd 1221 while (devicePrm.accu >= (0X10000L))
Davidroid 0:2887415a46cd 1222 {
Davidroid 0:2887415a46cd 1223 devicePrm.accu -= (0X10000L);
Davidroid 0:2887415a46cd 1224 speed +=1;
Davidroid 0:2887415a46cd 1225 speedUpdated = TRUE;
Davidroid 0:2887415a46cd 1226 }
Davidroid 0:2887415a46cd 1227
Davidroid 0:2887415a46cd 1228 if (speedUpdated)
Davidroid 0:2887415a46cd 1229 {
Davidroid 0:2887415a46cd 1230 if (speed > devicePrm.maxSpeed)
Davidroid 0:2887415a46cd 1231 {
Davidroid 0:2887415a46cd 1232 speed = devicePrm.maxSpeed;
Davidroid 0:2887415a46cd 1233 }
Davidroid 0:2887415a46cd 1234 devicePrm.speed = speed;
Davidroid 0:2887415a46cd 1235 L6474_ApplySpeed(devicePrm.speed);
Davidroid 0:2887415a46cd 1236 }
Davidroid 0:2887415a46cd 1237 }
Davidroid 0:2887415a46cd 1238 break;
Davidroid 0:2887415a46cd 1239 }
Davidroid 0:2887415a46cd 1240 case STEADY:
Davidroid 0:2887415a46cd 1241 {
Davidroid 0:2887415a46cd 1242 uint16_t maxSpeed = devicePrm.maxSpeed;
Davidroid 0:2887415a46cd 1243 uint32_t relativePos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1244 if ((devicePrm.commandExecuted == SOFT_STOP_CMD)||
Davidroid 0:2887415a46cd 1245 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1246 (relativePos >= (devicePrm.startDecPos))) ||
Davidroid 0:2887415a46cd 1247 ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1248 (devicePrm.speed > maxSpeed)))
Davidroid 0:2887415a46cd 1249 {
Davidroid 0:2887415a46cd 1250 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1251 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1252 }
Davidroid 0:2887415a46cd 1253 else if ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1254 (devicePrm.speed < maxSpeed))
Davidroid 0:2887415a46cd 1255 {
Davidroid 0:2887415a46cd 1256 devicePrm.motionState = ACCELERATING;
Davidroid 0:2887415a46cd 1257 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1258 }
Davidroid 0:2887415a46cd 1259 break;
Davidroid 0:2887415a46cd 1260 }
Davidroid 0:2887415a46cd 1261 case DECELERATING:
Davidroid 0:2887415a46cd 1262 {
Davidroid 0:2887415a46cd 1263 uint32_t relativePos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1264 uint16_t speed = devicePrm.speed;
Davidroid 0:2887415a46cd 1265 uint32_t deceleration = ((uint32_t)devicePrm.deceleration << 16);
Davidroid 0:2887415a46cd 1266 if (((devicePrm.commandExecuted == SOFT_STOP_CMD)&&(speed <= devicePrm.minSpeed))||
Davidroid 0:2887415a46cd 1267 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1268 (relativePos >= devicePrm.stepsToTake)))
Davidroid 0:2887415a46cd 1269 {
Davidroid 0:2887415a46cd 1270 /* Motion process complete */
Davidroid 0:2887415a46cd 1271 L6474_HardStop();
Davidroid 0:2887415a46cd 1272 }
Davidroid 0:2887415a46cd 1273 else if ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1274 (speed <= devicePrm.maxSpeed))
Davidroid 0:2887415a46cd 1275 {
Davidroid 0:2887415a46cd 1276 devicePrm.motionState = STEADY;
Davidroid 0:2887415a46cd 1277 }
Davidroid 0:2887415a46cd 1278 else
Davidroid 0:2887415a46cd 1279 {
Davidroid 0:2887415a46cd 1280 /* Go on decelerating */
Davidroid 0:2887415a46cd 1281 if (speed > devicePrm.minSpeed)
Davidroid 0:2887415a46cd 1282 {
Davidroid 0:2887415a46cd 1283 bool speedUpdated = FALSE;
Davidroid 0:2887415a46cd 1284 if (speed == 0) speed =1;
Davidroid 0:2887415a46cd 1285 devicePrm.accu += deceleration / speed;
Davidroid 0:2887415a46cd 1286 while (devicePrm.accu >= (0X10000L))
Davidroid 0:2887415a46cd 1287 {
Davidroid 0:2887415a46cd 1288 devicePrm.accu -= (0X10000L);
Davidroid 0:2887415a46cd 1289 if (speed > 1)
Davidroid 0:2887415a46cd 1290 {
Davidroid 0:2887415a46cd 1291 speed -=1;
Davidroid 0:2887415a46cd 1292 }
Davidroid 0:2887415a46cd 1293 speedUpdated = TRUE;
Davidroid 0:2887415a46cd 1294 }
Davidroid 0:2887415a46cd 1295
Davidroid 0:2887415a46cd 1296 if (speedUpdated)
Davidroid 0:2887415a46cd 1297 {
Davidroid 0:2887415a46cd 1298 if (speed < devicePrm.minSpeed)
Davidroid 0:2887415a46cd 1299 {
Davidroid 0:2887415a46cd 1300 speed = devicePrm.minSpeed;
Davidroid 0:2887415a46cd 1301 }
Davidroid 0:2887415a46cd 1302 devicePrm.speed = speed;
Davidroid 0:2887415a46cd 1303 L6474_ApplySpeed(devicePrm.speed);
Davidroid 0:2887415a46cd 1304 }
Davidroid 0:2887415a46cd 1305 }
Davidroid 0:2887415a46cd 1306 }
Davidroid 0:2887415a46cd 1307 break;
Davidroid 0:2887415a46cd 1308 }
Davidroid 0:2887415a46cd 1309 default:
Davidroid 0:2887415a46cd 1310 {
Davidroid 0:2887415a46cd 1311 break;
Davidroid 0:2887415a46cd 1312 }
Davidroid 0:2887415a46cd 1313 }
Davidroid 0:2887415a46cd 1314 /* Set isr flag */
Davidroid 0:2887415a46cd 1315 isrFlag = FALSE;
Davidroid 0:2887415a46cd 1316 }
Davidroid 0:2887415a46cd 1317
Davidroid 0:2887415a46cd 1318 /******************************************************//**
Davidroid 0:2887415a46cd 1319 * @brief Converts mA in compatible values for TVAL register
Davidroid 0:2887415a46cd 1320 * @param[in] Tval
Davidroid 0:2887415a46cd 1321 * @retval TVAL values
Davidroid 0:2887415a46cd 1322 **********************************************************/
Davidroid 0:2887415a46cd 1323 uint8_t L6474::L6474_Tval_Current_to_Par(double Tval)
Davidroid 0:2887415a46cd 1324 {
Davidroid 0:2887415a46cd 1325 return ((uint8_t)(((Tval - 31.25)/31.25)+0.5));
Davidroid 0:2887415a46cd 1326 }
Davidroid 0:2887415a46cd 1327
Davidroid 0:2887415a46cd 1328 /******************************************************//**
Davidroid 0:2887415a46cd 1329 * @brief Convert time in us in compatible values
Davidroid 0:2887415a46cd 1330 * for TON_MIN register
Davidroid 0:2887415a46cd 1331 * @param[in] Tmin
Davidroid 0:2887415a46cd 1332 * @retval TON_MIN values
Davidroid 0:2887415a46cd 1333 **********************************************************/
Davidroid 0:2887415a46cd 1334 uint8_t L6474::L6474_Tmin_Time_to_Par(double Tmin)
Davidroid 0:2887415a46cd 1335 {
Davidroid 0:2887415a46cd 1336 return ((uint8_t)(((Tmin - 0.5)*2)+0.5));
Davidroid 0:2887415a46cd 1337 }
Davidroid 0:2887415a46cd 1338
Davidroid 0:2887415a46cd 1339 /******************************************************//**
Davidroid 0:2887415a46cd 1340 * @brief Write and receive a byte via SPI
Davidroid 0:2887415a46cd 1341 * @param[in] pByteToTransmit pointer to the byte to transmit
Davidroid 0:2887415a46cd 1342 * @param[in] pReceivedByte pointer to the received byte
Davidroid 0:2887415a46cd 1343 * @retval None
Davidroid 0:2887415a46cd 1344 **********************************************************/
Davidroid 0:2887415a46cd 1345 void L6474::L6474_WriteBytes(uint8_t *pByteToTransmit, uint8_t *pReceivedByte)
Davidroid 0:2887415a46cd 1346 {
Davidroid 0:2887415a46cd 1347 if (L6474_SpiWriteBytes(pByteToTransmit, pReceivedByte) != 0)
Davidroid 0:2887415a46cd 1348 {
Davidroid 0:2887415a46cd 1349 L6474_ErrorHandler(L6474_ERROR_1);
Davidroid 0:2887415a46cd 1350 }
Davidroid 0:2887415a46cd 1351
Davidroid 0:2887415a46cd 1352 if (isrFlag)
Davidroid 0:2887415a46cd 1353 {
Davidroid 0:2887415a46cd 1354 spiPreemtionByIsr = TRUE;
Davidroid 0:2887415a46cd 1355 }
Davidroid 0:2887415a46cd 1356 }
Davidroid 0:2887415a46cd 1357
Davidroid 0:2887415a46cd 1358 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/