ST » Code » X-NUCLEO-IHM05A1

Expansion SW library to control a bipolar stepper motor using X-NUCLEO-IHM05A1 expansion board based on L6208.

Dependents: HelloWorld_IHM05A1 TAU_ROTATING_PLATFORM_IHM05A1 Amaldi_13_Exercise_IHM05A1 Amaldi_13_Exercise_IHM05A1motore ... more

Fork of X-NUCLEO-IHM05A1 by ST Expansion SW Team

Motor Control Library

Library to handle the X-NUCLEO-IHM05A1 Motor Control Expansion Board based on the L6208 component.

It features the:

Read and write of device parameters
Configuration of GPIOs and IRQs (for enabling, direction, current decay and microstepping)
Control of position, speed, acceleration and deceleration
Command locking until the device completes movement
Handling of overcurrent and thermal alarms (flag interrupt handling)

The API allows to easily:

perform various positioning, moves and stops
get/set or monitor the motor positions
set home position and mark another position
get/set minimum and maximum speed
get current speed
get/set acceleration and deceleration
get/set the step mode (up to 1/16)

Board configuration

/media/uploads/nucleosam/mbed-x-nucleo-ihm05a1.png

Platform compatibility

Compatible platforms have been tested with the configurations provided by the HelloWorld_IHM05A1 example.

Components/l6208/l6208_class.cpp@1:5cc2691ccfff, 2016-04-27 (annotated)

Committer:: nucleosam
Date:: Wed Apr 27 16:30:55 2016 +0000
Revision:: 1:5cc2691ccfff
Parent:: 0:52a66fac0f64

Initial version tested on NUCLEO-F401RE and NUCLEO-F334R8

Who changed what in which revision?

User	Revision	Line number	New contents of line
nucleosam	1:5cc2691ccfff	1	/**
nucleosam	1:5cc2691ccfff	2	******************************************************************************
nucleosam	1:5cc2691ccfff	3	* @file l6208_class.cpp
nucleosam	1:5cc2691ccfff	4	* @author IPC Rennes
nucleosam	1:5cc2691ccfff	5	* @version V1.1.0
nucleosam	1:5cc2691ccfff	6	* @date February 11th, 2016
nucleosam	1:5cc2691ccfff	7	* @brief L6208 product related routines
nucleosam	1:5cc2691ccfff	8	* @note (C) COPYRIGHT 2016 STMicroelectronics
nucleosam	1:5cc2691ccfff	9	******************************************************************************
nucleosam	1:5cc2691ccfff	10	* @attention
nucleosam	1:5cc2691ccfff	11	*
nucleosam	1:5cc2691ccfff	12	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
nucleosam	1:5cc2691ccfff	13	*
nucleosam	1:5cc2691ccfff	14	* Redistribution and use in source and binary forms, with or without modification,
nucleosam	1:5cc2691ccfff	15	* are permitted provided that the following conditions are met:
nucleosam	1:5cc2691ccfff	16	* 1. Redistributions of source code must retain the above copyright notice,
nucleosam	1:5cc2691ccfff	17	* this list of conditions and the following disclaimer.
nucleosam	1:5cc2691ccfff	18	* 2. Redistributions in binary form must reproduce the above copyright notice,
nucleosam	1:5cc2691ccfff	19	* this list of conditions and the following disclaimer in the documentation
nucleosam	1:5cc2691ccfff	20	* and/or other materials provided with the distribution.
nucleosam	1:5cc2691ccfff	21	* 3. Neither the name of STMicroelectronics nor the names of its contributors
nucleosam	1:5cc2691ccfff	22	* may be used to endorse or promote products derived from this software
nucleosam	1:5cc2691ccfff	23	* without specific prior written permission.
nucleosam	1:5cc2691ccfff	24	*
nucleosam	1:5cc2691ccfff	25	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
nucleosam	1:5cc2691ccfff	26	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
nucleosam	1:5cc2691ccfff	27	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
nucleosam	1:5cc2691ccfff	28	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
nucleosam	1:5cc2691ccfff	29	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
nucleosam	1:5cc2691ccfff	30	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
nucleosam	1:5cc2691ccfff	31	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
nucleosam	1:5cc2691ccfff	32	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
nucleosam	1:5cc2691ccfff	33	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
nucleosam	1:5cc2691ccfff	34	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nucleosam	1:5cc2691ccfff	35	*
nucleosam	1:5cc2691ccfff	36	******************************************************************************
nucleosam	1:5cc2691ccfff	37	*/
nucleosam	1:5cc2691ccfff	38
nucleosam	1:5cc2691ccfff	39	/* Includes ------------------------------------------------------------------*/
nucleosam	1:5cc2691ccfff	40	#include "l6208_class.h"
nucleosam	1:5cc2691ccfff	41
nucleosam	1:5cc2691ccfff	42	/* Definitions ---------------------------------------------------------------*/
nucleosam	1:5cc2691ccfff	43	/// Bridge A
nucleosam	1:5cc2691ccfff	44	#define BRIDGE_A (0)
nucleosam	1:5cc2691ccfff	45	/// Bridge B
nucleosam	1:5cc2691ccfff	46	#define BRIDGE_B (1)
nucleosam	1:5cc2691ccfff	47
nucleosam	1:5cc2691ccfff	48	/// Bitmaps for system flags
nucleosam	1:5cc2691ccfff	49	#define EN_A_set 0x00000001 ///< EN_A pin status
nucleosam	1:5cc2691ccfff	50	#define HiZstop 0x00000002 ///< motor has to be left in HiZ after stopping
nucleosam	1:5cc2691ccfff	51	#define busy 0x00000004 ///< stepper position command executing flag
nucleosam	1:5cc2691ccfff	52	#define running 0x00000008 ///< running motor flag
nucleosam	1:5cc2691ccfff	53	#define velocitymode 0x00000010 ///< velocity controlled stepper motor
nucleosam	1:5cc2691ccfff	54	#define positionmode 0x00000020 ///< position controlled stepper motor
nucleosam	1:5cc2691ccfff	55	#define fullstep 0x00000040 ///< full step mode controlled
nucleosam	1:5cc2691ccfff	56	#define halfstep 0x00000080 ///< half step mode controlled
nucleosam	1:5cc2691ccfff	57	#define microstep 0x00000100 ///< micro step mode controlled
nucleosam	1:5cc2691ccfff	58	#define forward 0x00000200 ///< forward running motor
nucleosam	1:5cc2691ccfff	59	#define dir2change 0x00000400 ///< direction has to be changed while the motor is running
nucleosam	1:5cc2691ccfff	60	#define fastdecaymode 0x00000800 ///< decay mode is fast
nucleosam	1:5cc2691ccfff	61	#define wavestep 0x00001000 ///< wave step mode controlled
nucleosam	1:5cc2691ccfff	62
nucleosam	1:5cc2691ccfff	63	/* Variables ----------------------------------------------------------------*/
nucleosam	1:5cc2691ccfff	64	/* Number of devices. */
nucleosam	1:5cc2691ccfff	65	uint8_t L6208::numberOfDevices = 0;
nucleosam	1:5cc2691ccfff	66
nucleosam	1:5cc2691ccfff	67	/// RefMicroTable values are 2^L6208_SINE_WAVEFORM_POWER_OF_TWO_MAX_VALUE\|sin(n/16PI/2)\|
nucleosam	1:5cc2691ccfff	68	/// where n is the index in the table
nucleosam	1:5cc2691ccfff	69	const uint16_t L6208::RefMicroTable[L6208_USTEPS_PER_QUARTER_PERIOD*3] =
nucleosam	1:5cc2691ccfff	70	{
nucleosam	1:5cc2691ccfff	71	0,3212,6393,9512,12540,15447,18205,20788,23170,25330,27246,28899,30274,31357,32138,32610,
nucleosam	1:5cc2691ccfff	72	32768,32610,32138,31357,30274,28899,27246,25330,23170,20788,18205,15447,12540,9512,6393,3212,
nucleosam	1:5cc2691ccfff	73	0,3212,6393,9512,12540,15447,18205,20788,23170,25330,27246,28899,30274,31357,32138,32610
nucleosam	1:5cc2691ccfff	74	};
nucleosam	1:5cc2691ccfff	75
nucleosam	1:5cc2691ccfff	76	/* Methods -------------------------------------------------------------------*/
nucleosam	1:5cc2691ccfff	77	/****************************************************//
nucleosam	1:5cc2691ccfff	78	* @brief Start the L6208 library
nucleosam	1:5cc2691ccfff	79	* @param[in] pInit pointer to the initialization data
nucleosam	1:5cc2691ccfff	80	* @retval COMPONENT_OK in case of success.
nucleosam	1:5cc2691ccfff	81	**********************************************************/
nucleosam	1:5cc2691ccfff	82	Status_t L6208::L6208_Init(void* pInit)
nucleosam	1:5cc2691ccfff	83	{
nucleosam	1:5cc2691ccfff	84	if (pInit == NULL)
nucleosam	1:5cc2691ccfff	85	{
nucleosam	1:5cc2691ccfff	86	/* Set context variables to the predefined values from l6208_target_config.h */
nucleosam	1:5cc2691ccfff	87	/* Set GPIO according to these values */
nucleosam	1:5cc2691ccfff	88	L6208_SetDeviceParamsToPredefinedValues();
nucleosam	1:5cc2691ccfff	89	}
nucleosam	1:5cc2691ccfff	90	else
nucleosam	1:5cc2691ccfff	91	{
nucleosam	1:5cc2691ccfff	92	L6208_SetDeviceParamsToGivenValues((l6208_Init_t*) pInit);
nucleosam	1:5cc2691ccfff	93	}
nucleosam	1:5cc2691ccfff	94
nucleosam	1:5cc2691ccfff	95	/* Initialise the PWMs */
nucleosam	1:5cc2691ccfff	96	L6208_Board_VrefPwmInit(BRIDGE_A, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	97	L6208_Board_VrefPwmInit(BRIDGE_B, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	98
nucleosam	1:5cc2691ccfff	99	/* Initialise the tick */
nucleosam	1:5cc2691ccfff	100	L6208_Board_TickInit();
nucleosam	1:5cc2691ccfff	101
nucleosam	1:5cc2691ccfff	102	/* Reset L6208 */
nucleosam	1:5cc2691ccfff	103	L6208_ResetDevice();
nucleosam	1:5cc2691ccfff	104
nucleosam	1:5cc2691ccfff	105	/* Align motor mechanical position to driver position */
nucleosam	1:5cc2691ccfff	106	L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	107	L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	108	//L6208_Enable();
nucleosam	1:5cc2691ccfff	109
nucleosam	1:5cc2691ccfff	110	return COMPONENT_OK;
nucleosam	1:5cc2691ccfff	111	}
nucleosam	1:5cc2691ccfff	112
nucleosam	1:5cc2691ccfff	113	/**********************************************************
nucleosam	1:5cc2691ccfff	114	* @brief Read id
nucleosam	1:5cc2691ccfff	115	* @param id pointer to the identifier to be read.
nucleosam	1:5cc2691ccfff	116	* @retval COMPONENT_OK in case of success.
nucleosam	1:5cc2691ccfff	117	**********************************************************/
nucleosam	1:5cc2691ccfff	118	Status_t L6208::L6208_ReadID(uint8_t *id)
nucleosam	1:5cc2691ccfff	119	{
nucleosam	1:5cc2691ccfff	120	*id = deviceInstance;
nucleosam	1:5cc2691ccfff	121
nucleosam	1:5cc2691ccfff	122	return COMPONENT_OK;
nucleosam	1:5cc2691ccfff	123	}
nucleosam	1:5cc2691ccfff	124
nucleosam	1:5cc2691ccfff	125	/**********************************************************
nucleosam	1:5cc2691ccfff	126	* @brief Attaches a user callback to the error Handler.
nucleosam	1:5cc2691ccfff	127	* The call back will be then called each time the library
nucleosam	1:5cc2691ccfff	128	* detects an error
nucleosam	1:5cc2691ccfff	129	* @param[in] callback Name of the callback to attach
nucleosam	1:5cc2691ccfff	130	* to the error Hanlder
nucleosam	1:5cc2691ccfff	131	* @retval None
nucleosam	1:5cc2691ccfff	132	**********************************************************/
nucleosam	1:5cc2691ccfff	133	void L6208::L6208_AttachErrorHandler(void (*callback)(uint16_t error))
nucleosam	1:5cc2691ccfff	134	{
nucleosam	1:5cc2691ccfff	135	errorHandlerCallback = (void (*)(uint16_t error)) callback;
nucleosam	1:5cc2691ccfff	136	}
nucleosam	1:5cc2691ccfff	137
nucleosam	1:5cc2691ccfff	138	/****************************************************//
nucleosam	1:5cc2691ccfff	139	* @brief Disable the power bridges (leave the output bridges HiZ)
nucleosam	1:5cc2691ccfff	140	* @retval None
nucleosam	1:5cc2691ccfff	141	**********************************************************/
nucleosam	1:5cc2691ccfff	142	void L6208::L6208_Disable(void)
nucleosam	1:5cc2691ccfff	143	{
nucleosam	1:5cc2691ccfff	144	L6208_Board_Disable();
nucleosam	1:5cc2691ccfff	145	L6208_ClearSysFlag(EN_A_set);
nucleosam	1:5cc2691ccfff	146	}
nucleosam	1:5cc2691ccfff	147
nucleosam	1:5cc2691ccfff	148	/****************************************************//
nucleosam	1:5cc2691ccfff	149	* @brief Error handler which calls the user callback (if defined)
nucleosam	1:5cc2691ccfff	150	* @param[in] error Number of the error
nucleosam	1:5cc2691ccfff	151	* @retval None
nucleosam	1:5cc2691ccfff	152	**********************************************************/
nucleosam	1:5cc2691ccfff	153	void L6208::L6208_ErrorHandler(uint16_t error)
nucleosam	1:5cc2691ccfff	154	{
nucleosam	1:5cc2691ccfff	155	if (errorHandlerCallback != 0)
nucleosam	1:5cc2691ccfff	156	{
nucleosam	1:5cc2691ccfff	157	errorHandlerCallback(error);
nucleosam	1:5cc2691ccfff	158	}
nucleosam	1:5cc2691ccfff	159	else
nucleosam	1:5cc2691ccfff	160	{
nucleosam	1:5cc2691ccfff	161	while(1)
nucleosam	1:5cc2691ccfff	162	{
nucleosam	1:5cc2691ccfff	163	/* Infinite loop */
nucleosam	1:5cc2691ccfff	164	}
nucleosam	1:5cc2691ccfff	165	}
nucleosam	1:5cc2691ccfff	166	}
nucleosam	1:5cc2691ccfff	167
nucleosam	1:5cc2691ccfff	168	/****************************************************//
nucleosam	1:5cc2691ccfff	169	* @brief Enable the power bridges
nucleosam	1:5cc2691ccfff	170	* @retval None
nucleosam	1:5cc2691ccfff	171	**********************************************************/
nucleosam	1:5cc2691ccfff	172	void L6208::L6208_Enable(void)
nucleosam	1:5cc2691ccfff	173	{
nucleosam	1:5cc2691ccfff	174	L6208_Board_Enable();
nucleosam	1:5cc2691ccfff	175	L6208_SetSysFlag(EN_A_set);
nucleosam	1:5cc2691ccfff	176	}
nucleosam	1:5cc2691ccfff	177
nucleosam	1:5cc2691ccfff	178	/****************************************************//
nucleosam	1:5cc2691ccfff	179	* @brief Get the stepper acceleration rate
nucleosam	1:5cc2691ccfff	180	* in step/s^2 for full, half and wave modes
nucleosam	1:5cc2691ccfff	181	* in microsteps/s^2 for microstep modes
nucleosam	1:5cc2691ccfff	182	* @retval the stepper acceleration rate in step/s^2 or microstep/s^2
nucleosam	1:5cc2691ccfff	183	* @note
nucleosam	1:5cc2691ccfff	184	**********************************************************/
nucleosam	1:5cc2691ccfff	185	uint16_t L6208::L6208_GetAcceleration(void)
nucleosam	1:5cc2691ccfff	186	{
nucleosam	1:5cc2691ccfff	187	return devicePrm.accelerationSps2;
nucleosam	1:5cc2691ccfff	188	}
nucleosam	1:5cc2691ccfff	189
nucleosam	1:5cc2691ccfff	190	/****************************************************//
nucleosam	1:5cc2691ccfff	191	* @brief Get the current speed
nucleosam	1:5cc2691ccfff	192	* in step/s for full, half and wave modes
nucleosam	1:5cc2691ccfff	193	* in microsteps/s for microstep modes
nucleosam	1:5cc2691ccfff	194	* @retval return the current speed in step/s or microstep/s
nucleosam	1:5cc2691ccfff	195	* @note
nucleosam	1:5cc2691ccfff	196	**********************************************************/
nucleosam	1:5cc2691ccfff	197	uint16_t L6208::L6208_GetCurrentSpeed(void)
nucleosam	1:5cc2691ccfff	198	{
nucleosam	1:5cc2691ccfff	199	uint64_t tmp64 = (uint64_t) devicePrm.speedSpt * L6208_Board_TickGetFreq();
nucleosam	1:5cc2691ccfff	200
nucleosam	1:5cc2691ccfff	201	devicePrm.speedSps = (uint16_t)(tmp64 >> 23);
nucleosam	1:5cc2691ccfff	202	if (devicePrm.speedSps & 0x1)
nucleosam	1:5cc2691ccfff	203	{
nucleosam	1:5cc2691ccfff	204	devicePrm.speedSps = (devicePrm.speedSps >> 1) + 1;
nucleosam	1:5cc2691ccfff	205	}
nucleosam	1:5cc2691ccfff	206	else
nucleosam	1:5cc2691ccfff	207	{
nucleosam	1:5cc2691ccfff	208	devicePrm.speedSps = devicePrm.speedSps >> 1;
nucleosam	1:5cc2691ccfff	209	}
nucleosam	1:5cc2691ccfff	210	return devicePrm.speedSps;
nucleosam	1:5cc2691ccfff	211	}
nucleosam	1:5cc2691ccfff	212
nucleosam	1:5cc2691ccfff	213	/****************************************************//
nucleosam	1:5cc2691ccfff	214	* @brief Get the motor decay mode
nucleosam	1:5cc2691ccfff	215	* @retval decay mode
nucleosam	1:5cc2691ccfff	216	**********************************************************/
nucleosam	1:5cc2691ccfff	217	motorDecayMode_t L6208::L6208_GetDecayMode(void)
nucleosam	1:5cc2691ccfff	218	{
nucleosam	1:5cc2691ccfff	219	if (L6208_IsSysFlag(fastdecaymode)) return (FAST_DECAY);
nucleosam	1:5cc2691ccfff	220	else return (SLOW_DECAY);
nucleosam	1:5cc2691ccfff	221	}
nucleosam	1:5cc2691ccfff	222
nucleosam	1:5cc2691ccfff	223	/****************************************************//
nucleosam	1:5cc2691ccfff	224	* @brief Get the stepper deceleration rate
nucleosam	1:5cc2691ccfff	225	* in step/s^2 for full, half and wave modes
nucleosam	1:5cc2691ccfff	226	* in microsteps/s^2 for microstep modes
nucleosam	1:5cc2691ccfff	227	* @retval the stepper deceleration rate in step/s^2 or microstep/s^2
nucleosam	1:5cc2691ccfff	228	* @note
nucleosam	1:5cc2691ccfff	229	**********************************************************/
nucleosam	1:5cc2691ccfff	230	uint16_t L6208::L6208_GetDeceleration(void)
nucleosam	1:5cc2691ccfff	231	{
nucleosam	1:5cc2691ccfff	232	return devicePrm.decelerationSps2;
nucleosam	1:5cc2691ccfff	233	}
nucleosam	1:5cc2691ccfff	234
nucleosam	1:5cc2691ccfff	235	/****************************************************//
nucleosam	1:5cc2691ccfff	236	* @brief Get the motor current direction
nucleosam	1:5cc2691ccfff	237	* @retval direction
nucleosam	1:5cc2691ccfff	238	**********************************************************/
nucleosam	1:5cc2691ccfff	239	motorDir_t L6208::L6208_GetDirection(void)
nucleosam	1:5cc2691ccfff	240	{
nucleosam	1:5cc2691ccfff	241	if (L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	242	{
nucleosam	1:5cc2691ccfff	243	return FORWARD;
nucleosam	1:5cc2691ccfff	244	}
nucleosam	1:5cc2691ccfff	245	else
nucleosam	1:5cc2691ccfff	246	{
nucleosam	1:5cc2691ccfff	247	return BACKWARD;
nucleosam	1:5cc2691ccfff	248	}
nucleosam	1:5cc2691ccfff	249	}
nucleosam	1:5cc2691ccfff	250
nucleosam	1:5cc2691ccfff	251	/****************************************************//
nucleosam	1:5cc2691ccfff	252	* @brief Return the FW version.
nucleosam	1:5cc2691ccfff	253	* @retval FW version
nucleosam	1:5cc2691ccfff	254	**********************************************************/
nucleosam	1:5cc2691ccfff	255	uint32_t L6208::L6208_GetFwVersion(void)
nucleosam	1:5cc2691ccfff	256	{
nucleosam	1:5cc2691ccfff	257	return L6208_FW_VERSION;
nucleosam	1:5cc2691ccfff	258	}
nucleosam	1:5cc2691ccfff	259
nucleosam	1:5cc2691ccfff	260	/****************************************************//
nucleosam	1:5cc2691ccfff	261	* @brief Get the mark position (32b signed)
nucleosam	1:5cc2691ccfff	262	* @retval mark position
nucleosam	1:5cc2691ccfff	263	**********************************************************/
nucleosam	1:5cc2691ccfff	264	int32_t L6208::L6208_GetMark(void)
nucleosam	1:5cc2691ccfff	265	{
nucleosam	1:5cc2691ccfff	266	return devicePrm.markPos;
nucleosam	1:5cc2691ccfff	267	}
nucleosam	1:5cc2691ccfff	268
nucleosam	1:5cc2691ccfff	269	/****************************************************//
nucleosam	1:5cc2691ccfff	270	* @brief Get the max speed
nucleosam	1:5cc2691ccfff	271	* in step/s for full, half and wave modes
nucleosam	1:5cc2691ccfff	272	* in microsteps/s for microstep modes
nucleosam	1:5cc2691ccfff	273	* @retval return the max speed in step/s or microstep/s
nucleosam	1:5cc2691ccfff	274	* @note
nucleosam	1:5cc2691ccfff	275	**********************************************************/
nucleosam	1:5cc2691ccfff	276	uint16_t L6208::L6208_GetMaxSpeed(void)
nucleosam	1:5cc2691ccfff	277	{
nucleosam	1:5cc2691ccfff	278	return devicePrm.maxSpeedSps;
nucleosam	1:5cc2691ccfff	279	}
nucleosam	1:5cc2691ccfff	280
nucleosam	1:5cc2691ccfff	281	/****************************************************//
nucleosam	1:5cc2691ccfff	282	* @brief Get the min speed
nucleosam	1:5cc2691ccfff	283	* in step/s for full, half and wave modes
nucleosam	1:5cc2691ccfff	284	* in microsteps/s for microstep modes
nucleosam	1:5cc2691ccfff	285	* @retval return the min speed in step/s or microstep/s
nucleosam	1:5cc2691ccfff	286	* @note
nucleosam	1:5cc2691ccfff	287	**********************************************************/
nucleosam	1:5cc2691ccfff	288	uint16_t L6208::L6208_GetMinSpeed(void)
nucleosam	1:5cc2691ccfff	289	{
nucleosam	1:5cc2691ccfff	290	return devicePrm.minSpeedSps;
nucleosam	1:5cc2691ccfff	291	}
nucleosam	1:5cc2691ccfff	292
nucleosam	1:5cc2691ccfff	293	/****************************************************//
nucleosam	1:5cc2691ccfff	294	* @brief Get the stepper state machine index
nucleosam	1:5cc2691ccfff	295	* @retval one of the stepper state machine index in the motorState_t enum
nucleosam	1:5cc2691ccfff	296	**********************************************************/
nucleosam	1:5cc2691ccfff	297	motorState_t L6208::L6208_GetMotionState(void)
nucleosam	1:5cc2691ccfff	298	{
nucleosam	1:5cc2691ccfff	299	// gets the new stepper state machine index
nucleosam	1:5cc2691ccfff	300	return devicePrm.motionState;
nucleosam	1:5cc2691ccfff	301	}
nucleosam	1:5cc2691ccfff	302
nucleosam	1:5cc2691ccfff	303	/****************************************************//
nucleosam	1:5cc2691ccfff	304	* @brief Get the current position (32b signed)
nucleosam	1:5cc2691ccfff	305	* @retval current absoulte position
nucleosam	1:5cc2691ccfff	306	**********************************************************/
nucleosam	1:5cc2691ccfff	307	int32_t L6208::L6208_GetPosition(void)
nucleosam	1:5cc2691ccfff	308	{
nucleosam	1:5cc2691ccfff	309	return devicePrm.absolutePos;
nucleosam	1:5cc2691ccfff	310	}
nucleosam	1:5cc2691ccfff	311
nucleosam	1:5cc2691ccfff	312	/****************************************************//
nucleosam	1:5cc2691ccfff	313	* @brief Get the motor step mode
nucleosam	1:5cc2691ccfff	314	* @retval step mode
nucleosam	1:5cc2691ccfff	315	**********************************************************/
nucleosam	1:5cc2691ccfff	316	motorStepMode_t L6208::L6208_GetStepMode(void)
nucleosam	1:5cc2691ccfff	317	{
nucleosam	1:5cc2691ccfff	318	return devicePrm.stepMode;
nucleosam	1:5cc2691ccfff	319	}
nucleosam	1:5cc2691ccfff	320
nucleosam	1:5cc2691ccfff	321	/****************************************************//
nucleosam	1:5cc2691ccfff	322	* @brief Get the selected stop mode
nucleosam	1:5cc2691ccfff	323	* @retval the selected stop mode
nucleosam	1:5cc2691ccfff	324	**********************************************************/
nucleosam	1:5cc2691ccfff	325	motorStopMode_t L6208::L6208_GetStopMode(void)
nucleosam	1:5cc2691ccfff	326	{
nucleosam	1:5cc2691ccfff	327	if (L6208_IsSysFlag(HiZstop) == FALSE)
nucleosam	1:5cc2691ccfff	328	{
nucleosam	1:5cc2691ccfff	329	return (HOLD_MODE);
nucleosam	1:5cc2691ccfff	330	}
nucleosam	1:5cc2691ccfff	331	else
nucleosam	1:5cc2691ccfff	332	{
nucleosam	1:5cc2691ccfff	333	return (HIZ_MODE);
nucleosam	1:5cc2691ccfff	334	}
nucleosam	1:5cc2691ccfff	335	}
nucleosam	1:5cc2691ccfff	336
nucleosam	1:5cc2691ccfff	337	/****************************************************//
nucleosam	1:5cc2691ccfff	338	* @brief Go to the home position
nucleosam	1:5cc2691ccfff	339	* @retval None
nucleosam	1:5cc2691ccfff	340	**********************************************************/
nucleosam	1:5cc2691ccfff	341	void L6208::L6208_GoHome(void)
nucleosam	1:5cc2691ccfff	342	{
nucleosam	1:5cc2691ccfff	343	L6208_GoTo(0);
nucleosam	1:5cc2691ccfff	344	}
nucleosam	1:5cc2691ccfff	345
nucleosam	1:5cc2691ccfff	346	/****************************************************//
nucleosam	1:5cc2691ccfff	347	* @brief Go to the Mark position
nucleosam	1:5cc2691ccfff	348	* @retval None
nucleosam	1:5cc2691ccfff	349	**********************************************************/
nucleosam	1:5cc2691ccfff	350	void L6208::L6208_GoMark(void)
nucleosam	1:5cc2691ccfff	351	{
nucleosam	1:5cc2691ccfff	352	L6208_GoTo(devicePrm.markPos);
nucleosam	1:5cc2691ccfff	353	}
nucleosam	1:5cc2691ccfff	354
nucleosam	1:5cc2691ccfff	355	/****************************************************//
nucleosam	1:5cc2691ccfff	356	* @brief Move the motor to the absolute position using the shortest path
nucleosam	1:5cc2691ccfff	357	* @param[in] abs_pos 32 bit signed value position
nucleosam	1:5cc2691ccfff	358	* @retval None
nucleosam	1:5cc2691ccfff	359	* @note The position is at the resolution corresponding to the
nucleosam	1:5cc2691ccfff	360	* selected step mode.
nucleosam	1:5cc2691ccfff	361	* STEP_MODE_FULL or STEP_MODE_WAVE : step
nucleosam	1:5cc2691ccfff	362	* STEP_MODE_HALF : 1/2 step
nucleosam	1:5cc2691ccfff	363	* STEP_MODE_1_4 : 1/4 step
nucleosam	1:5cc2691ccfff	364	* STEP_MODE_1_8 : 1/8 step
nucleosam	1:5cc2691ccfff	365	* STEP_MODE_1_16 : 1/16 step
nucleosam	1:5cc2691ccfff	366	**********************************************************/
nucleosam	1:5cc2691ccfff	367	void L6208::L6208_GoTo(int32_t abs_pos)
nucleosam	1:5cc2691ccfff	368	{
nucleosam	1:5cc2691ccfff	369	uint32_t steps = 0;
nucleosam	1:5cc2691ccfff	370
nucleosam	1:5cc2691ccfff	371	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	372	{
nucleosam	1:5cc2691ccfff	373	L6208_HardStop();
nucleosam	1:5cc2691ccfff	374	}
nucleosam	1:5cc2691ccfff	375
nucleosam	1:5cc2691ccfff	376	if (abs_pos > devicePrm.absolutePos)
nucleosam	1:5cc2691ccfff	377	{
nucleosam	1:5cc2691ccfff	378	steps = abs_pos - devicePrm.absolutePos;
nucleosam	1:5cc2691ccfff	379	if (steps < (L6208_POSITION_RANGE>>1))
nucleosam	1:5cc2691ccfff	380	{
nucleosam	1:5cc2691ccfff	381	L6208_Move(FORWARD, steps);
nucleosam	1:5cc2691ccfff	382	}
nucleosam	1:5cc2691ccfff	383	else
nucleosam	1:5cc2691ccfff	384	{
nucleosam	1:5cc2691ccfff	385	L6208_Move(BACKWARD, (L6208_POSITION_RANGE - steps));
nucleosam	1:5cc2691ccfff	386	}
nucleosam	1:5cc2691ccfff	387	}
nucleosam	1:5cc2691ccfff	388	else
nucleosam	1:5cc2691ccfff	389	{
nucleosam	1:5cc2691ccfff	390	steps = devicePrm.absolutePos - abs_pos;
nucleosam	1:5cc2691ccfff	391	if (steps < (L6208_POSITION_RANGE>>1))
nucleosam	1:5cc2691ccfff	392	{
nucleosam	1:5cc2691ccfff	393	L6208_Move(BACKWARD, steps);
nucleosam	1:5cc2691ccfff	394	}
nucleosam	1:5cc2691ccfff	395	else
nucleosam	1:5cc2691ccfff	396	{
nucleosam	1:5cc2691ccfff	397	L6208_Move(FORWARD, (L6208_POSITION_RANGE - steps));
nucleosam	1:5cc2691ccfff	398	}
nucleosam	1:5cc2691ccfff	399	}
nucleosam	1:5cc2691ccfff	400	}
nucleosam	1:5cc2691ccfff	401
nucleosam	1:5cc2691ccfff	402	/****************************************************//
nucleosam	1:5cc2691ccfff	403	* @brief Move the motor to the absolute position
nucleosam	1:5cc2691ccfff	404	* @param[in] direction FORWARD or BACKWARD
nucleosam	1:5cc2691ccfff	405	* @param[in] abs_pos 32 bit signed value position
nucleosam	1:5cc2691ccfff	406	* @retval None
nucleosam	1:5cc2691ccfff	407	* @note The position is at the resolution corresponding to the
nucleosam	1:5cc2691ccfff	408	* selected step mode.
nucleosam	1:5cc2691ccfff	409	* STEP_MODE_FULL or STEP_MODE_WAVE : step
nucleosam	1:5cc2691ccfff	410	* STEP_MODE_HALF : 1/2 step
nucleosam	1:5cc2691ccfff	411	* STEP_MODE_1_4 : 1/4 step
nucleosam	1:5cc2691ccfff	412	* STEP_MODE_1_8 : 1/8 step
nucleosam	1:5cc2691ccfff	413	* STEP_MODE_1_16 : 1/16 step
nucleosam	1:5cc2691ccfff	414	**********************************************************/
nucleosam	1:5cc2691ccfff	415	void L6208::L6208_GoToDir(motorDir_t direction, int32_t abs_pos)
nucleosam	1:5cc2691ccfff	416	{
nucleosam	1:5cc2691ccfff	417	uint32_t steps = 0;
nucleosam	1:5cc2691ccfff	418
nucleosam	1:5cc2691ccfff	419	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	420	{
nucleosam	1:5cc2691ccfff	421	L6208_HardStop();
nucleosam	1:5cc2691ccfff	422	}
nucleosam	1:5cc2691ccfff	423
nucleosam	1:5cc2691ccfff	424	if (direction != BACKWARD)
nucleosam	1:5cc2691ccfff	425	{
nucleosam	1:5cc2691ccfff	426	if (abs_pos > devicePrm.absolutePos)
nucleosam	1:5cc2691ccfff	427	{
nucleosam	1:5cc2691ccfff	428	steps = abs_pos - devicePrm.absolutePos;
nucleosam	1:5cc2691ccfff	429	}
nucleosam	1:5cc2691ccfff	430	else
nucleosam	1:5cc2691ccfff	431	{
nucleosam	1:5cc2691ccfff	432	steps = L6208_POSITION_RANGE + (abs_pos - devicePrm.absolutePos);
nucleosam	1:5cc2691ccfff	433	}
nucleosam	1:5cc2691ccfff	434	}
nucleosam	1:5cc2691ccfff	435	else
nucleosam	1:5cc2691ccfff	436	{
nucleosam	1:5cc2691ccfff	437	if (abs_pos > devicePrm.absolutePos)
nucleosam	1:5cc2691ccfff	438	{
nucleosam	1:5cc2691ccfff	439	steps = L6208_POSITION_RANGE + (devicePrm.absolutePos - abs_pos);
nucleosam	1:5cc2691ccfff	440	}
nucleosam	1:5cc2691ccfff	441	else
nucleosam	1:5cc2691ccfff	442	{
nucleosam	1:5cc2691ccfff	443	steps = devicePrm.absolutePos - abs_pos;
nucleosam	1:5cc2691ccfff	444	}
nucleosam	1:5cc2691ccfff	445	}
nucleosam	1:5cc2691ccfff	446	L6208_Move(direction, steps);
nucleosam	1:5cc2691ccfff	447	}
nucleosam	1:5cc2691ccfff	448
nucleosam	1:5cc2691ccfff	449	/****************************************************//
nucleosam	1:5cc2691ccfff	450	* @brief Immediately stop the motor and disables the power bridges
nucleosam	1:5cc2691ccfff	451	* @retval None
nucleosam	1:5cc2691ccfff	452	**********************************************************/
nucleosam	1:5cc2691ccfff	453	void L6208::L6208_HardHiZ(void)
nucleosam	1:5cc2691ccfff	454	{
nucleosam	1:5cc2691ccfff	455	/* Disables power stage */
nucleosam	1:5cc2691ccfff	456	L6208_Disable();
nucleosam	1:5cc2691ccfff	457
nucleosam	1:5cc2691ccfff	458	/* Sets inactive state */
nucleosam	1:5cc2691ccfff	459	L6208_SetMotionState(INACTIVE);
nucleosam	1:5cc2691ccfff	460
nucleosam	1:5cc2691ccfff	461	/* Clears the running motor and the position */
nucleosam	1:5cc2691ccfff	462	L6208_ClearSysFlag(running);
nucleosam	1:5cc2691ccfff	463
nucleosam	1:5cc2691ccfff	464	/* Disables PWMs */
nucleosam	1:5cc2691ccfff	465	L6208_Board_VrefPwmStop(BRIDGE_A);
nucleosam	1:5cc2691ccfff	466	L6208_Board_VrefPwmStop(BRIDGE_B);
nucleosam	1:5cc2691ccfff	467
nucleosam	1:5cc2691ccfff	468	/* Disables tick timer */
nucleosam	1:5cc2691ccfff	469	L6208_Board_TickStop();
nucleosam	1:5cc2691ccfff	470	}
nucleosam	1:5cc2691ccfff	471
nucleosam	1:5cc2691ccfff	472	/****************************************************//
nucleosam	1:5cc2691ccfff	473	* @brief Immediately stop the motor and keeps holding torque
nucleosam	1:5cc2691ccfff	474	* @retval None
nucleosam	1:5cc2691ccfff	475	**********************************************************/
nucleosam	1:5cc2691ccfff	476	void L6208::L6208_HardStop(void)
nucleosam	1:5cc2691ccfff	477	{
nucleosam	1:5cc2691ccfff	478	/* Sets inactive state */
nucleosam	1:5cc2691ccfff	479	L6208_SetMotionState(INACTIVE);
nucleosam	1:5cc2691ccfff	480
nucleosam	1:5cc2691ccfff	481	/* Clears the running motor and the position */
nucleosam	1:5cc2691ccfff	482	L6208_ClearSysFlag(running);
nucleosam	1:5cc2691ccfff	483	L6208_VectorCalc(devicePrm.holdTorque);
nucleosam	1:5cc2691ccfff	484
nucleosam	1:5cc2691ccfff	485	/* Disables tick timer */
nucleosam	1:5cc2691ccfff	486	L6208_Board_TickStop();
nucleosam	1:5cc2691ccfff	487	}
nucleosam	1:5cc2691ccfff	488
nucleosam	1:5cc2691ccfff	489	/****************************************************//
nucleosam	1:5cc2691ccfff	490	* @brief Move the motor by the specified number of steps
nucleosam	1:5cc2691ccfff	491	* in the specified direction
nucleosam	1:5cc2691ccfff	492	* @param[in] direction FORWARD or BACKWARD
nucleosam	1:5cc2691ccfff	493	* @param[in] stepCount 32 bit unsigned step count
nucleosam	1:5cc2691ccfff	494	* @retval None
nucleosam	1:5cc2691ccfff	495	* @note The step count resolution is corresponding to the
nucleosam	1:5cc2691ccfff	496	* selected step mode.
nucleosam	1:5cc2691ccfff	497	* STEP_MODE_FULL or STEP_MODE_WAVE : step
nucleosam	1:5cc2691ccfff	498	* STEP_MODE_HALF : 1/2 step
nucleosam	1:5cc2691ccfff	499	* STEP_MODE_1_4 : 1/4 step
nucleosam	1:5cc2691ccfff	500	* STEP_MODE_1_8 : 1/8 step
nucleosam	1:5cc2691ccfff	501	* STEP_MODE_1_16 : 1/16 step
nucleosam	1:5cc2691ccfff	502	**********************************************************/
nucleosam	1:5cc2691ccfff	503	void L6208::L6208_Move(motorDir_t direction, uint32_t stepCount)
nucleosam	1:5cc2691ccfff	504	{
nucleosam	1:5cc2691ccfff	505	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	506	{
nucleosam	1:5cc2691ccfff	507	L6208_HardStop();
nucleosam	1:5cc2691ccfff	508	}
nucleosam	1:5cc2691ccfff	509
nucleosam	1:5cc2691ccfff	510	/* clear the velocity driving mode flag */
nucleosam	1:5cc2691ccfff	511	L6208_ClearSysFlag(velocitymode);
nucleosam	1:5cc2691ccfff	512
nucleosam	1:5cc2691ccfff	513	/* Set the indexing driving mode flag */
nucleosam	1:5cc2691ccfff	514	/* and the user command executing flag */
nucleosam	1:5cc2691ccfff	515	L6208_SetSysFlag(positionmode);
nucleosam	1:5cc2691ccfff	516
nucleosam	1:5cc2691ccfff	517	/* store relative number of steps to move */
nucleosam	1:5cc2691ccfff	518	devicePrm.positionTarget = stepCount;
nucleosam	1:5cc2691ccfff	519
nucleosam	1:5cc2691ccfff	520	L6208_SetDirection(direction);
nucleosam	1:5cc2691ccfff	521
nucleosam	1:5cc2691ccfff	522	/* Motor activation */
nucleosam	1:5cc2691ccfff	523	L6208_StartMovement();
nucleosam	1:5cc2691ccfff	524	}
nucleosam	1:5cc2691ccfff	525
nucleosam	1:5cc2691ccfff	526	/****************************************************//
nucleosam	1:5cc2691ccfff	527	* @brief Release the L6208 reset (Reset pin set to high level)
nucleosam	1:5cc2691ccfff	528	* @retval None
nucleosam	1:5cc2691ccfff	529	**********************************************************/
nucleosam	1:5cc2691ccfff	530	void L6208::L6208_ReleaseReset(void)
nucleosam	1:5cc2691ccfff	531	{
nucleosam	1:5cc2691ccfff	532	L6208_Board_ReleaseReset();
nucleosam	1:5cc2691ccfff	533	}
nucleosam	1:5cc2691ccfff	534
nucleosam	1:5cc2691ccfff	535	/****************************************************//
nucleosam	1:5cc2691ccfff	536	* @brief Reset the L6208 (Reset pin set to low level)
nucleosam	1:5cc2691ccfff	537	* @retval None
nucleosam	1:5cc2691ccfff	538	**********************************************************/
nucleosam	1:5cc2691ccfff	539	void L6208::L6208_Reset(void)
nucleosam	1:5cc2691ccfff	540	{
nucleosam	1:5cc2691ccfff	541	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	542	}
nucleosam	1:5cc2691ccfff	543
nucleosam	1:5cc2691ccfff	544
nucleosam	1:5cc2691ccfff	545	/****************************************************//
nucleosam	1:5cc2691ccfff	546	* @brief Call L6208_SetStepMode with current step mode,
nucleosam	1:5cc2691ccfff	547	* the L6208_SetStepMode function along with setting the step mode resets
nucleosam	1:5cc2691ccfff	548	* the L6208 device
nucleosam	1:5cc2691ccfff	549	* @retval None
nucleosam	1:5cc2691ccfff	550	**********************************************************/
nucleosam	1:5cc2691ccfff	551	void L6208::L6208_ResetDevice(void)
nucleosam	1:5cc2691ccfff	552	{
nucleosam	1:5cc2691ccfff	553	L6208_SetStepMode(L6208_GetStepMode());
nucleosam	1:5cc2691ccfff	554	}
nucleosam	1:5cc2691ccfff	555
nucleosam	1:5cc2691ccfff	556	/****************************************************//
nucleosam	1:5cc2691ccfff	557	* @brief Run the motor in the specified direction
nucleosam	1:5cc2691ccfff	558	* according to the speed profile defined by the minimum speed,
nucleosam	1:5cc2691ccfff	559	* maximum speed, and acceleration parameters.
nucleosam	1:5cc2691ccfff	560	* The device accelerates from the minimum speed up to the maximum
nucleosam	1:5cc2691ccfff	561	* speed by using the device acceleration.
nucleosam	1:5cc2691ccfff	562	* @param[in] direction FORWARD or BACKWARD
nucleosam	1:5cc2691ccfff	563	* @retval None
nucleosam	1:5cc2691ccfff	564	**********************************************************/
nucleosam	1:5cc2691ccfff	565	void L6208::L6208_Run(motorDir_t direction)
nucleosam	1:5cc2691ccfff	566	{
nucleosam	1:5cc2691ccfff	567	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	568	{
nucleosam	1:5cc2691ccfff	569	L6208_HardStop();
nucleosam	1:5cc2691ccfff	570	}
nucleosam	1:5cc2691ccfff	571	L6208_SetDirection(direction);
nucleosam	1:5cc2691ccfff	572	/* Clear the indexing driving mode flag */
nucleosam	1:5cc2691ccfff	573	L6208_ClearSysFlag(positionmode);
nucleosam	1:5cc2691ccfff	574	/* Set the velocity driving mode flag */
nucleosam	1:5cc2691ccfff	575	L6208_SetSysFlag(velocitymode);
nucleosam	1:5cc2691ccfff	576	/* Motor activation */
nucleosam	1:5cc2691ccfff	577	L6208_StartMovement();
nucleosam	1:5cc2691ccfff	578	}
nucleosam	1:5cc2691ccfff	579
nucleosam	1:5cc2691ccfff	580	/****************************************************//
nucleosam	1:5cc2691ccfff	581	* @brief Set the stepper acceleration rate
nucleosam	1:5cc2691ccfff	582	* in step/s^2 and step/tick^2 for full, half and wave modes
nucleosam	1:5cc2691ccfff	583	* in microsteps/s^2 and microsteps/tick^2 for microstep modes
nucleosam	1:5cc2691ccfff	584	* @param[in] newAcc new acceleration rate in step/s^2 or microstep/s^2
nucleosam	1:5cc2691ccfff	585	* @retval TRUE
nucleosam	1:5cc2691ccfff	586	* @note
nucleosam	1:5cc2691ccfff	587	**********************************************************/
nucleosam	1:5cc2691ccfff	588	bool L6208::L6208_SetAcceleration(uint16_t newAcc)
nucleosam	1:5cc2691ccfff	589	{
nucleosam	1:5cc2691ccfff	590	uint16_t newAccSpt2 = L6208_ConvertAcceDecelRateValue(newAcc);
nucleosam	1:5cc2691ccfff	591	if (newAccSpt2)
nucleosam	1:5cc2691ccfff	592	{
nucleosam	1:5cc2691ccfff	593	devicePrm.accelerationSps2 = newAcc;
nucleosam	1:5cc2691ccfff	594	devicePrm.accelerationSpt2 = newAccSpt2;
nucleosam	1:5cc2691ccfff	595	}
nucleosam	1:5cc2691ccfff	596	else
nucleosam	1:5cc2691ccfff	597	{
nucleosam	1:5cc2691ccfff	598	L6208_ErrorHandler(L6208_ERROR_SET_ACCELERATION);
nucleosam	1:5cc2691ccfff	599	}
nucleosam	1:5cc2691ccfff	600	return TRUE;
nucleosam	1:5cc2691ccfff	601	}
nucleosam	1:5cc2691ccfff	602
nucleosam	1:5cc2691ccfff	603	/****************************************************//
nucleosam	1:5cc2691ccfff	604	* @brief Select the motor decay mode
nucleosam	1:5cc2691ccfff	605	* @param[in] decayMode (SLOW_DECAY or FAST_DECAY)
nucleosam	1:5cc2691ccfff	606	* @retval None
nucleosam	1:5cc2691ccfff	607	**********************************************************/
nucleosam	1:5cc2691ccfff	608	void L6208::L6208_SetDecayMode(motorDecayMode_t decayMode)
nucleosam	1:5cc2691ccfff	609	{
nucleosam	1:5cc2691ccfff	610	if ((decayMode & L6208_FAST_DECAY_MODE_MASK) == L6208_FAST_DECAY_MODE_MASK)
nucleosam	1:5cc2691ccfff	611	{
nucleosam	1:5cc2691ccfff	612	L6208_Board_CONTROL_PIN_Set();
nucleosam	1:5cc2691ccfff	613	L6208_SetSysFlag(fastdecaymode);
nucleosam	1:5cc2691ccfff	614	}
nucleosam	1:5cc2691ccfff	615	else
nucleosam	1:5cc2691ccfff	616	{
nucleosam	1:5cc2691ccfff	617	L6208_Board_CONTROL_PIN_Reset();
nucleosam	1:5cc2691ccfff	618	L6208_ClearSysFlag(fastdecaymode);
nucleosam	1:5cc2691ccfff	619	}
nucleosam	1:5cc2691ccfff	620	}
nucleosam	1:5cc2691ccfff	621
nucleosam	1:5cc2691ccfff	622	/****************************************************//
nucleosam	1:5cc2691ccfff	623	* @brief Set the stepper deceleration rate
nucleosam	1:5cc2691ccfff	624	* in step/s^2 and step/tick^2 for full, half and wave modes
nucleosam	1:5cc2691ccfff	625	* in microsteps/s^2 and microsteps/tick^2 for microstep modes
nucleosam	1:5cc2691ccfff	626	* @param[in] newDec new deceleration rate in step/s^2 or microstep/s^2
nucleosam	1:5cc2691ccfff	627	* @retval TRUE
nucleosam	1:5cc2691ccfff	628	* @note
nucleosam	1:5cc2691ccfff	629	**********************************************************/
nucleosam	1:5cc2691ccfff	630	bool L6208::L6208_SetDeceleration(uint16_t newDec)
nucleosam	1:5cc2691ccfff	631	{
nucleosam	1:5cc2691ccfff	632	uint16_t newDecSpt2 = L6208_ConvertAcceDecelRateValue(newDec);
nucleosam	1:5cc2691ccfff	633	if (newDecSpt2)
nucleosam	1:5cc2691ccfff	634	{
nucleosam	1:5cc2691ccfff	635	devicePrm.decelerationSps2 = newDec;
nucleosam	1:5cc2691ccfff	636	devicePrm.decelerationSpt2 = newDecSpt2;
nucleosam	1:5cc2691ccfff	637	}
nucleosam	1:5cc2691ccfff	638	else
nucleosam	1:5cc2691ccfff	639	{
nucleosam	1:5cc2691ccfff	640	L6208_ErrorHandler(L6208_ERROR_SET_DECELERATION);
nucleosam	1:5cc2691ccfff	641	}
nucleosam	1:5cc2691ccfff	642	return TRUE;
nucleosam	1:5cc2691ccfff	643	}
nucleosam	1:5cc2691ccfff	644
nucleosam	1:5cc2691ccfff	645	/****************************************************//
nucleosam	1:5cc2691ccfff	646	* @brief Specify the direction
nucleosam	1:5cc2691ccfff	647	* @param[in] dir FORWARD or BACKWARD
nucleosam	1:5cc2691ccfff	648	* @note In velocity mode a direction change forces the device to stop and
nucleosam	1:5cc2691ccfff	649	* then run in the new direction. In position mode, if the device is
nucleosam	1:5cc2691ccfff	650	* running, a direction change will generate an error.
nucleosam	1:5cc2691ccfff	651	* @retval None
nucleosam	1:5cc2691ccfff	652	**********************************************************/
nucleosam	1:5cc2691ccfff	653	void L6208::L6208_SetDirection(motorDir_t dir)
nucleosam	1:5cc2691ccfff	654	{
nucleosam	1:5cc2691ccfff	655	L6208_ClearSysFlag(dir2change);
nucleosam	1:5cc2691ccfff	656	if (dir == FORWARD)
nucleosam	1:5cc2691ccfff	657	{
nucleosam	1:5cc2691ccfff	658	if (!L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	659	{
nucleosam	1:5cc2691ccfff	660	if (L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	661	{
nucleosam	1:5cc2691ccfff	662	/* motor is running */
nucleosam	1:5cc2691ccfff	663	if (L6208_IsSysFlag(positionmode))
nucleosam	1:5cc2691ccfff	664	{
nucleosam	1:5cc2691ccfff	665	L6208_ErrorHandler(L6208_ERROR_SET_DIRECTION);
nucleosam	1:5cc2691ccfff	666	}
nucleosam	1:5cc2691ccfff	667	else
nucleosam	1:5cc2691ccfff	668	{
nucleosam	1:5cc2691ccfff	669	/* set the rotation direction to change flag */
nucleosam	1:5cc2691ccfff	670	L6208_SetSysFlag(dir2change);
nucleosam	1:5cc2691ccfff	671	}
nucleosam	1:5cc2691ccfff	672	}
nucleosam	1:5cc2691ccfff	673	else /* the motor is stopped, cw direction selected */
nucleosam	1:5cc2691ccfff	674	{
nucleosam	1:5cc2691ccfff	675	L6208_SetSysFlag(forward);
nucleosam	1:5cc2691ccfff	676	L6208_Board_DIR_PIN_Set();
nucleosam	1:5cc2691ccfff	677	}
nucleosam	1:5cc2691ccfff	678	}
nucleosam	1:5cc2691ccfff	679	}
nucleosam	1:5cc2691ccfff	680	else
nucleosam	1:5cc2691ccfff	681	{
nucleosam	1:5cc2691ccfff	682	if (L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	683	{
nucleosam	1:5cc2691ccfff	684	if (L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	685	{
nucleosam	1:5cc2691ccfff	686	/* motor is running */
nucleosam	1:5cc2691ccfff	687	if (L6208_IsSysFlag(positionmode))
nucleosam	1:5cc2691ccfff	688	{
nucleosam	1:5cc2691ccfff	689	L6208_ErrorHandler(L6208_ERROR_SET_DIRECTION);
nucleosam	1:5cc2691ccfff	690	}
nucleosam	1:5cc2691ccfff	691	else
nucleosam	1:5cc2691ccfff	692	{
nucleosam	1:5cc2691ccfff	693	/* set the rotation direction to change flag */
nucleosam	1:5cc2691ccfff	694	L6208_SetSysFlag(dir2change);
nucleosam	1:5cc2691ccfff	695	}
nucleosam	1:5cc2691ccfff	696	}
nucleosam	1:5cc2691ccfff	697	else /* the motor is stopped, ccw direction selected */
nucleosam	1:5cc2691ccfff	698	{
nucleosam	1:5cc2691ccfff	699	L6208_ClearSysFlag(forward);
nucleosam	1:5cc2691ccfff	700	L6208_Board_DIR_PIN_Reset();
nucleosam	1:5cc2691ccfff	701	}
nucleosam	1:5cc2691ccfff	702	}
nucleosam	1:5cc2691ccfff	703	}
nucleosam	1:5cc2691ccfff	704	if(L6208_IsSysFlag(dir2change))
nucleosam	1:5cc2691ccfff	705	{
nucleosam	1:5cc2691ccfff	706	L6208_VectorCalc(devicePrm.decelTorque);
nucleosam	1:5cc2691ccfff	707	L6208_SetMotionState(DECELERATINGTOSTOP);
nucleosam	1:5cc2691ccfff	708	}
nucleosam	1:5cc2691ccfff	709	}
nucleosam	1:5cc2691ccfff	710
nucleosam	1:5cc2691ccfff	711	/****************************************************//
nucleosam	1:5cc2691ccfff	712	* @brief Set current position to be the home position
nucleosam	1:5cc2691ccfff	713	* @retval None
nucleosam	1:5cc2691ccfff	714	**********************************************************/
nucleosam	1:5cc2691ccfff	715	void L6208::L6208_SetHome(void)
nucleosam	1:5cc2691ccfff	716	{
nucleosam	1:5cc2691ccfff	717	if (!L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	718	{
nucleosam	1:5cc2691ccfff	719	devicePrm.absolutePos = 0;
nucleosam	1:5cc2691ccfff	720	}
nucleosam	1:5cc2691ccfff	721	else
nucleosam	1:5cc2691ccfff	722	{
nucleosam	1:5cc2691ccfff	723	L6208_ErrorHandler(L6208_ERROR_SET_HOME);
nucleosam	1:5cc2691ccfff	724	}
nucleosam	1:5cc2691ccfff	725	}
nucleosam	1:5cc2691ccfff	726
nucleosam	1:5cc2691ccfff	727	/****************************************************//
nucleosam	1:5cc2691ccfff	728	* @brief Set current position to be the mark position
nucleosam	1:5cc2691ccfff	729	* @retval None
nucleosam	1:5cc2691ccfff	730	**********************************************************/
nucleosam	1:5cc2691ccfff	731	void L6208::L6208_SetMark(void)
nucleosam	1:5cc2691ccfff	732	{
nucleosam	1:5cc2691ccfff	733	devicePrm.markPos = devicePrm.absolutePos;
nucleosam	1:5cc2691ccfff	734	}
nucleosam	1:5cc2691ccfff	735
nucleosam	1:5cc2691ccfff	736	/****************************************************//
nucleosam	1:5cc2691ccfff	737	* @brief Set the user selected maximum speed
nucleosam	1:5cc2691ccfff	738	* in step/s and step/tick for full, half and wave modes
nucleosam	1:5cc2691ccfff	739	* in microsteps/s and microsteps/tick for microstep modes
nucleosam	1:5cc2691ccfff	740	* @param[in] newSpeed speed value (step/s or microstep/s)
nucleosam	1:5cc2691ccfff	741	* @retval TRUE
nucleosam	1:5cc2691ccfff	742	* @note One microstep is 1/16 step
nucleosam	1:5cc2691ccfff	743	**********************************************************/
nucleosam	1:5cc2691ccfff	744	bool L6208::L6208_SetMaxSpeed(uint16_t newSpeed)
nucleosam	1:5cc2691ccfff	745	{
nucleosam	1:5cc2691ccfff	746	if (L6208_SetSpeed(newSpeed, &devicePrm.maxSpeedSpt))
nucleosam	1:5cc2691ccfff	747	{
nucleosam	1:5cc2691ccfff	748	devicePrm.maxSpeedSps = newSpeed;
nucleosam	1:5cc2691ccfff	749	}
nucleosam	1:5cc2691ccfff	750	else
nucleosam	1:5cc2691ccfff	751	{
nucleosam	1:5cc2691ccfff	752	L6208_ErrorHandler(L6208_ERROR_SET_MAX_SPEED);
nucleosam	1:5cc2691ccfff	753	}
nucleosam	1:5cc2691ccfff	754	return TRUE;
nucleosam	1:5cc2691ccfff	755	}
nucleosam	1:5cc2691ccfff	756
nucleosam	1:5cc2691ccfff	757	/****************************************************//
nucleosam	1:5cc2691ccfff	758	* @brief Set the user selected minimum speed
nucleosam	1:5cc2691ccfff	759	* in step/s and step/tick for full, half and wave modes
nucleosam	1:5cc2691ccfff	760	* in microsteps/s and microsteps/tick for microstep modes
nucleosam	1:5cc2691ccfff	761	* @param[in] newSpeed speed value (step/s or microstep/s)
nucleosam	1:5cc2691ccfff	762	* @retval TRUE
nucleosam	1:5cc2691ccfff	763	* @note One microstep is 1/16 step
nucleosam	1:5cc2691ccfff	764	**********************************************************/
nucleosam	1:5cc2691ccfff	765	bool L6208::L6208_SetMinSpeed(uint16_t newSpeed)
nucleosam	1:5cc2691ccfff	766	{
nucleosam	1:5cc2691ccfff	767	if (L6208_SetSpeed(newSpeed, &devicePrm.minSpeedSpt))
nucleosam	1:5cc2691ccfff	768	{
nucleosam	1:5cc2691ccfff	769	devicePrm.minSpeedSps = newSpeed;
nucleosam	1:5cc2691ccfff	770	}
nucleosam	1:5cc2691ccfff	771	else
nucleosam	1:5cc2691ccfff	772	{
nucleosam	1:5cc2691ccfff	773	L6208_ErrorHandler(L6208_ERROR_SET_MIN_SPEED);
nucleosam	1:5cc2691ccfff	774	}
nucleosam	1:5cc2691ccfff	775	return TRUE;
nucleosam	1:5cc2691ccfff	776	}
nucleosam	1:5cc2691ccfff	777
nucleosam	1:5cc2691ccfff	778	/****************************************************//
nucleosam	1:5cc2691ccfff	779	* @brief Set the step mode
nucleosam	1:5cc2691ccfff	780	* @param[in] stepMode
nucleosam	1:5cc2691ccfff	781	* @retval true if the command is successfully executed, else false
nucleosam	1:5cc2691ccfff	782	* @note Every time the step mode is changed, the step state machine is reset
nucleosam	1:5cc2691ccfff	783	**********************************************************/
nucleosam	1:5cc2691ccfff	784	bool L6208::L6208_SetStepMode(motorStepMode_t stepMode)
nucleosam	1:5cc2691ccfff	785	{
nucleosam	1:5cc2691ccfff	786	devicePrm.stepMode = stepMode;
nucleosam	1:5cc2691ccfff	787	L6208_ClearSysFlag(fullstep \| halfstep \| microstep \| wavestep);
nucleosam	1:5cc2691ccfff	788	switch (stepMode)
nucleosam	1:5cc2691ccfff	789	{
nucleosam	1:5cc2691ccfff	790	case STEP_MODE_HALF:
nucleosam	1:5cc2691ccfff	791	/* Set the Half/Full pin low and Reset and the set the Half/Full pin high*/
nucleosam	1:5cc2691ccfff	792	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	793	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	794	L6208_Board_HALF_FULL_PIN_Set();
nucleosam	1:5cc2691ccfff	795	/* Set system flag */
nucleosam	1:5cc2691ccfff	796	L6208_SetSysFlag(halfstep);
nucleosam	1:5cc2691ccfff	797	break;
nucleosam	1:5cc2691ccfff	798	case STEP_MODE_FULL:
nucleosam	1:5cc2691ccfff	799	/* Set the Half/Full pin low and Reset */
nucleosam	1:5cc2691ccfff	800	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	801	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	802	/* Set system flag */
nucleosam	1:5cc2691ccfff	803	L6208_SetSysFlag(fullstep);
nucleosam	1:5cc2691ccfff	804	break;
nucleosam	1:5cc2691ccfff	805	case STEP_MODE_WAVE:
nucleosam	1:5cc2691ccfff	806	/* Set the Half/Full pin low and Reset and the set the Half/Full pin high*/
nucleosam	1:5cc2691ccfff	807	L6208_Board_CLOCK_PIN_Reset();
nucleosam	1:5cc2691ccfff	808	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	809	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	810	L6208_Board_CLOCK_PIN_Set();
nucleosam	1:5cc2691ccfff	811	L6208_Board_HALF_FULL_PIN_Set();
nucleosam	1:5cc2691ccfff	812	L6208_Board_Delay(2);
nucleosam	1:5cc2691ccfff	813	L6208_Board_CLOCK_PIN_Reset();
nucleosam	1:5cc2691ccfff	814	L6208_Board_Delay(2);
nucleosam	1:5cc2691ccfff	815	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	816	/* Set system flag */
nucleosam	1:5cc2691ccfff	817	L6208_SetSysFlag(wavestep);
nucleosam	1:5cc2691ccfff	818	break;
nucleosam	1:5cc2691ccfff	819	case STEP_MODE_1_4:
nucleosam	1:5cc2691ccfff	820	/* Set the Half/Full pin low and Reset */
nucleosam	1:5cc2691ccfff	821	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	822	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	823	/* Set system flag */
nucleosam	1:5cc2691ccfff	824	L6208_SetSysFlag(microstep);
nucleosam	1:5cc2691ccfff	825	devicePrm.uStepInc = 4;
nucleosam	1:5cc2691ccfff	826	break;
nucleosam	1:5cc2691ccfff	827	case STEP_MODE_1_8:
nucleosam	1:5cc2691ccfff	828	/* Set the Half/Full pin low and Reset */
nucleosam	1:5cc2691ccfff	829	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	830	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	831	/* Set system flag */
nucleosam	1:5cc2691ccfff	832	L6208_SetSysFlag(microstep);
nucleosam	1:5cc2691ccfff	833	devicePrm.uStepInc = 2;
nucleosam	1:5cc2691ccfff	834	break;
nucleosam	1:5cc2691ccfff	835	case STEP_MODE_1_16:
nucleosam	1:5cc2691ccfff	836	/* Set the Half/Full pin low and Reset */
nucleosam	1:5cc2691ccfff	837	L6208_Board_HALF_FULL_PIN_Reset();
nucleosam	1:5cc2691ccfff	838	L6208_Board_Reset();
nucleosam	1:5cc2691ccfff	839	/* Set system flag */
nucleosam	1:5cc2691ccfff	840	L6208_SetSysFlag(microstep);
nucleosam	1:5cc2691ccfff	841	devicePrm.uStepInc = 1;
nucleosam	1:5cc2691ccfff	842	break;
nucleosam	1:5cc2691ccfff	843	default:
nucleosam	1:5cc2691ccfff	844	return FALSE;
nucleosam	1:5cc2691ccfff	845	}
nucleosam	1:5cc2691ccfff	846	L6208_Board_Delay(2);
nucleosam	1:5cc2691ccfff	847	L6208_Board_ReleaseReset();
nucleosam	1:5cc2691ccfff	848	L6208_ResetSteps();
nucleosam	1:5cc2691ccfff	849	return TRUE;
nucleosam	1:5cc2691ccfff	850	}
nucleosam	1:5cc2691ccfff	851
nucleosam	1:5cc2691ccfff	852	/****************************************************//
nucleosam	1:5cc2691ccfff	853	* @brief Select the mode to stop the motor. When the motor
nucleosam	1:5cc2691ccfff	854	* is stopped, if autoHiZ is TRUE, the power bridges are disabled
nucleosam	1:5cc2691ccfff	855	* if autoHiZ is FALSE, the power bridges are kept enabled.
nucleosam	1:5cc2691ccfff	856	* @param[in] stopMode HOLD_MODE to let power bridge enabled
nucleosam	1:5cc2691ccfff	857	* @retval None
nucleosam	1:5cc2691ccfff	858	**********************************************************/
nucleosam	1:5cc2691ccfff	859	void L6208::L6208_SetStopMode(motorStopMode_t stopMode)
nucleosam	1:5cc2691ccfff	860	{
nucleosam	1:5cc2691ccfff	861	if (stopMode == HOLD_MODE)
nucleosam	1:5cc2691ccfff	862	{
nucleosam	1:5cc2691ccfff	863	L6208_ClearSysFlag(HiZstop);
nucleosam	1:5cc2691ccfff	864	}
nucleosam	1:5cc2691ccfff	865	else
nucleosam	1:5cc2691ccfff	866	{
nucleosam	1:5cc2691ccfff	867	L6208_SetSysFlag(HiZstop);
nucleosam	1:5cc2691ccfff	868	}
nucleosam	1:5cc2691ccfff	869	}
nucleosam	1:5cc2691ccfff	870
nucleosam	1:5cc2691ccfff	871	/****************************************************//
nucleosam	1:5cc2691ccfff	872	* @brief Stop the motor by using the device deceleration and set deceleration torque
nucleosam	1:5cc2691ccfff	873	* @retval true if the command is successfully executed, else false
nucleosam	1:5cc2691ccfff	874	* @note .
nucleosam	1:5cc2691ccfff	875	**********************************************************/
nucleosam	1:5cc2691ccfff	876	bool L6208::L6208_SoftStop(void)
nucleosam	1:5cc2691ccfff	877	{
nucleosam	1:5cc2691ccfff	878	L6208_VectorCalc(devicePrm.decelTorque);
nucleosam	1:5cc2691ccfff	879	L6208_SetMotionState(DECELERATINGTOSTOP);
nucleosam	1:5cc2691ccfff	880	return TRUE;
nucleosam	1:5cc2691ccfff	881	}
nucleosam	1:5cc2691ccfff	882
nucleosam	1:5cc2691ccfff	883	/****************************************************//
nucleosam	1:5cc2691ccfff	884	* @brief Handle the device state machine at each tick timer pulse end.
nucleosam	1:5cc2691ccfff	885	* @retval None
nucleosam	1:5cc2691ccfff	886	**********************************************************/
nucleosam	1:5cc2691ccfff	887	void L6208::L6208_TickHandler(void)
nucleosam	1:5cc2691ccfff	888	{
nucleosam	1:5cc2691ccfff	889	uint32_t locMaxSpeedSpt = devicePrm.maxSpeedSpt;
nucleosam	1:5cc2691ccfff	890	uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
nucleosam	1:5cc2691ccfff	891
nucleosam	1:5cc2691ccfff	892	/* Update state, target speed, acceleration and deceleration rates */
nucleosam	1:5cc2691ccfff	893	L6208_Board_CLOCK_PIN_Reset();
nucleosam	1:5cc2691ccfff	894
nucleosam	1:5cc2691ccfff	895	switch(L6208_GetMotionState())
nucleosam	1:5cc2691ccfff	896	{
nucleosam	1:5cc2691ccfff	897	/* ============ Velocity control mode states ======================== */
nucleosam	1:5cc2691ccfff	898	case ACCELERATING:
nucleosam	1:5cc2691ccfff	899	/* velocity mode: acceleration phase */
nucleosam	1:5cc2691ccfff	900	/* Increase Speed and update position */
nucleosam	1:5cc2691ccfff	901	L6208_DoAccel();
nucleosam	1:5cc2691ccfff	902	if(locMaxSpeedSpt < devicePrm.speedSpt)
nucleosam	1:5cc2691ccfff	903	{
nucleosam	1:5cc2691ccfff	904	/Target speed reached /
nucleosam	1:5cc2691ccfff	905	devicePrm.speedSpt = locMaxSpeedSpt;
nucleosam	1:5cc2691ccfff	906	L6208_VectorCalc(devicePrm.runTorque);
nucleosam	1:5cc2691ccfff	907	L6208_SetMotionState(STEADY);
nucleosam	1:5cc2691ccfff	908	}
nucleosam	1:5cc2691ccfff	909	break;
nucleosam	1:5cc2691ccfff	910	case STEADY:
nucleosam	1:5cc2691ccfff	911	/* velocity mode: constant speed phase */
nucleosam	1:5cc2691ccfff	912	/* Update position */
nucleosam	1:5cc2691ccfff	913	L6208_DoRun();
nucleosam	1:5cc2691ccfff	914	if(locMaxSpeedSpt != devicePrm.speedSpt)
nucleosam	1:5cc2691ccfff	915	{
nucleosam	1:5cc2691ccfff	916	/* targeted speed has changed */
nucleosam	1:5cc2691ccfff	917	if(locMaxSpeedSpt< devicePrm.speedSpt)
nucleosam	1:5cc2691ccfff	918	{
nucleosam	1:5cc2691ccfff	919	/* Slow down the motor */
nucleosam	1:5cc2691ccfff	920	L6208_VectorCalc(devicePrm.decelTorque);
nucleosam	1:5cc2691ccfff	921	L6208_SetMotionState(DECELERATING);
nucleosam	1:5cc2691ccfff	922	}
nucleosam	1:5cc2691ccfff	923	else
nucleosam	1:5cc2691ccfff	924	{
nucleosam	1:5cc2691ccfff	925	/* speed up the motor */
nucleosam	1:5cc2691ccfff	926	L6208_VectorCalc(devicePrm.accelTorque);
nucleosam	1:5cc2691ccfff	927	L6208_SetMotionState(ACCELERATING);
nucleosam	1:5cc2691ccfff	928	}
nucleosam	1:5cc2691ccfff	929	}
nucleosam	1:5cc2691ccfff	930	break;
nucleosam	1:5cc2691ccfff	931	case DECELERATING:
nucleosam	1:5cc2691ccfff	932	/* velocity mode: running motor deceleration phase */
nucleosam	1:5cc2691ccfff	933	/* Decrease Speed and update position */
nucleosam	1:5cc2691ccfff	934	L6208_DoDecel();
nucleosam	1:5cc2691ccfff	935	if(locMaxSpeedSpt > devicePrm.speedSpt)
nucleosam	1:5cc2691ccfff	936	{
nucleosam	1:5cc2691ccfff	937	/Target speed reached but motor has still to be run/
nucleosam	1:5cc2691ccfff	938	devicePrm.speedSpt = locMaxSpeedSpt;
nucleosam	1:5cc2691ccfff	939	L6208_VectorCalc(devicePrm.runTorque);
nucleosam	1:5cc2691ccfff	940	L6208_SetMotionState(STEADY);
nucleosam	1:5cc2691ccfff	941	}
nucleosam	1:5cc2691ccfff	942	break;
nucleosam	1:5cc2691ccfff	943	case DECELERATINGTOSTOP:
nucleosam	1:5cc2691ccfff	944	/* velocity mode: decelerate to stopped phase */
nucleosam	1:5cc2691ccfff	945	/* Decrease current speed */
nucleosam	1:5cc2691ccfff	946	L6208_DoDecel();
nucleosam	1:5cc2691ccfff	947	if(devicePrm.speedSpt == locMinSpeedSpt)
nucleosam	1:5cc2691ccfff	948	{
nucleosam	1:5cc2691ccfff	949	if (L6208_IsSysFlag(dir2change))
nucleosam	1:5cc2691ccfff	950	{
nucleosam	1:5cc2691ccfff	951	L6208_ClearSysFlag(running);
nucleosam	1:5cc2691ccfff	952	/* Change direction */
nucleosam	1:5cc2691ccfff	953	if (L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	954	{
nucleosam	1:5cc2691ccfff	955	/* switch to reverse rotation */
nucleosam	1:5cc2691ccfff	956	L6208_SetDirection(BACKWARD);
nucleosam	1:5cc2691ccfff	957	}
nucleosam	1:5cc2691ccfff	958	else
nucleosam	1:5cc2691ccfff	959	{
nucleosam	1:5cc2691ccfff	960	/* switch to forward rotation */
nucleosam	1:5cc2691ccfff	961	L6208_SetDirection(FORWARD);
nucleosam	1:5cc2691ccfff	962	}
nucleosam	1:5cc2691ccfff	963	L6208_SetSysFlag(running);
nucleosam	1:5cc2691ccfff	964	L6208_SetMotionState(ACCELERATING);
nucleosam	1:5cc2691ccfff	965	/* Set VRefA and VRefB to the selected acceleration torque */
nucleosam	1:5cc2691ccfff	966	L6208_VectorCalc(devicePrm.accelTorque);
nucleosam	1:5cc2691ccfff	967	}
nucleosam	1:5cc2691ccfff	968	else
nucleosam	1:5cc2691ccfff	969	{
nucleosam	1:5cc2691ccfff	970	if (L6208_IsSysFlag(HiZstop))
nucleosam	1:5cc2691ccfff	971	{
nucleosam	1:5cc2691ccfff	972	L6208_HardHiZ();
nucleosam	1:5cc2691ccfff	973	}
nucleosam	1:5cc2691ccfff	974	else
nucleosam	1:5cc2691ccfff	975	{
nucleosam	1:5cc2691ccfff	976	L6208_HardStop();
nucleosam	1:5cc2691ccfff	977	}
nucleosam	1:5cc2691ccfff	978	}
nucleosam	1:5cc2691ccfff	979	}
nucleosam	1:5cc2691ccfff	980	break;
nucleosam	1:5cc2691ccfff	981
nucleosam	1:5cc2691ccfff	982	/* ============ Position (indexed) control mode states ======================== */
nucleosam	1:5cc2691ccfff	983
nucleosam	1:5cc2691ccfff	984	case INDEX_ACCEL:
nucleosam	1:5cc2691ccfff	985	/* position mode: acceleration state*/
nucleosam	1:5cc2691ccfff	986
nucleosam	1:5cc2691ccfff	987	/* Increase Speed and update position */
nucleosam	1:5cc2691ccfff	988	L6208_DoAccel();
nucleosam	1:5cc2691ccfff	989
nucleosam	1:5cc2691ccfff	990	if(devicePrm.positionTarget1 <= devicePrm.step)
nucleosam	1:5cc2691ccfff	991	{
nucleosam	1:5cc2691ccfff	992	/* End of acceleration phase */
nucleosam	1:5cc2691ccfff	993	L6208_VectorCalc(devicePrm.runTorque);
nucleosam	1:5cc2691ccfff	994	L6208_SetMotionState(INDEX_RUN);
nucleosam	1:5cc2691ccfff	995	}
nucleosam	1:5cc2691ccfff	996	break;
nucleosam	1:5cc2691ccfff	997
nucleosam	1:5cc2691ccfff	998	case INDEX_RUN:
nucleosam	1:5cc2691ccfff	999	/* position mode: constant speed phase */
nucleosam	1:5cc2691ccfff	1000
nucleosam	1:5cc2691ccfff	1001	/* Update position */
nucleosam	1:5cc2691ccfff	1002	L6208_DoRun();
nucleosam	1:5cc2691ccfff	1003
nucleosam	1:5cc2691ccfff	1004	if(devicePrm.positionTarget2 <= devicePrm.step)
nucleosam	1:5cc2691ccfff	1005	{
nucleosam	1:5cc2691ccfff	1006	/* reach position targeted for constant speed */
nucleosam	1:5cc2691ccfff	1007	L6208_VectorCalc(devicePrm.decelTorque);
nucleosam	1:5cc2691ccfff	1008	L6208_SetMotionState(INDEX_DECEL);
nucleosam	1:5cc2691ccfff	1009	}
nucleosam	1:5cc2691ccfff	1010	break;
nucleosam	1:5cc2691ccfff	1011
nucleosam	1:5cc2691ccfff	1012	case INDEX_DECEL:
nucleosam	1:5cc2691ccfff	1013	/* position mode: deceleration phase */
nucleosam	1:5cc2691ccfff	1014
nucleosam	1:5cc2691ccfff	1015	/* Decrease Speed and update position */
nucleosam	1:5cc2691ccfff	1016	L6208_DoDecel();
nucleosam	1:5cc2691ccfff	1017
nucleosam	1:5cc2691ccfff	1018	if(devicePrm.positionTarget3 <= devicePrm.step)
nucleosam	1:5cc2691ccfff	1019	{
nucleosam	1:5cc2691ccfff	1020	/* reach position targeted for deceleration phase */
nucleosam	1:5cc2691ccfff	1021	/* the motor terminated its run */
nucleosam	1:5cc2691ccfff	1022	/* the torque will be the deceleration one */
nucleosam	1:5cc2691ccfff	1023	devicePrm.step = devicePrm.positionTarget3;
nucleosam	1:5cc2691ccfff	1024	L6208_SetMotionState(INDEX_DWELL);
nucleosam	1:5cc2691ccfff	1025	}
nucleosam	1:5cc2691ccfff	1026	break;
nucleosam	1:5cc2691ccfff	1027
nucleosam	1:5cc2691ccfff	1028	case INDEX_DWELL:
nucleosam	1:5cc2691ccfff	1029	/* position mode: dwelling state */
nucleosam	1:5cc2691ccfff	1030	if(devicePrm.dwellCounter > 0)
nucleosam	1:5cc2691ccfff	1031	{
nucleosam	1:5cc2691ccfff	1032	/* decrease the dwelling wait tick counter */
nucleosam	1:5cc2691ccfff	1033	devicePrm.dwellCounter--;
nucleosam	1:5cc2691ccfff	1034	}
nucleosam	1:5cc2691ccfff	1035	if(devicePrm.dwellCounter == 0)
nucleosam	1:5cc2691ccfff	1036	{
nucleosam	1:5cc2691ccfff	1037	/* dwelling wait time is elapsed */
nucleosam	1:5cc2691ccfff	1038	/* so stop the motor */
nucleosam	1:5cc2691ccfff	1039	if (L6208_IsSysFlag(HiZstop))
nucleosam	1:5cc2691ccfff	1040	{
nucleosam	1:5cc2691ccfff	1041	L6208_HardHiZ();
nucleosam	1:5cc2691ccfff	1042	}
nucleosam	1:5cc2691ccfff	1043	else
nucleosam	1:5cc2691ccfff	1044	{
nucleosam	1:5cc2691ccfff	1045	L6208_HardStop();
nucleosam	1:5cc2691ccfff	1046	}
nucleosam	1:5cc2691ccfff	1047	}
nucleosam	1:5cc2691ccfff	1048	break;
nucleosam	1:5cc2691ccfff	1049
nucleosam	1:5cc2691ccfff	1050	/* ============ stopped state ======================== */
nucleosam	1:5cc2691ccfff	1051	case INACTIVE:
nucleosam	1:5cc2691ccfff	1052	{
nucleosam	1:5cc2691ccfff	1053	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	1054	{
nucleosam	1:5cc2691ccfff	1055	/* clear the user move command executing */
nucleosam	1:5cc2691ccfff	1056	/* and the motor running flags */
nucleosam	1:5cc2691ccfff	1057	L6208_ClearSysFlag(running);
nucleosam	1:5cc2691ccfff	1058	}
nucleosam	1:5cc2691ccfff	1059	break;
nucleosam	1:5cc2691ccfff	1060	}
nucleosam	1:5cc2691ccfff	1061	default:
nucleosam	1:5cc2691ccfff	1062	break;
nucleosam	1:5cc2691ccfff	1063	} /* switch(L6208_GetMotionState()) */
nucleosam	1:5cc2691ccfff	1064	if(L6208_GetMotionState() != INACTIVE)
nucleosam	1:5cc2691ccfff	1065	{
nucleosam	1:5cc2691ccfff	1066	if (L6208_IsSysFlag(microstep))
nucleosam	1:5cc2691ccfff	1067	{
nucleosam	1:5cc2691ccfff	1068	/* Microstep handling */
nucleosam	1:5cc2691ccfff	1069	switch(devicePrm.uStepInc)
nucleosam	1:5cc2691ccfff	1070	{
nucleosam	1:5cc2691ccfff	1071	default:
nucleosam	1:5cc2691ccfff	1072	case 1:
nucleosam	1:5cc2691ccfff	1073	/* 1 microstep increment */
nucleosam	1:5cc2691ccfff	1074	devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>16);
nucleosam	1:5cc2691ccfff	1075	break;
nucleosam	1:5cc2691ccfff	1076
nucleosam	1:5cc2691ccfff	1077	case 2:
nucleosam	1:5cc2691ccfff	1078	/* 2 microsteps increment */
nucleosam	1:5cc2691ccfff	1079	devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>17);
nucleosam	1:5cc2691ccfff	1080	break;
nucleosam	1:5cc2691ccfff	1081
nucleosam	1:5cc2691ccfff	1082	case 4:
nucleosam	1:5cc2691ccfff	1083	/* 4 microsteps increment */
nucleosam	1:5cc2691ccfff	1084	devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>18);
nucleosam	1:5cc2691ccfff	1085	break;
nucleosam	1:5cc2691ccfff	1086	}
nucleosam	1:5cc2691ccfff	1087	devicePrm.lsbTicks &= 0x01;
nucleosam	1:5cc2691ccfff	1088	if(devicePrm.lsbOldUSteppingTicks != devicePrm.lsbTicks)
nucleosam	1:5cc2691ccfff	1089	{
nucleosam	1:5cc2691ccfff	1090	/* waveform sample to update */
nucleosam	1:5cc2691ccfff	1091	devicePrm.lsbOldUSteppingTicks = devicePrm.lsbTicks;
nucleosam	1:5cc2691ccfff	1092	devicePrm.step++;
nucleosam	1:5cc2691ccfff	1093	if(L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	1094	{
nucleosam	1:5cc2691ccfff	1095	/* the motor is going forward */
nucleosam	1:5cc2691ccfff	1096	devicePrm.absolutePos++;
nucleosam	1:5cc2691ccfff	1097	/* Reset the absolute motor position in step/microsteps */
nucleosam	1:5cc2691ccfff	1098	/* Get next microstep sample */
nucleosam	1:5cc2691ccfff	1099	devicePrm.uStepSample += devicePrm.uStepInc;
nucleosam	1:5cc2691ccfff	1100	if(devicePrm.uStepSample > 31)
nucleosam	1:5cc2691ccfff	1101	{
nucleosam	1:5cc2691ccfff	1102	devicePrm.uStepSample = 0;
nucleosam	1:5cc2691ccfff	1103	}
nucleosam	1:5cc2691ccfff	1104	}
nucleosam	1:5cc2691ccfff	1105	else
nucleosam	1:5cc2691ccfff	1106	{
nucleosam	1:5cc2691ccfff	1107	/* the motor is going backward */
nucleosam	1:5cc2691ccfff	1108	devicePrm.absolutePos--;
nucleosam	1:5cc2691ccfff	1109	if(devicePrm.uStepSample >= devicePrm.uStepInc)
nucleosam	1:5cc2691ccfff	1110	{
nucleosam	1:5cc2691ccfff	1111	/* Get previous microstep sample */
nucleosam	1:5cc2691ccfff	1112	devicePrm.uStepSample -= devicePrm.uStepInc;
nucleosam	1:5cc2691ccfff	1113	}
nucleosam	1:5cc2691ccfff	1114	else
nucleosam	1:5cc2691ccfff	1115	{
nucleosam	1:5cc2691ccfff	1116	devicePrm.uStepSample = 32 - devicePrm.uStepInc;
nucleosam	1:5cc2691ccfff	1117	}
nucleosam	1:5cc2691ccfff	1118	}
nucleosam	1:5cc2691ccfff	1119	/* set the PWM to update VRefs */
nucleosam	1:5cc2691ccfff	1120	L6208_VrefPwmComputePulseWidth(BRIDGE_A, pMicroTable2[devicePrm.uStepSample], FALSE);
nucleosam	1:5cc2691ccfff	1121	L6208_VrefPwmComputePulseWidth(BRIDGE_B, microTable1[devicePrm.uStepSample], FALSE);
nucleosam	1:5cc2691ccfff	1122	if(devicePrm.uStepsample2update > 0)
nucleosam	1:5cc2691ccfff	1123	{
nucleosam	1:5cc2691ccfff	1124	/* the waveform samples table has been recalculated
nucleosam	1:5cc2691ccfff	1125	so update the waveform scanning table */
nucleosam	1:5cc2691ccfff	1126	L6208_UpdateScanWaveformTable();
nucleosam	1:5cc2691ccfff	1127	devicePrm.uStepsample2update = 0;
nucleosam	1:5cc2691ccfff	1128	}
nucleosam	1:5cc2691ccfff	1129	}
nucleosam	1:5cc2691ccfff	1130	/* Microstep: use the bit4 toggling as step clock */
nucleosam	1:5cc2691ccfff	1131	/* this bit is used because there are 16 microstep samples per quarter period */
nucleosam	1:5cc2691ccfff	1132	devicePrm.lsbTicks = (uint8_t)((devicePrm.uStepSample>>4) & 0x01);
nucleosam	1:5cc2691ccfff	1133	if(devicePrm.lsbOldTicks != devicePrm.lsbTicks)
nucleosam	1:5cc2691ccfff	1134	{
nucleosam	1:5cc2691ccfff	1135	/* the selected bit status changed ==> get the next motor step
nucleosam	1:5cc2691ccfff	1136	save the current masked motor tick position for step setting scope ... */
nucleosam	1:5cc2691ccfff	1137	devicePrm.lsbOldTicks = devicePrm.lsbTicks;
nucleosam	1:5cc2691ccfff	1138	L6208_Board_CLOCK_PIN_Set();
nucleosam	1:5cc2691ccfff	1139	}
nucleosam	1:5cc2691ccfff	1140	}
nucleosam	1:5cc2691ccfff	1141	else
nucleosam	1:5cc2691ccfff	1142	{
nucleosam	1:5cc2691ccfff	1143	/* Full and half step handling code */
nucleosam	1:5cc2691ccfff	1144	if(!L6208_IsSysFlag(halfstep))
nucleosam	1:5cc2691ccfff	1145	{
nucleosam	1:5cc2691ccfff	1146	/* Full step: use the bit 16 toggling as step clock */
nucleosam	1:5cc2691ccfff	1147	devicePrm.lsbTicks = (uint8_t)((devicePrm.ticks>>16) & 0x00000001);
nucleosam	1:5cc2691ccfff	1148	}
nucleosam	1:5cc2691ccfff	1149	else
nucleosam	1:5cc2691ccfff	1150	{
nucleosam	1:5cc2691ccfff	1151	/* half step: use the bit 15 toggling as step clock */
nucleosam	1:5cc2691ccfff	1152	devicePrm.lsbTicks = (uint8_t)((devicePrm.ticks>>15) & 0x00000001);
nucleosam	1:5cc2691ccfff	1153	}
nucleosam	1:5cc2691ccfff	1154	if(devicePrm.lsbOldTicks != devicePrm.lsbTicks)
nucleosam	1:5cc2691ccfff	1155	{
nucleosam	1:5cc2691ccfff	1156	/* the selected bit status changed ==> get the next motor step */
nucleosam	1:5cc2691ccfff	1157	devicePrm.step++;
nucleosam	1:5cc2691ccfff	1158	if(L6208_IsSysFlag(forward))
nucleosam	1:5cc2691ccfff	1159	{
nucleosam	1:5cc2691ccfff	1160	/* the motor is going forward */
nucleosam	1:5cc2691ccfff	1161	devicePrm.absolutePos++;
nucleosam	1:5cc2691ccfff	1162	}
nucleosam	1:5cc2691ccfff	1163	else
nucleosam	1:5cc2691ccfff	1164	{
nucleosam	1:5cc2691ccfff	1165	/* the motor is going backward */
nucleosam	1:5cc2691ccfff	1166	devicePrm.absolutePos--;
nucleosam	1:5cc2691ccfff	1167	}
nucleosam	1:5cc2691ccfff	1168	/* save the current masked motor tick position for step setting scope ... */
nucleosam	1:5cc2691ccfff	1169	devicePrm.lsbOldTicks = devicePrm.lsbTicks;
nucleosam	1:5cc2691ccfff	1170	L6208_Board_CLOCK_PIN_Set();
nucleosam	1:5cc2691ccfff	1171	}
nucleosam	1:5cc2691ccfff	1172	}
nucleosam	1:5cc2691ccfff	1173	}
nucleosam	1:5cc2691ccfff	1174	L6208_UstepWaveformHandling();
nucleosam	1:5cc2691ccfff	1175	L6208_VrefPwmUpdatePulseWidth();
nucleosam	1:5cc2691ccfff	1176	}
nucleosam	1:5cc2691ccfff	1177
nucleosam	1:5cc2691ccfff	1178	/****************************************************//
nucleosam	1:5cc2691ccfff	1179	* @brief Get the frequency of VREFA and VREFB PWM
nucleosam	1:5cc2691ccfff	1180	* @retval the frequency of VREFA and VREFB PWM in Hz
nucleosam	1:5cc2691ccfff	1181	* @note
nucleosam	1:5cc2691ccfff	1182	**********************************************************/
nucleosam	1:5cc2691ccfff	1183	uint32_t L6208::L6208_VrefPwmGetFreq(void)
nucleosam	1:5cc2691ccfff	1184	{
nucleosam	1:5cc2691ccfff	1185	return devicePrm.vrefPwmFreq;
nucleosam	1:5cc2691ccfff	1186	}
nucleosam	1:5cc2691ccfff	1187
nucleosam	1:5cc2691ccfff	1188	/****************************************************//
nucleosam	1:5cc2691ccfff	1189	* @brief Set the frequency of the VREFA and VREFB PWM
nucleosam	1:5cc2691ccfff	1190	* @param[in] newFreq in Hz
nucleosam	1:5cc2691ccfff	1191	* @retval None
nucleosam	1:5cc2691ccfff	1192	* @note
nucleosam	1:5cc2691ccfff	1193	**********************************************************/
nucleosam	1:5cc2691ccfff	1194	void L6208::L6208_VrefPwmSetFreq(uint32_t newFreq)
nucleosam	1:5cc2691ccfff	1195	{
nucleosam	1:5cc2691ccfff	1196	devicePrm.vrefPwmFreq = newFreq;
nucleosam	1:5cc2691ccfff	1197	/* Compute the pwm period in 1/256th of a microsecond */
nucleosam	1:5cc2691ccfff	1198	devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/newFreq);
nucleosam	1:5cc2691ccfff	1199	/* Re-Initialise the PWMs -----------------------------------------------------*/
nucleosam	1:5cc2691ccfff	1200	L6208_Board_VrefPwmInit(BRIDGE_A, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1201	L6208_Board_VrefPwmInit(BRIDGE_B, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1202	/* Recompute the waveform samples according to the new PWM frequency */
nucleosam	1:5cc2691ccfff	1203	L6208_ScaleWaveformTable();
nucleosam	1:5cc2691ccfff	1204	/* Update the waveform scanning table */
nucleosam	1:5cc2691ccfff	1205	L6208_UpdateScanWaveformTable();
nucleosam	1:5cc2691ccfff	1206	if (L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	1207	{
nucleosam	1:5cc2691ccfff	1208	L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1209	L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1210	}
nucleosam	1:5cc2691ccfff	1211	}
nucleosam	1:5cc2691ccfff	1212
nucleosam	1:5cc2691ccfff	1213	/****************************************************//
nucleosam	1:5cc2691ccfff	1214	* @brief Lock while motor is running
nucleosam	1:5cc2691ccfff	1215	* @retval None
nucleosam	1:5cc2691ccfff	1216	**********************************************************/
nucleosam	1:5cc2691ccfff	1217	void L6208::L6208_WaitWhileActive(void)
nucleosam	1:5cc2691ccfff	1218	{
nucleosam	1:5cc2691ccfff	1219	/* Wait while motor is running */
nucleosam	1:5cc2691ccfff	1220	while (L6208_IsSysFlag(running));
nucleosam	1:5cc2691ccfff	1221	}
nucleosam	1:5cc2691ccfff	1222
nucleosam	1:5cc2691ccfff	1223	/* ------------------------------------------------------------------------- */
nucleosam	1:5cc2691ccfff	1224	/* Private functions ------------------------------------------------------- */
nucleosam	1:5cc2691ccfff	1225	/* ------------------------------------------------------------------------- */
nucleosam	1:5cc2691ccfff	1226	/****************************************************//
nucleosam	1:5cc2691ccfff	1227	* @brief Clear the bit/s of flags according to the specified mask
nucleosam	1:5cc2691ccfff	1228	* @param[in] mask flag bit mask
nucleosam	1:5cc2691ccfff	1229	* @retval None
nucleosam	1:5cc2691ccfff	1230	**********************************************************/
nucleosam	1:5cc2691ccfff	1231	inline void L6208::L6208_ClearSysFlag(uint32_t mask)
nucleosam	1:5cc2691ccfff	1232	{
nucleosam	1:5cc2691ccfff	1233	devicePrm.flags &= ~mask;
nucleosam	1:5cc2691ccfff	1234	}
nucleosam	1:5cc2691ccfff	1235
nucleosam	1:5cc2691ccfff	1236	/****************************************************//
nucleosam	1:5cc2691ccfff	1237	* @brief Compute the number of steps at the end of the accereration/deceleration phase
nucleosam	1:5cc2691ccfff	1238	* P = position in steps at the end of the acceleration/deceleration phase
nucleosam	1:5cc2691ccfff	1239	* T = acceleration/deceleration time in seconds
nucleosam	1:5cc2691ccfff	1240	* A = acceleration/deceleration rate in steps per second per second (steps/sec^2)
nucleosam	1:5cc2691ccfff	1241	* V = peak velocity during acceleration/deceleration phase
nucleosam	1:5cc2691ccfff	1242	* V1 = average velocity during acceleration/deceleration phase
nucleosam	1:5cc2691ccfff	1243	* T = V/A
nucleosam	1:5cc2691ccfff	1244	* V1 = V/2
nucleosam	1:5cc2691ccfff	1245	* P = V1*T
nucleosam	1:5cc2691ccfff	1246	* P = V^2/2A
nucleosam	1:5cc2691ccfff	1247	* @param accOrDecRate acceleration/deceleration rate in steps per second per second (steps/sec^2)
nucleosam	1:5cc2691ccfff	1248	* @retval end position or 0xFFFFFFFF on error
nucleosam	1:5cc2691ccfff	1249	**********************************************************/
nucleosam	1:5cc2691ccfff	1250	uint32_t L6208::L6208_ComputeNbAccOrDecSteps(uint16_t accOrDecRate)
nucleosam	1:5cc2691ccfff	1251	{
nucleosam	1:5cc2691ccfff	1252	uint32_t nbAccOrDecSteps;
nucleosam	1:5cc2691ccfff	1253	uint32_t locMaxSpeedSps = (uint32_t)devicePrm.maxSpeedSps;
nucleosam	1:5cc2691ccfff	1254
nucleosam	1:5cc2691ccfff	1255	if (L6208_IsSysFlag(microstep))
nucleosam	1:5cc2691ccfff	1256	{
nucleosam	1:5cc2691ccfff	1257	switch(devicePrm.uStepInc)
nucleosam	1:5cc2691ccfff	1258	{
nucleosam	1:5cc2691ccfff	1259	case 1:
nucleosam	1:5cc2691ccfff	1260	locMaxSpeedSps = (uint32_t)devicePrm.maxSpeedSps;
nucleosam	1:5cc2691ccfff	1261	break;
nucleosam	1:5cc2691ccfff	1262	case 2:
nucleosam	1:5cc2691ccfff	1263	locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)>>1;
nucleosam	1:5cc2691ccfff	1264	accOrDecRate >>= 1;
nucleosam	1:5cc2691ccfff	1265	break;
nucleosam	1:5cc2691ccfff	1266	case 4:
nucleosam	1:5cc2691ccfff	1267	locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)>>2;
nucleosam	1:5cc2691ccfff	1268	accOrDecRate >>= 2;
nucleosam	1:5cc2691ccfff	1269	break;
nucleosam	1:5cc2691ccfff	1270	default:
nucleosam	1:5cc2691ccfff	1271	break;
nucleosam	1:5cc2691ccfff	1272	}
nucleosam	1:5cc2691ccfff	1273	}
nucleosam	1:5cc2691ccfff	1274	else if (L6208_IsSysFlag(halfstep))
nucleosam	1:5cc2691ccfff	1275	{
nucleosam	1:5cc2691ccfff	1276	locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)<<1;
nucleosam	1:5cc2691ccfff	1277	accOrDecRate <<= 1;
nucleosam	1:5cc2691ccfff	1278	}
nucleosam	1:5cc2691ccfff	1279
nucleosam	1:5cc2691ccfff	1280	if(accOrDecRate == 0)
nucleosam	1:5cc2691ccfff	1281	{
nucleosam	1:5cc2691ccfff	1282	/* division by 0 error */
nucleosam	1:5cc2691ccfff	1283	return 0xFFFFFFFF;
nucleosam	1:5cc2691ccfff	1284	}
nucleosam	1:5cc2691ccfff	1285	nbAccOrDecSteps = locMaxSpeedSps * locMaxSpeedSps;
nucleosam	1:5cc2691ccfff	1286	nbAccOrDecSteps /= (uint32_t)accOrDecRate;
nucleosam	1:5cc2691ccfff	1287	nbAccOrDecSteps /= 2;
nucleosam	1:5cc2691ccfff	1288
nucleosam	1:5cc2691ccfff	1289	return nbAccOrDecSteps;
nucleosam	1:5cc2691ccfff	1290	}
nucleosam	1:5cc2691ccfff	1291
nucleosam	1:5cc2691ccfff	1292	/****************************************************//
nucleosam	1:5cc2691ccfff	1293	* @brief Compute the acceleration/deceleration speed increment value
nucleosam	1:5cc2691ccfff	1294	* @param[in] newAccOrDecRate acceleration or deceleration value (steps/s^2) greater or equal than 24
nucleosam	1:5cc2691ccfff	1295	* @retval the speed (step/tick) increment value
nucleosam	1:5cc2691ccfff	1296	* LSB = 2^-24 step/tick^2 or 2^-20 microstep/tick^2
nucleosam	1:5cc2691ccfff	1297	* @note return 0 if the rate is too low or if the tick frequency is too small
nucleosam	1:5cc2691ccfff	1298	* or if the device is running in position mode
nucleosam	1:5cc2691ccfff	1299	**********************************************************/
nucleosam	1:5cc2691ccfff	1300	uint16_t L6208::L6208_ConvertAcceDecelRateValue(uint16_t newAccOrDecRate)
nucleosam	1:5cc2691ccfff	1301	{
nucleosam	1:5cc2691ccfff	1302	uint64_t tmp64;
nucleosam	1:5cc2691ccfff	1303	uint32_t tmp32;
nucleosam	1:5cc2691ccfff	1304
nucleosam	1:5cc2691ccfff	1305	if (((L6208_IsSysFlag(running))&&(L6208_IsSysFlag(positionmode)))\|\|\
nucleosam	1:5cc2691ccfff	1306	(newAccOrDecRate < L6208_MIN_ACC_DEC_RATE))
nucleosam	1:5cc2691ccfff	1307	{
nucleosam	1:5cc2691ccfff	1308	return 0;
nucleosam	1:5cc2691ccfff	1309	}
nucleosam	1:5cc2691ccfff	1310	/* Compute (tick frequency)^2 */
nucleosam	1:5cc2691ccfff	1311	tmp32 = (uint32_t)L6208_Board_TickGetFreq();
nucleosam	1:5cc2691ccfff	1312	tmp32 *= tmp32;
nucleosam	1:5cc2691ccfff	1313	/* Return 0 if the (tick frequency)^2 is too small */
nucleosam	1:5cc2691ccfff	1314	if ( tmp32 < (uint32_t)newAccOrDecRate )
nucleosam	1:5cc2691ccfff	1315	{
nucleosam	1:5cc2691ccfff	1316	return 0;
nucleosam	1:5cc2691ccfff	1317	}
nucleosam	1:5cc2691ccfff	1318	/* Compute the decimal number of microstep or step per tick^2 */
nucleosam	1:5cc2691ccfff	1319	/* Decimal part is on 32 bits */
nucleosam	1:5cc2691ccfff	1320	tmp64 = (uint64_t)newAccOrDecRate << 32;
nucleosam	1:5cc2691ccfff	1321	tmp64 /= ((uint64_t)tmp32);
nucleosam	1:5cc2691ccfff	1322
nucleosam	1:5cc2691ccfff	1323	return (uint16_t)((tmp64 & 0x00000000FFFFFFFF)>>8);
nucleosam	1:5cc2691ccfff	1324	}
nucleosam	1:5cc2691ccfff	1325
nucleosam	1:5cc2691ccfff	1326	/****************************************************//
nucleosam	1:5cc2691ccfff	1327	* @brief Compute next position and speed according to the acceleration rate
nucleosam	1:5cc2691ccfff	1328	* @retval None
nucleosam	1:5cc2691ccfff	1329	**********************************************************/
nucleosam	1:5cc2691ccfff	1330	void L6208::L6208_DoAccel(void)
nucleosam	1:5cc2691ccfff	1331	{
nucleosam	1:5cc2691ccfff	1332	/* Increase speed by acceleration rate */
nucleosam	1:5cc2691ccfff	1333	uint32_t locAccelerationSpt2 = (uint32_t)devicePrm.accelerationSpt2;
nucleosam	1:5cc2691ccfff	1334	uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
nucleosam	1:5cc2691ccfff	1335	if ((devicePrm.speedSpt + locAccelerationSpt2) < locMinSpeedSpt)
nucleosam	1:5cc2691ccfff	1336	{
nucleosam	1:5cc2691ccfff	1337	devicePrm.speedSpt = locMinSpeedSpt;
nucleosam	1:5cc2691ccfff	1338	}
nucleosam	1:5cc2691ccfff	1339	else
nucleosam	1:5cc2691ccfff	1340	{
nucleosam	1:5cc2691ccfff	1341	devicePrm.speedSpt += locAccelerationSpt2;
nucleosam	1:5cc2691ccfff	1342	}
nucleosam	1:5cc2691ccfff	1343	/* Compute next position */
nucleosam	1:5cc2691ccfff	1344	L6208_DoRun();
nucleosam	1:5cc2691ccfff	1345	}
nucleosam	1:5cc2691ccfff	1346
nucleosam	1:5cc2691ccfff	1347	/****************************************************//
nucleosam	1:5cc2691ccfff	1348	* @brief Compute next position and speed according to the deceleration rate
nucleosam	1:5cc2691ccfff	1349	* @retval None
nucleosam	1:5cc2691ccfff	1350	**********************************************************/
nucleosam	1:5cc2691ccfff	1351	void L6208::L6208_DoDecel(void)
nucleosam	1:5cc2691ccfff	1352	{
nucleosam	1:5cc2691ccfff	1353	/* Decrease current speed by deceleration rate */
nucleosam	1:5cc2691ccfff	1354	uint32_t locDecelerationSpt2 = (uint32_t)devicePrm.decelerationSpt2;
nucleosam	1:5cc2691ccfff	1355	uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
nucleosam	1:5cc2691ccfff	1356	if((devicePrm.speedSpt - locMinSpeedSpt) > (uint32_t)locDecelerationSpt2)
nucleosam	1:5cc2691ccfff	1357	{
nucleosam	1:5cc2691ccfff	1358	devicePrm.speedSpt -= (uint32_t)locDecelerationSpt2;
nucleosam	1:5cc2691ccfff	1359	}
nucleosam	1:5cc2691ccfff	1360	else
nucleosam	1:5cc2691ccfff	1361	{
nucleosam	1:5cc2691ccfff	1362	/* Set minimum speed */
nucleosam	1:5cc2691ccfff	1363	devicePrm.speedSpt = locMinSpeedSpt;
nucleosam	1:5cc2691ccfff	1364	}
nucleosam	1:5cc2691ccfff	1365	/* Compute next position */
nucleosam	1:5cc2691ccfff	1366	L6208_DoRun();
nucleosam	1:5cc2691ccfff	1367	}
nucleosam	1:5cc2691ccfff	1368
nucleosam	1:5cc2691ccfff	1369	/****************************************************//
nucleosam	1:5cc2691ccfff	1370	* @brief Compute next position by adding current speed
nucleosam	1:5cc2691ccfff	1371	* @retval None
nucleosam	1:5cc2691ccfff	1372	**********************************************************/
nucleosam	1:5cc2691ccfff	1373	void L6208::L6208_DoRun(void)
nucleosam	1:5cc2691ccfff	1374	{
nucleosam	1:5cc2691ccfff	1375	devicePrm.ticks += (devicePrm.speedSpt >> 8) & 0x0000FFFF;
nucleosam	1:5cc2691ccfff	1376	}
nucleosam	1:5cc2691ccfff	1377
nucleosam	1:5cc2691ccfff	1378	/****************************************************//
nucleosam	1:5cc2691ccfff	1379	* @brief Get number of samples to rescale
nucleosam	1:5cc2691ccfff	1380	* @retval uStepsample2scale the number of micro stepping waveform samples to rescale
nucleosam	1:5cc2691ccfff	1381	**********************************************************/
nucleosam	1:5cc2691ccfff	1382	uint8_t L6208::L6208_GetMicrostepSample2Scale(void)
nucleosam	1:5cc2691ccfff	1383	{
nucleosam	1:5cc2691ccfff	1384	return devicePrm.uStepsample2scale;
nucleosam	1:5cc2691ccfff	1385	}
nucleosam	1:5cc2691ccfff	1386
nucleosam	1:5cc2691ccfff	1387	/****************************************************//
nucleosam	1:5cc2691ccfff	1388	* @brief Initialize the system for position mode motor moving command
nucleosam	1:5cc2691ccfff	1389	* P = total move distance in steps
nucleosam	1:5cc2691ccfff	1390	* P1 = steps required to accel from 0 to V
nucleosam	1:5cc2691ccfff	1391	* P2 = steps required to decel from V to 0
nucleosam	1:5cc2691ccfff	1392	* V = peak velocity in steps per second (steps/sec)
nucleosam	1:5cc2691ccfff	1393	* V1 = average velocity during accel or decel*
nucleosam	1:5cc2691ccfff	1394	* A = required accel rate in steps per second per second (steps/sec2)
nucleosam	1:5cc2691ccfff	1395	* D = required decel rate in steps per second per second (steps/sec2)
nucleosam	1:5cc2691ccfff	1396	* T1 = acceleration time in seconds
nucleosam	1:5cc2691ccfff	1397	* T2 = deceleration time in seconds*
nucleosam	1:5cc2691ccfff	1398	*
nucleosam	1:5cc2691ccfff	1399	* 1) T1 = V / A
nucleosam	1:5cc2691ccfff	1400	* 2) V1 = V / 2
nucleosam	1:5cc2691ccfff	1401	* 3) P1 = V1 T1
nucleosam	1:5cc2691ccfff	1402	* Substituting 1 and 2 into 3 yields:
nucleosam	1:5cc2691ccfff	1403	* 4) P1 = V2 / 2A
nucleosam	1:5cc2691ccfff	1404	* In the same manner we have:
nucleosam	1:5cc2691ccfff	1405	* 5) P2 = V2 / 2D
nucleosam	1:5cc2691ccfff	1406	*
nucleosam	1:5cc2691ccfff	1407	* P1 = PD/(D+A)
nucleosam	1:5cc2691ccfff	1408	*
nucleosam	1:5cc2691ccfff	1409	* \sa Application Note: AN2044
nucleosam	1:5cc2691ccfff	1410	* @retval None
nucleosam	1:5cc2691ccfff	1411	**********************************************************/
nucleosam	1:5cc2691ccfff	1412	void L6208::L6208_Indexmodeinit(void)
nucleosam	1:5cc2691ccfff	1413	{
nucleosam	1:5cc2691ccfff	1414	uint32_t tmpVal0;
nucleosam	1:5cc2691ccfff	1415	uint32_t tmpVal1;
nucleosam	1:5cc2691ccfff	1416	uint32_t locAccelSteps;
nucleosam	1:5cc2691ccfff	1417	uint32_t locDecSteps;
nucleosam	1:5cc2691ccfff	1418
nucleosam	1:5cc2691ccfff	1419	/* calculate the number of steps to get the running speed */
nucleosam	1:5cc2691ccfff	1420	locAccelSteps = L6208_ComputeNbAccOrDecSteps(devicePrm.accelerationSps2);
nucleosam	1:5cc2691ccfff	1421	/* calculate the number of steps to get the motor stopped */
nucleosam	1:5cc2691ccfff	1422	locDecSteps = L6208_ComputeNbAccOrDecSteps(devicePrm.decelerationSps2);
nucleosam	1:5cc2691ccfff	1423	if(( locAccelSteps + locDecSteps ) > devicePrm.positionTarget)
nucleosam	1:5cc2691ccfff	1424	{
nucleosam	1:5cc2691ccfff	1425	/* Triangular move needed */
nucleosam	1:5cc2691ccfff	1426	/* accelsteps = P1 = PD/(D+A) */
nucleosam	1:5cc2691ccfff	1427	tmpVal0 = devicePrm.positionTarget * devicePrm.decelerationSps2;
nucleosam	1:5cc2691ccfff	1428	tmpVal1 = (uint32_t)devicePrm.decelerationSps2;
nucleosam	1:5cc2691ccfff	1429	tmpVal1 += (uint32_t)devicePrm.accelerationSps2;
nucleosam	1:5cc2691ccfff	1430	locAccelSteps = tmpVal0 / tmpVal1;
nucleosam	1:5cc2691ccfff	1431	devicePrm.positionTarget1 = locAccelSteps;
nucleosam	1:5cc2691ccfff	1432	devicePrm.positionTarget2 = devicePrm.positionTarget1 + 1;
nucleosam	1:5cc2691ccfff	1433	devicePrm.positionTarget3 = devicePrm.positionTarget;
nucleosam	1:5cc2691ccfff	1434	if(devicePrm.positionTarget1 == 0)
nucleosam	1:5cc2691ccfff	1435	{
nucleosam	1:5cc2691ccfff	1436	devicePrm.positionTarget1 = 1;
nucleosam	1:5cc2691ccfff	1437	}
nucleosam	1:5cc2691ccfff	1438	}
nucleosam	1:5cc2691ccfff	1439	else
nucleosam	1:5cc2691ccfff	1440	{
nucleosam	1:5cc2691ccfff	1441	/* trapezoidal move needed */
nucleosam	1:5cc2691ccfff	1442	/* P1 = V^2/2A */
nucleosam	1:5cc2691ccfff	1443	/* P2 = P - V^2/2D */
nucleosam	1:5cc2691ccfff	1444	devicePrm.positionTarget1 = locAccelSteps;
nucleosam	1:5cc2691ccfff	1445	devicePrm.positionTarget2 = devicePrm.positionTarget - locDecSteps;
nucleosam	1:5cc2691ccfff	1446	devicePrm.positionTarget3 = devicePrm.positionTarget;
nucleosam	1:5cc2691ccfff	1447	}
nucleosam	1:5cc2691ccfff	1448	L6208_SetMotionState(INDEX_ACCEL);
nucleosam	1:5cc2691ccfff	1449	}
nucleosam	1:5cc2691ccfff	1450
nucleosam	1:5cc2691ccfff	1451	/****************************************************//
nucleosam	1:5cc2691ccfff	1452	* @brief Check the bit/s of flags according to the specified mask
nucleosam	1:5cc2691ccfff	1453	* @param[in] mask flag bit mask
nucleosam	1:5cc2691ccfff	1454	* @retval TRUE if the bit of the mask are set
nucleosam	1:5cc2691ccfff	1455	**********************************************************/
nucleosam	1:5cc2691ccfff	1456	inline bool L6208::L6208_IsSysFlag(uint32_t mask)
nucleosam	1:5cc2691ccfff	1457	{
nucleosam	1:5cc2691ccfff	1458	return (bool)((devicePrm.flags & mask) == mask);
nucleosam	1:5cc2691ccfff	1459	}
nucleosam	1:5cc2691ccfff	1460
nucleosam	1:5cc2691ccfff	1461	/****************************************************//
nucleosam	1:5cc2691ccfff	1462	* @brief Stepper driver device step state reset subroutine
nucleosam	1:5cc2691ccfff	1463	* @retval None
nucleosam	1:5cc2691ccfff	1464	**********************************************************/
nucleosam	1:5cc2691ccfff	1465	void L6208::L6208_ResetSteps(void)
nucleosam	1:5cc2691ccfff	1466	{
nucleosam	1:5cc2691ccfff	1467	devicePrm.speedSpt = 0; // reset the current speed value
nucleosam	1:5cc2691ccfff	1468	devicePrm.ticks = 0; // reset the current ticks counter value
nucleosam	1:5cc2691ccfff	1469	devicePrm.step = 0; // reset the current step counter value
nucleosam	1:5cc2691ccfff	1470	devicePrm.lsbOldTicks = 0; // reset copy of the previous position (tick)
nucleosam	1:5cc2691ccfff	1471	devicePrm.lsbOldUSteppingTicks = 0; // reset copy of the previous position (tick) ( micro stepping )
nucleosam	1:5cc2691ccfff	1472	devicePrm.lsbTicks = 0; // reset copy of the current position (tick)
nucleosam	1:5cc2691ccfff	1473	devicePrm.absolutePos = 0; // reset the absolute motor position in step/microsteps
nucleosam	1:5cc2691ccfff	1474	devicePrm.uStepSample = 0; // reset the microstepping waveform sample index
nucleosam	1:5cc2691ccfff	1475	}
nucleosam	1:5cc2691ccfff	1476
nucleosam	1:5cc2691ccfff	1477	/****************************************************//
nucleosam	1:5cc2691ccfff	1478	* @brief Compute the specified micro stepping waveform sample with the
nucleosam	1:5cc2691ccfff	1479	* current selected torque and pwm period
nucleosam	1:5cc2691ccfff	1480	* @param[in] sampleIndex sample Index
nucleosam	1:5cc2691ccfff	1481	* @retval scaled sample value
nucleosam	1:5cc2691ccfff	1482	**********************************************************/
nucleosam	1:5cc2691ccfff	1483	uint32_t L6208::L6208_ScaleWaveformSample(uint8_t sampleIndex)
nucleosam	1:5cc2691ccfff	1484	{
nucleosam	1:5cc2691ccfff	1485	uint32_t sample;
nucleosam	1:5cc2691ccfff	1486
nucleosam	1:5cc2691ccfff	1487	sample = (uint32_t)RefMicroTable[sampleIndex];
nucleosam	1:5cc2691ccfff	1488	sample *= devicePrm.vrefPwmPeriod;
nucleosam	1:5cc2691ccfff	1489	sample >>= (uint32_t)L6208_SINE_WAVEFORM_POWER_OF_TWO_MAX_VALUE;
nucleosam	1:5cc2691ccfff	1490
nucleosam	1:5cc2691ccfff	1491	sample *= (uint32_t)devicePrm.curTorqueScaler; // torque val (%)
nucleosam	1:5cc2691ccfff	1492	sample /= (uint32_t)100;
nucleosam	1:5cc2691ccfff	1493
nucleosam	1:5cc2691ccfff	1494	return sample;
nucleosam	1:5cc2691ccfff	1495	}
nucleosam	1:5cc2691ccfff	1496
nucleosam	1:5cc2691ccfff	1497	/****************************************************//
nucleosam	1:5cc2691ccfff	1498	* @brief Compute the micro stepping waveform sample table samples with the
nucleosam	1:5cc2691ccfff	1499	* current selected torque and pwm period
nucleosam	1:5cc2691ccfff	1500	* @retval None
nucleosam	1:5cc2691ccfff	1501	**********************************************************/
nucleosam	1:5cc2691ccfff	1502	void L6208::L6208_ScaleWaveformTable(void)
nucleosam	1:5cc2691ccfff	1503	{
nucleosam	1:5cc2691ccfff	1504	uint8_t index;
nucleosam	1:5cc2691ccfff	1505	for(index=0; index<=L6208_USTEPS_PER_QUARTER_PERIOD; index++)
nucleosam	1:5cc2691ccfff	1506	{
nucleosam	1:5cc2691ccfff	1507	/* Calculate the scaled sample and save its value into the waveform to update table */
nucleosam	1:5cc2691ccfff	1508	updatedMicroTable[index] = (uint16_t)L6208_ScaleWaveformSample(index);
nucleosam	1:5cc2691ccfff	1509	}
nucleosam	1:5cc2691ccfff	1510	}
nucleosam	1:5cc2691ccfff	1511
nucleosam	1:5cc2691ccfff	1512	/****************************************************//
nucleosam	1:5cc2691ccfff	1513	* @brief Set the parameters of the device to values of the structure pointed
nucleosam	1:5cc2691ccfff	1514	* by pInitDevicePrm. Set GPIO according to these values.
nucleosam	1:5cc2691ccfff	1515	* @param pInitDevicePrm pointer onto the structure containing values to
nucleosam	1:5cc2691ccfff	1516	* initialize the device parameters.
nucleosam	1:5cc2691ccfff	1517	* @retval None
nucleosam	1:5cc2691ccfff	1518	**********************************************************/
nucleosam	1:5cc2691ccfff	1519	void L6208::L6208_SetDeviceParamsToGivenValues(l6208_Init_t* pInitDevicePrm)
nucleosam	1:5cc2691ccfff	1520	{
nucleosam	1:5cc2691ccfff	1521	memset(&devicePrm, 0, sizeof(devicePrm));
nucleosam	1:5cc2691ccfff	1522	L6208_SetAcceleration(pInitDevicePrm->accelerationSps2);
nucleosam	1:5cc2691ccfff	1523	L6208_SetDeceleration(pInitDevicePrm->decelerationSps2);
nucleosam	1:5cc2691ccfff	1524	L6208_SetMaxSpeed(pInitDevicePrm->maxSpeedSps);
nucleosam	1:5cc2691ccfff	1525	L6208_SetMinSpeed(L6208_MIN_SPEED);
nucleosam	1:5cc2691ccfff	1526	devicePrm.accelTorque = pInitDevicePrm->accelTorque;
nucleosam	1:5cc2691ccfff	1527	devicePrm.decelTorque = pInitDevicePrm->decelTorque;
nucleosam	1:5cc2691ccfff	1528	devicePrm.runTorque = pInitDevicePrm->runTorque;
nucleosam	1:5cc2691ccfff	1529	devicePrm.holdTorque = pInitDevicePrm->holdTorque;
nucleosam	1:5cc2691ccfff	1530	/* Only once acceleration, deceleration, min speed and max speed have been */
nucleosam	1:5cc2691ccfff	1531	/* initialized, set the step mode */
nucleosam	1:5cc2691ccfff	1532	devicePrm.stepMode = pInitDevicePrm->stepMode;
nucleosam	1:5cc2691ccfff	1533	L6208_SetDecayMode(pInitDevicePrm->decayMode);
nucleosam	1:5cc2691ccfff	1534	devicePrm.moveDwellTime = pInitDevicePrm->moveDwellTime;
nucleosam	1:5cc2691ccfff	1535	if (L6208_CONF_PARAM_AUTO_HIZ_STOP) L6208_SetSysFlag(pInitDevicePrm->autoHiZstop);
nucleosam	1:5cc2691ccfff	1536	devicePrm.vrefPwmFreq = pInitDevicePrm->vrefPwmFreq;
nucleosam	1:5cc2691ccfff	1537	devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/pInitDevicePrm->vrefPwmFreq);
nucleosam	1:5cc2691ccfff	1538	/* Initialize current stepper state machine index */
nucleosam	1:5cc2691ccfff	1539	L6208_SetMotionState(INACTIVE);
nucleosam	1:5cc2691ccfff	1540	}
nucleosam	1:5cc2691ccfff	1541
nucleosam	1:5cc2691ccfff	1542	/****************************************************//
nucleosam	1:5cc2691ccfff	1543	* @brief Set the parameters of the device to predefined values
nucleosam	1:5cc2691ccfff	1544	* Set GPIO according to these values
nucleosam	1:5cc2691ccfff	1545	* from l6208_target_config.h
nucleosam	1:5cc2691ccfff	1546	* @retval None
nucleosam	1:5cc2691ccfff	1547	**********************************************************/
nucleosam	1:5cc2691ccfff	1548	void L6208::L6208_SetDeviceParamsToPredefinedValues(void)
nucleosam	1:5cc2691ccfff	1549	{
nucleosam	1:5cc2691ccfff	1550	memset(&devicePrm, 0, sizeof(devicePrm));
nucleosam	1:5cc2691ccfff	1551	L6208_SetAcceleration(L6208_CONF_PARAM_ACC_RATE);
nucleosam	1:5cc2691ccfff	1552	L6208_SetDeceleration(L6208_CONF_PARAM_DEC_RATE);
nucleosam	1:5cc2691ccfff	1553	L6208_SetMaxSpeed(L6208_CONF_PARAM_RUNNING_SPEED);
nucleosam	1:5cc2691ccfff	1554	L6208_SetMinSpeed(L6208_MIN_SPEED);
nucleosam	1:5cc2691ccfff	1555	devicePrm.accelTorque = L6208_CONF_PARAM_ACC_CURRENT;
nucleosam	1:5cc2691ccfff	1556	devicePrm.decelTorque = L6208_CONF_PARAM_DEC_CURRENT;
nucleosam	1:5cc2691ccfff	1557	devicePrm.runTorque = L6208_CONF_PARAM_RUNNING_CURRENT;
nucleosam	1:5cc2691ccfff	1558	devicePrm.holdTorque = L6208_CONF_PARAM_HOLDING_CURRENT;
nucleosam	1:5cc2691ccfff	1559	/* Only once acceleration, deceleration, min speed and max speed have been */
nucleosam	1:5cc2691ccfff	1560	/* initialized, set the step mode */
nucleosam	1:5cc2691ccfff	1561	devicePrm.stepMode = (motorStepMode_t) L6208_CONF_PARAM_STEP_MODE;
nucleosam	1:5cc2691ccfff	1562	L6208_SetDecayMode(L6208_CONF_PARAM_DECAY_MODE);
nucleosam	1:5cc2691ccfff	1563	devicePrm.moveDwellTime = L6208_CONF_PARAM_DWELL_TIME;
nucleosam	1:5cc2691ccfff	1564	if (L6208_CONF_PARAM_AUTO_HIZ_STOP) L6208_SetSysFlag(HiZstop);
nucleosam	1:5cc2691ccfff	1565	devicePrm.vrefPwmFreq = L6208_CONF_VREF_PWM_FREQUENCY;
nucleosam	1:5cc2691ccfff	1566	devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/L6208_CONF_VREF_PWM_FREQUENCY);
nucleosam	1:5cc2691ccfff	1567	/* Initialize current stepper state machine index */
nucleosam	1:5cc2691ccfff	1568	L6208_SetMotionState(INACTIVE);
nucleosam	1:5cc2691ccfff	1569	}
nucleosam	1:5cc2691ccfff	1570
nucleosam	1:5cc2691ccfff	1571	/****************************************************//
nucleosam	1:5cc2691ccfff	1572	* @brief Set the number of micro stepping waveform samples to rescale
nucleosam	1:5cc2691ccfff	1573	* @param[in] value number of micro stepping waveform samples
nucleosam	1:5cc2691ccfff	1574	* @retval None
nucleosam	1:5cc2691ccfff	1575	**********************************************************/
nucleosam	1:5cc2691ccfff	1576	void L6208::L6208_SetMicrostepSample2Scale(uint8_t value)
nucleosam	1:5cc2691ccfff	1577	{
nucleosam	1:5cc2691ccfff	1578	if(value > L6208_USTEPS_PER_QUARTER_PERIOD)
nucleosam	1:5cc2691ccfff	1579	{
nucleosam	1:5cc2691ccfff	1580	value = L6208_USTEPS_PER_QUARTER_PERIOD; // clamp to maximum number of samples per period/4
nucleosam	1:5cc2691ccfff	1581	}
nucleosam	1:5cc2691ccfff	1582	devicePrm.uStepsample2scale = value;
nucleosam	1:5cc2691ccfff	1583	}
nucleosam	1:5cc2691ccfff	1584
nucleosam	1:5cc2691ccfff	1585	/****************************************************//
nucleosam	1:5cc2691ccfff	1586	* @brief Set the number of micro stepping waveform samples to update into scanning
nucleosam	1:5cc2691ccfff	1587	* @param[in] value number of micro stepping waveform samples
nucleosam	1:5cc2691ccfff	1588	* @retval None
nucleosam	1:5cc2691ccfff	1589	**********************************************************/
nucleosam	1:5cc2691ccfff	1590	void L6208::L6208_SetMicrostepSample2Update(uint8_t value)
nucleosam	1:5cc2691ccfff	1591	{
nucleosam	1:5cc2691ccfff	1592	// clamp to maximum number of samples per period/4
nucleosam	1:5cc2691ccfff	1593	if(value > L6208_USTEPS_PER_QUARTER_PERIOD)
nucleosam	1:5cc2691ccfff	1594	{
nucleosam	1:5cc2691ccfff	1595	value = L6208_USTEPS_PER_QUARTER_PERIOD;
nucleosam	1:5cc2691ccfff	1596	}
nucleosam	1:5cc2691ccfff	1597	// copy the stepper acceleration rate
nucleosam	1:5cc2691ccfff	1598	devicePrm.uStepsample2update = value;
nucleosam	1:5cc2691ccfff	1599	}
nucleosam	1:5cc2691ccfff	1600
nucleosam	1:5cc2691ccfff	1601	/****************************************************//
nucleosam	1:5cc2691ccfff	1602	* @brief Set the stepper state machine index
nucleosam	1:5cc2691ccfff	1603	* @param[in] newMotionState
nucleosam	1:5cc2691ccfff	1604	* @retval None
nucleosam	1:5cc2691ccfff	1605	**********************************************************/
nucleosam	1:5cc2691ccfff	1606	void L6208::L6208_SetMotionState(motorState_t newMotionState)
nucleosam	1:5cc2691ccfff	1607	{
nucleosam	1:5cc2691ccfff	1608	// sets the new stepper state machine index
nucleosam	1:5cc2691ccfff	1609	devicePrm.motionState = newMotionState;
nucleosam	1:5cc2691ccfff	1610	}
nucleosam	1:5cc2691ccfff	1611
nucleosam	1:5cc2691ccfff	1612	/****************************************************//
nucleosam	1:5cc2691ccfff	1613	* @brief Set the user selected speed in step/tick
nucleosam	1:5cc2691ccfff	1614	* @param[in] newSpeed speed value (step/s)
nucleosam	1:5cc2691ccfff	1615	* @param[in] pSpeed pointer to the selected speed field
nucleosam	1:5cc2691ccfff	1616	* @retval return FALSE if the speed is too low or too high
nucleosam	1:5cc2691ccfff	1617	* or if the device is running in position mode, else TRUE
nucleosam	1:5cc2691ccfff	1618	**********************************************************/
nucleosam	1:5cc2691ccfff	1619	bool L6208::L6208_SetSpeed(uint16_t newSpeed, uint32_t volatile *pSpeed)
nucleosam	1:5cc2691ccfff	1620	{
nucleosam	1:5cc2691ccfff	1621	uint64_t tmp64;
nucleosam	1:5cc2691ccfff	1622	uint32_t tmp32;
nucleosam	1:5cc2691ccfff	1623
nucleosam	1:5cc2691ccfff	1624	if (((L6208_IsSysFlag(running))&&(L6208_IsSysFlag(positionmode)))\|\|\
nucleosam	1:5cc2691ccfff	1625	(newSpeed < L6208_MIN_SPEED))
nucleosam	1:5cc2691ccfff	1626	{
nucleosam	1:5cc2691ccfff	1627	return FALSE;
nucleosam	1:5cc2691ccfff	1628	}
nucleosam	1:5cc2691ccfff	1629	tmp32 = (uint32_t)L6208_Board_TickGetFreq();
nucleosam	1:5cc2691ccfff	1630	if (tmp32 < newSpeed)
nucleosam	1:5cc2691ccfff	1631	{
nucleosam	1:5cc2691ccfff	1632	return FALSE;
nucleosam	1:5cc2691ccfff	1633	}
nucleosam	1:5cc2691ccfff	1634	/* Compute the decimal number of microstep or step per tick */
nucleosam	1:5cc2691ccfff	1635	/* Decimal part is on 32 bits */
nucleosam	1:5cc2691ccfff	1636	tmp64 = (uint64_t)newSpeed << 32;
nucleosam	1:5cc2691ccfff	1637	tmp64 /= ((uint64_t)tmp32);
nucleosam	1:5cc2691ccfff	1638	/* set the running constant speed value (step/tick) */
nucleosam	1:5cc2691ccfff	1639	*pSpeed = (uint32_t)((tmp64 & 0x00000000FFFFFFFF)>>8);
nucleosam	1:5cc2691ccfff	1640
nucleosam	1:5cc2691ccfff	1641	return TRUE;
nucleosam	1:5cc2691ccfff	1642	}
nucleosam	1:5cc2691ccfff	1643
nucleosam	1:5cc2691ccfff	1644	/****************************************************//
nucleosam	1:5cc2691ccfff	1645	* @brief Set the bit/s of flags according to the specified mask
nucleosam	1:5cc2691ccfff	1646	* @param[in] mask flag bit mask
nucleosam	1:5cc2691ccfff	1647	* @retval None
nucleosam	1:5cc2691ccfff	1648	**********************************************************/
nucleosam	1:5cc2691ccfff	1649	inline void L6208::L6208_SetSysFlag(uint32_t mask)
nucleosam	1:5cc2691ccfff	1650	{
nucleosam	1:5cc2691ccfff	1651	devicePrm.flags \|= mask;
nucleosam	1:5cc2691ccfff	1652	}
nucleosam	1:5cc2691ccfff	1653
nucleosam	1:5cc2691ccfff	1654	/****************************************************//
nucleosam	1:5cc2691ccfff	1655	* @brief Stepper motor start command
nucleosam	1:5cc2691ccfff	1656	* @retval true on correct command execution
nucleosam	1:5cc2691ccfff	1657	**********************************************************/
nucleosam	1:5cc2691ccfff	1658	bool L6208::L6208_StartMovement(void)
nucleosam	1:5cc2691ccfff	1659	{
nucleosam	1:5cc2691ccfff	1660	uint32_t tmp;
nucleosam	1:5cc2691ccfff	1661	if (L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	1662	{
nucleosam	1:5cc2691ccfff	1663	/* Motor is already running ==> quit */
nucleosam	1:5cc2691ccfff	1664	return FALSE;
nucleosam	1:5cc2691ccfff	1665	}
nucleosam	1:5cc2691ccfff	1666	if (!L6208_IsSysFlag(positionmode))
nucleosam	1:5cc2691ccfff	1667	{
nucleosam	1:5cc2691ccfff	1668	/* Set the VREFA and VREFB to the selected acc. torque */
nucleosam	1:5cc2691ccfff	1669	L6208_VectorCalc(devicePrm.accelTorque);
nucleosam	1:5cc2691ccfff	1670
nucleosam	1:5cc2691ccfff	1671	/* If the speed control mode is selected */
nucleosam	1:5cc2691ccfff	1672	/* setup the motor acceleration for velocity mode driving */
nucleosam	1:5cc2691ccfff	1673	L6208_SetMotionState(ACCELERATING);
nucleosam	1:5cc2691ccfff	1674	}
nucleosam	1:5cc2691ccfff	1675	else
nucleosam	1:5cc2691ccfff	1676	{
nucleosam	1:5cc2691ccfff	1677	/* if position control mode is selected, reset the current step counter */
nucleosam	1:5cc2691ccfff	1678	devicePrm.step = 0;
nucleosam	1:5cc2691ccfff	1679	if(devicePrm.uStepSample > 31)
nucleosam	1:5cc2691ccfff	1680	{
nucleosam	1:5cc2691ccfff	1681	/* check the micro stepping waveform sample index */
nucleosam	1:5cc2691ccfff	1682	devicePrm.uStepSample = 0;
nucleosam	1:5cc2691ccfff	1683	}
nucleosam	1:5cc2691ccfff	1684	/* Set the position dwelling wait time */
nucleosam	1:5cc2691ccfff	1685	/* compute number of ticks per millisecond */
nucleosam	1:5cc2691ccfff	1686	tmp = (uint32_t)L6208_Board_TickGetFreq() / 1000;
nucleosam	1:5cc2691ccfff	1687	/* Compute the dwelling time in ticks => dwellCounter (ticks) */
nucleosam	1:5cc2691ccfff	1688	devicePrm.dwellCounter = tmp * (uint32_t)devicePrm.moveDwellTime;
nucleosam	1:5cc2691ccfff	1689	if (devicePrm.positionTarget == 0)
nucleosam	1:5cc2691ccfff	1690	{
nucleosam	1:5cc2691ccfff	1691	/* if the position to go is 0 (no move) */
nucleosam	1:5cc2691ccfff	1692	/* Set the deceleration torque */
nucleosam	1:5cc2691ccfff	1693	L6208_VectorCalc(devicePrm.decelTorque);
nucleosam	1:5cc2691ccfff	1694	/* Set the dwelling delay state index */
nucleosam	1:5cc2691ccfff	1695	L6208_SetMotionState(INDEX_DWELL);
nucleosam	1:5cc2691ccfff	1696	}
nucleosam	1:5cc2691ccfff	1697	else
nucleosam	1:5cc2691ccfff	1698	{
nucleosam	1:5cc2691ccfff	1699	/* Set the VREFA and VREFB to the selected acc. torque */
nucleosam	1:5cc2691ccfff	1700	L6208_VectorCalc(devicePrm.accelTorque);
nucleosam	1:5cc2691ccfff	1701	/* go to the selected position */
nucleosam	1:5cc2691ccfff	1702	L6208_Indexmodeinit();
nucleosam	1:5cc2691ccfff	1703	L6208_SetMotionState(INDEX_ACCEL);
nucleosam	1:5cc2691ccfff	1704	}
nucleosam	1:5cc2691ccfff	1705	}
nucleosam	1:5cc2691ccfff	1706	/* Sets the motor running flag */
nucleosam	1:5cc2691ccfff	1707	L6208_SetSysFlag(running);
nucleosam	1:5cc2691ccfff	1708	/* Start the VREFA and VREFB PWMs */
nucleosam	1:5cc2691ccfff	1709	L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1710	L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
nucleosam	1:5cc2691ccfff	1711	if (!(L6208_IsSysFlag(EN_A_set)))
nucleosam	1:5cc2691ccfff	1712	{
nucleosam	1:5cc2691ccfff	1713	/* Enable power bridges */
nucleosam	1:5cc2691ccfff	1714	L6208_Enable();
nucleosam	1:5cc2691ccfff	1715	}
nucleosam	1:5cc2691ccfff	1716	/* Start the tick */
nucleosam	1:5cc2691ccfff	1717	L6208_Board_TickStart(L6208::tickFreq);
nucleosam	1:5cc2691ccfff	1718
nucleosam	1:5cc2691ccfff	1719	return TRUE;
nucleosam	1:5cc2691ccfff	1720	}
nucleosam	1:5cc2691ccfff	1721
nucleosam	1:5cc2691ccfff	1722	/****************************************************//
nucleosam	1:5cc2691ccfff	1723	* @brief Update the micro stepping waveform samples table with the
nucleosam	1:5cc2691ccfff	1724	* values previously scaled with current selected torque and tick period
nucleosam	1:5cc2691ccfff	1725	* @retval None
nucleosam	1:5cc2691ccfff	1726	**********************************************************/
nucleosam	1:5cc2691ccfff	1727	void L6208::L6208_UpdateScanWaveformTable(void)
nucleosam	1:5cc2691ccfff	1728	{
nucleosam	1:5cc2691ccfff	1729	uint8_t index;
nucleosam	1:5cc2691ccfff	1730
nucleosam	1:5cc2691ccfff	1731	for(index=0; index<=L6208_USTEPS_PER_QUARTER_PERIOD; index++)
nucleosam	1:5cc2691ccfff	1732	{
nucleosam	1:5cc2691ccfff	1733	microTable1[index] = updatedMicroTable[index];
nucleosam	1:5cc2691ccfff	1734	microTable1[L6208_USTEPS_PER_QUARTER_PERIOD*2 - index] = microTable1[index];
nucleosam	1:5cc2691ccfff	1735	microTable1[index + L6208_USTEPS_PER_QUARTER_PERIOD*2] = updatedMicroTable[index];
nucleosam	1:5cc2691ccfff	1736	}
nucleosam	1:5cc2691ccfff	1737	/* clear the number of samples to update */
nucleosam	1:5cc2691ccfff	1738	L6208_SetMicrostepSample2Update(0);
nucleosam	1:5cc2691ccfff	1739	}
nucleosam	1:5cc2691ccfff	1740
nucleosam	1:5cc2691ccfff	1741	/****************************************************//
nucleosam	1:5cc2691ccfff	1742	* @brief Check if there are waveform samples to rescale and if so, perform the rescaling
nucleosam	1:5cc2691ccfff	1743	* @retval None
nucleosam	1:5cc2691ccfff	1744	**********************************************************/
nucleosam	1:5cc2691ccfff	1745	void L6208::L6208_UstepWaveformHandling(void)
nucleosam	1:5cc2691ccfff	1746	{
nucleosam	1:5cc2691ccfff	1747	/* micro stepper waveform samples rescaling ... and updating */
nucleosam	1:5cc2691ccfff	1748	uint8_t nbSamplesToRescale = L6208_GetMicrostepSample2Scale();
nucleosam	1:5cc2691ccfff	1749	if(nbSamplesToRescale > 0)
nucleosam	1:5cc2691ccfff	1750	{
nucleosam	1:5cc2691ccfff	1751	/* Current torque value has been changed, so recalculate the waveform table */
nucleosam	1:5cc2691ccfff	1752	L6208_ScaleWaveformTable();
nucleosam	1:5cc2691ccfff	1753
nucleosam	1:5cc2691ccfff	1754	/* Set the number of samples to update */
nucleosam	1:5cc2691ccfff	1755	L6208_SetMicrostepSample2Update(L6208_USTEPS_PER_QUARTER_PERIOD);
nucleosam	1:5cc2691ccfff	1756
nucleosam	1:5cc2691ccfff	1757	/* Reset the number of samples to rescaled afer rescaling */
nucleosam	1:5cc2691ccfff	1758	L6208_SetMicrostepSample2Scale(0);
nucleosam	1:5cc2691ccfff	1759	}
nucleosam	1:5cc2691ccfff	1760	}
nucleosam	1:5cc2691ccfff	1761
nucleosam	1:5cc2691ccfff	1762	/****************************************************//
nucleosam	1:5cc2691ccfff	1763	* @brief Set the current torque value (Vref)
nucleosam	1:5cc2691ccfff	1764	* @param[in] newTorque Selected torque value
nucleosam	1:5cc2691ccfff	1765	* @retval always TRUE
nucleosam	1:5cc2691ccfff	1766	**********************************************************/
nucleosam	1:5cc2691ccfff	1767	bool L6208::L6208_VectorCalc(uint8_t newTorque)
nucleosam	1:5cc2691ccfff	1768	{
nucleosam	1:5cc2691ccfff	1769	/* save current selected torque value */
nucleosam	1:5cc2691ccfff	1770	devicePrm.curTorqueScaler = (uint16_t)newTorque;
nucleosam	1:5cc2691ccfff	1771
nucleosam	1:5cc2691ccfff	1772	if(!L6208_IsSysFlag(microstep))
nucleosam	1:5cc2691ccfff	1773	{
nucleosam	1:5cc2691ccfff	1774	/* full/half step mode or the motor is not running */
nucleosam	1:5cc2691ccfff	1775	/* set the PWM duty cycle according to the current torque value (%). */
nucleosam	1:5cc2691ccfff	1776	/* The TON value will be calculated inside the TIMx_PWM_duty_setup f(). */
nucleosam	1:5cc2691ccfff	1777	L6208_VrefPwmComputePulseWidth(BRIDGE_A, devicePrm.curTorqueScaler, TRUE);
nucleosam	1:5cc2691ccfff	1778	L6208_VrefPwmComputePulseWidth(BRIDGE_B, devicePrm.curTorqueScaler, TRUE);
nucleosam	1:5cc2691ccfff	1779	devicePrm.vRefAVal = devicePrm.curTorqueScaler; // save current VREFA value
nucleosam	1:5cc2691ccfff	1780	devicePrm.vRefBVal = devicePrm.curTorqueScaler; // save current VREFB value
nucleosam	1:5cc2691ccfff	1781	}
nucleosam	1:5cc2691ccfff	1782	else
nucleosam	1:5cc2691ccfff	1783	{
nucleosam	1:5cc2691ccfff	1784	/* microstep mode */
nucleosam	1:5cc2691ccfff	1785	if(L6208_IsSysFlag(running))
nucleosam	1:5cc2691ccfff	1786	{
nucleosam	1:5cc2691ccfff	1787	/* set the number of waveform sample to rescale according current selected */
nucleosam	1:5cc2691ccfff	1788	/* torque value */
nucleosam	1:5cc2691ccfff	1789	L6208_SetMicrostepSample2Scale(L6208_USTEPS_PER_QUARTER_PERIOD);
nucleosam	1:5cc2691ccfff	1790	}
nucleosam	1:5cc2691ccfff	1791	else
nucleosam	1:5cc2691ccfff	1792	{
nucleosam	1:5cc2691ccfff	1793	/* micro stepping mode motor stopped */
nucleosam	1:5cc2691ccfff	1794	L6208_ScaleWaveformTable();
nucleosam	1:5cc2691ccfff	1795	L6208_UpdateScanWaveformTable();
nucleosam	1:5cc2691ccfff	1796	/* Set the VREF timer PWM TON to update VREFA and VREFB */
nucleosam	1:5cc2691ccfff	1797	L6208_VrefPwmComputePulseWidth(BRIDGE_A, pMicroTable2[devicePrm.uStepSample], FALSE);
nucleosam	1:5cc2691ccfff	1798	L6208_VrefPwmComputePulseWidth(BRIDGE_B, microTable1[devicePrm.uStepSample], FALSE);
nucleosam	1:5cc2691ccfff	1799	}
nucleosam	1:5cc2691ccfff	1800	}
nucleosam	1:5cc2691ccfff	1801	return TRUE;
nucleosam	1:5cc2691ccfff	1802	}
nucleosam	1:5cc2691ccfff	1803
nucleosam	1:5cc2691ccfff	1804	/****************************************************//
nucleosam	1:5cc2691ccfff	1805	* @brief Compute the pulse width of VREFA or VREFB PWM
nucleosam	1:5cc2691ccfff	1806	* @param[in] bridgeId
nucleosam	1:5cc2691ccfff	1807	* 0 for BRIDGE_A
nucleosam	1:5cc2691ccfff	1808	* 1 for BRIDGE_B
nucleosam	1:5cc2691ccfff	1809	* @param[in] value pulse length in 1/256th of microsecond
nucleosam	1:5cc2691ccfff	1810	* or PWM duty cycle: 0 - 100 %
nucleosam	1:5cc2691ccfff	1811	* @param[in] valueIsPwmDutyCycle must be TRUE if value is a PWM duty cycle
nucleosam	1:5cc2691ccfff	1812	* @retval FALSE if wrong timer handle is used, else TRUE
nucleosam	1:5cc2691ccfff	1813	**********************************************************/
nucleosam	1:5cc2691ccfff	1814	bool L6208::L6208_VrefPwmComputePulseWidth(uint8_t bridgeId, uint16_t value, bool valueIsPwmDutyCycle)
nucleosam	1:5cc2691ccfff	1815	{
nucleosam	1:5cc2691ccfff	1816	if(valueIsPwmDutyCycle)
nucleosam	1:5cc2691ccfff	1817	{
nucleosam	1:5cc2691ccfff	1818	if (value > 100) value = 100;
nucleosam	1:5cc2691ccfff	1819	value = (uint16_t)(((uint32_t)devicePrm.vrefPwmPeriod * (uint32_t)value) / 100);
nucleosam	1:5cc2691ccfff	1820	}
nucleosam	1:5cc2691ccfff	1821	if (bridgeId == 0)
nucleosam	1:5cc2691ccfff	1822	{
nucleosam	1:5cc2691ccfff	1823	devicePrm.vrefPwmPulseWidthTargetA = value;
nucleosam	1:5cc2691ccfff	1824	devicePrm.vrefPwmPulseWidthToBeGeneratedA = 0;
nucleosam	1:5cc2691ccfff	1825	}
nucleosam	1:5cc2691ccfff	1826	else if (bridgeId == 1)
nucleosam	1:5cc2691ccfff	1827	{
nucleosam	1:5cc2691ccfff	1828	devicePrm.vrefPwmPulseWidthTargetB = value;
nucleosam	1:5cc2691ccfff	1829	devicePrm.vrefPwmPulseWidthToBeGeneratedB = 0;
nucleosam	1:5cc2691ccfff	1830	}
nucleosam	1:5cc2691ccfff	1831	else
nucleosam	1:5cc2691ccfff	1832	{
nucleosam	1:5cc2691ccfff	1833	return FALSE;
nucleosam	1:5cc2691ccfff	1834	}
nucleosam	1:5cc2691ccfff	1835	return TRUE;
nucleosam	1:5cc2691ccfff	1836	}
nucleosam	1:5cc2691ccfff	1837
nucleosam	1:5cc2691ccfff	1838	/****************************************************//
nucleosam	1:5cc2691ccfff	1839	* @brief Update the pulse width of VREFA or VREFB PWM
nucleosam	1:5cc2691ccfff	1840	* @param None
nucleosam	1:5cc2691ccfff	1841	* @retval None
nucleosam	1:5cc2691ccfff	1842	**********************************************************/
nucleosam	1:5cc2691ccfff	1843	void L6208::L6208_VrefPwmUpdatePulseWidth(void)
nucleosam	1:5cc2691ccfff	1844	{
nucleosam	1:5cc2691ccfff	1845	uint16_t pulseWidthUs;
nucleosam	1:5cc2691ccfff	1846
nucleosam	1:5cc2691ccfff	1847	devicePrm.vrefPwmPulseWidthToBeGeneratedA += devicePrm.vrefPwmPulseWidthTargetA;
nucleosam	1:5cc2691ccfff	1848	pulseWidthUs = devicePrm.vrefPwmPulseWidthToBeGeneratedA>>8;
nucleosam	1:5cc2691ccfff	1849	if (pulseWidthUs!=0)
nucleosam	1:5cc2691ccfff	1850	{
nucleosam	1:5cc2691ccfff	1851	L6208_Board_VrefPwmSetPulseWidthA(pulseWidthUs);
nucleosam	1:5cc2691ccfff	1852	devicePrm.vrefPwmPulseWidthToBeGeneratedA -= (pulseWidthUs<<8);
nucleosam	1:5cc2691ccfff	1853	}
nucleosam	1:5cc2691ccfff	1854	else
nucleosam	1:5cc2691ccfff	1855	{
nucleosam	1:5cc2691ccfff	1856	L6208_Board_VrefPwmSetPulseWidthA(0);
nucleosam	1:5cc2691ccfff	1857	}
nucleosam	1:5cc2691ccfff	1858
nucleosam	1:5cc2691ccfff	1859	devicePrm.vrefPwmPulseWidthToBeGeneratedB += devicePrm.vrefPwmPulseWidthTargetB;
nucleosam	1:5cc2691ccfff	1860	pulseWidthUs = devicePrm.vrefPwmPulseWidthToBeGeneratedB>>8;
nucleosam	1:5cc2691ccfff	1861	if (pulseWidthUs!=0)
nucleosam	1:5cc2691ccfff	1862	{
nucleosam	1:5cc2691ccfff	1863	L6208_Board_VrefPwmSetPulseWidthB(pulseWidthUs);
nucleosam	1:5cc2691ccfff	1864	devicePrm.vrefPwmPulseWidthToBeGeneratedB -= (pulseWidthUs<<8);
nucleosam	1:5cc2691ccfff	1865	}
nucleosam	1:5cc2691ccfff	1866	else
nucleosam	1:5cc2691ccfff	1867	{
nucleosam	1:5cc2691ccfff	1868	L6208_Board_VrefPwmSetPulseWidthB(0);
nucleosam	1:5cc2691ccfff	1869	}
nucleosam	1:5cc2691ccfff	1870	}
nucleosam	1:5cc2691ccfff	1871
nucleosam	1:5cc2691ccfff	1872	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/