X_NUCLEO_IHM01A1_Disabled_Control - Personal fork of the library for direct control i…

Users » Arkadi » Code » X_NUCLEO_IHM01A1_Disabled_Control

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@6:a47569fc7534, 2015-11-19 (annotated)

Committer:: Davidroid
Date:: Thu Nov 19 10:56:34 2015 +0000
Revision:: 6:a47569fc7534
Parent:: 5:d3c78f12a78d
Child:: 7:f7e0c3621f77

Set ISR flags as static members.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	24 May 2017
Imports:	0
Forks:	0
Commits:	27
Dependents:	1
Dependencies:	1
Followers:	1

Components/l6474/l6474_class.cpp@6:a47569fc7534, 2015-11-19 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning