Easyspin_lib - Speed profile working

Robotique FIP » Code » Easyspin_lib

Speed profile working

Fork of Easyspin_lib by Julien Tiron

easyspin.cpp@1:9efe863db15e, 2015-08-26 (annotated)

Committer:: julientiron
Date:: Wed Aug 26 13:35:55 2015 +0000
Revision:: 1:9efe863db15e
Parent:: 0:cba942f8172a

Update for speed profile

Who changed what in which revision?

User	Revision	Line number	New contents of line
julientiron	0:cba942f8172a	1	/****************************************************//
julientiron	1:9efe863db15e	2	* @file easyspin.cpp
julientiron	0:cba942f8172a	3	* @version V1.0
julientiron	0:cba942f8172a	4	* @date June 29, 2015
julientiron	0:cba942f8172a	5	* @brief easyspin library for mbed
julientiron	0:cba942f8172a	6	*
julientiron	0:cba942f8172a	7	* This file is free software; you can redistribute it and/or modify
julientiron	0:cba942f8172a	8	* it under the terms of either the GNU General Public License version 2
julientiron	0:cba942f8172a	9	* or the GNU Lesser General Public License version 2.1, both as
julientiron	0:cba942f8172a	10	* published by the Free Software Foundation.
julientiron	1:9efe863db15e	11	**********************************************************/
julientiron	0:cba942f8172a	12
julientiron	0:cba942f8172a	13	#include "easyspin.h"
julientiron	0:cba942f8172a	14	#include "mbed.h"
julientiron	0:cba942f8172a	15
julientiron	0:cba942f8172a	16	const uint16_t Easyspin::prescalerArrayTimer0_1[PRESCALER_ARRAY_TIMER0_1_SIZE] = { 0, 1, 8, 64, 256, 1024};
julientiron	0:cba942f8172a	17	const uint16_t Easyspin::prescalerArrayTimer2[PRESCALER_ARRAY_TIMER2_SIZE] = {0, 1, 8, 32, 64, 128, 256, 1024};
julientiron	0:cba942f8172a	18	volatile void (*Easyspin::flagInterruptCallback)(void);
julientiron	0:cba942f8172a	19	volatile uint8_t Easyspin::numberOfShields;
julientiron	0:cba942f8172a	20	uint8_t Easyspin::spiTxBursts[Easyspin_CMD_ARG_MAX_NB_BYTES][MAX_NUMBER_OF_SHIELDS];
julientiron	0:cba942f8172a	21	uint8_t Easyspin::spiRxBursts[Easyspin_CMD_ARG_MAX_NB_BYTES][MAX_NUMBER_OF_SHIELDS];
julientiron	0:cba942f8172a	22	volatile bool Easyspin::spiPreemtionByIsr = false;
julientiron	0:cba942f8172a	23	volatile bool Easyspin::isrFlag = false;
julientiron	0:cba942f8172a	24	volatile class Easyspin* Easyspin::instancePtr = NULL;
julientiron	1:9efe863db15e	25
julientiron	0:cba942f8172a	26	/****************************************************//
julientiron	0:cba942f8172a	27	* @brief Constructor
julientiron	0:cba942f8172a	28	* @param None
julientiron	0:cba942f8172a	29	* @retval None
julientiron	1:9efe863db15e	30	**********************************************************/
julientiron	0:cba942f8172a	31	Easyspin::Easyspin():reset(Easyspin_Reset_Pin), dir1(Easyspin_DIR_1_Pin), dir2(Easyspin_DIR_2_Pin),
julientiron	1:9efe863db15e	32	dir3(Easyspin_DIR_3_Pin), CS(Easyspin_CS_Pin), flag(Easyspin_FLAG_Pin), pwm1(Easyspin_PWM_1_Pin),
julientiron	1:9efe863db15e	33	pwm2(Easyspin_PWM_2_Pin), pwm3(Easyspin_PWM_3_Pin), spi(Easyspin_MOSI_Pin, Easyspin_MISO_Pin, Easyspin_SCK_Pin)
julientiron	0:cba942f8172a	34	{
julientiron	1:9efe863db15e	35	uint8_t i;
julientiron	1:9efe863db15e	36	for (i = 0; i < MAX_NUMBER_OF_SHIELDS; i++) {
julientiron	1:9efe863db15e	37	shieldPrm[i].motionState = INACTIVE;
julientiron	1:9efe863db15e	38	shieldPrm[i].commandExecuted = NO_CMD;
julientiron	1:9efe863db15e	39	shieldPrm[i].stepsToTake = MAX_STEPS;
julientiron	1:9efe863db15e	40	}
julientiron	0:cba942f8172a	41	instancePtr = this;
julientiron	0:cba942f8172a	42	}
julientiron	0:cba942f8172a	43
julientiron	0:cba942f8172a	44	/****************************************************//
julientiron	0:cba942f8172a	45	* @brief Attaches a user callback to the flag Interrupt
julientiron	1:9efe863db15e	46	* The call back will be then called each time the status
julientiron	1:9efe863db15e	47	* flag pin will be pulled down due to the occurrence of
julientiron	1:9efe863db15e	48	* a programmed alarms ( OCD, thermal pre-warning or
julientiron	0:cba942f8172a	49	* shutdown, UVLO, wrong command, non-performable command)
julientiron	1:9efe863db15e	50	* @param[in] callback Name of the callback to attach
julientiron	0:cba942f8172a	51	* to the Flag Interrupt
julientiron	0:cba942f8172a	52	* @retval None
julientiron	0:cba942f8172a	53	**********************************************************/
julientiron	0:cba942f8172a	54	void Easyspin::AttachFlagInterrupt(void (*callback)(void))
julientiron	0:cba942f8172a	55	{
julientiron	1:9efe863db15e	56	flagInterruptCallback = (volatile void (*)())callback;
julientiron	0:cba942f8172a	57	}
julientiron	0:cba942f8172a	58
julientiron	0:cba942f8172a	59	/****************************************************//
julientiron	0:cba942f8172a	60	* @brief Starts the Easyspin library
julientiron	0:cba942f8172a	61	* @param[in] nbShields Number of Easyspin shields to use (from 1 to 3)
julientiron	0:cba942f8172a	62	* @retval None
julientiron	0:cba942f8172a	63	**********************************************************/
julientiron	0:cba942f8172a	64	void Easyspin::Begin(uint8_t nbShields)
julientiron	0:cba942f8172a	65	{
julientiron	1:9efe863db15e	66	numberOfShields = nbShields;
julientiron	1:9efe863db15e	67
julientiron	1:9efe863db15e	68	// start the SPI library:
julientiron	1:9efe863db15e	69	//SPI.begin();
julientiron	1:9efe863db15e	70	//SPI.setBitOrder(MSBFIRST);
julientiron	1:9efe863db15e	71	spi.format(8, 3);
julientiron	1:9efe863db15e	72	//SPI.setClockDivider(SPI_CLOCK_DIV4);
julientiron	1:9efe863db15e	73
julientiron	1:9efe863db15e	74	// flag pin
julientiron	1:9efe863db15e	75	//pinMode(Easyspin_FLAG_Pin, INPUT_PULLUP);
julientiron	1:9efe863db15e	76	flag.mode(PullUp);
julientiron	1:9efe863db15e	77	flag.fall(&FlagInterruptHandler);
julientiron	1:9efe863db15e	78
julientiron	1:9efe863db15e	79	//reset pin
julientiron	1:9efe863db15e	80	//pinMode(Easyspin_Reset_Pin, OUTPUT);
julientiron	1:9efe863db15e	81
julientiron	1:9efe863db15e	82	switch (nbShields) {
julientiron	1:9efe863db15e	83	case 3:
julientiron	1:9efe863db15e	84	//pinMode(Easyspin_DIR_3_Pin, OUTPUT);
julientiron	1:9efe863db15e	85	//pinMode(Easyspin_PWM_3_Pin, OUTPUT);
julientiron	1:9efe863db15e	86	PwmInit(2);
julientiron	1:9efe863db15e	87	case 2:
julientiron	1:9efe863db15e	88	//pinMode(Easyspin_DIR_2_Pin, OUTPUT);
julientiron	1:9efe863db15e	89	//pinMode(Easyspin_PWM_2_Pin, OUTPUT);
julientiron	1:9efe863db15e	90	PwmInit(1);
julientiron	1:9efe863db15e	91	case 1:
julientiron	1:9efe863db15e	92	//pinMode(Easyspin_DIR_1_Pin, OUTPUT);
julientiron	1:9efe863db15e	93	//pinMode(Easyspin_PWM_1_Pin, OUTPUT);
julientiron	1:9efe863db15e	94	PwmInit(0);
julientiron	1:9efe863db15e	95	default:
julientiron	1:9efe863db15e	96	;
julientiron	1:9efe863db15e	97	}
julientiron	1:9efe863db15e	98
julientiron	1:9efe863db15e	99	/* Standby-reset deactivation */
julientiron	1:9efe863db15e	100	ReleaseReset();
julientiron	1:9efe863db15e	101
julientiron	1:9efe863db15e	102	/* Set all registers and context variables to the predefined values from Easyspin_target_config.h */
julientiron	1:9efe863db15e	103	SetShieldParamsToPredefinedValues();
julientiron	1:9efe863db15e	104
julientiron	1:9efe863db15e	105	/* Disable Easyspin powerstage */
julientiron	1:9efe863db15e	106	for (uint32_t i = 0; i < nbShields; i++) {
julientiron	1:9efe863db15e	107	CmdDisable(i);
julientiron	1:9efe863db15e	108	/* Get Status to clear flags after start up */
julientiron	1:9efe863db15e	109	CmdGetStatus(i);
julientiron	1:9efe863db15e	110	}
julientiron	0:cba942f8172a	111	}
julientiron	0:cba942f8172a	112
julientiron	0:cba942f8172a	113	/****************************************************//
julientiron	0:cba942f8172a	114	* @brief Returns the acceleration of the specified shield
julientiron	0:cba942f8172a	115	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	116	* @retval Acceleration in pps^2
julientiron	0:cba942f8172a	117	**********************************************************/
julientiron	0:cba942f8172a	118	uint16_t Easyspin::GetAcceleration(uint8_t shieldId)
julientiron	1:9efe863db15e	119	{
julientiron	1:9efe863db15e	120	return (shieldPrm[shieldId].acceleration);
julientiron	1:9efe863db15e	121	}
julientiron	0:cba942f8172a	122
julientiron	0:cba942f8172a	123	/****************************************************//
julientiron	0:cba942f8172a	124	* @brief Returns the current speed of the specified shield
julientiron	0:cba942f8172a	125	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	126	* @retval Speed in pps
julientiron	0:cba942f8172a	127	**********************************************************/
julientiron	0:cba942f8172a	128	uint16_t Easyspin::GetCurrentSpeed(uint8_t shieldId)
julientiron	0:cba942f8172a	129	{
julientiron	1:9efe863db15e	130	return shieldPrm[shieldId].speed;
julientiron	0:cba942f8172a	131	}
julientiron	0:cba942f8172a	132
julientiron	0:cba942f8172a	133	/****************************************************//
julientiron	0:cba942f8172a	134	* @brief Returns the deceleration of the specified shield
julientiron	0:cba942f8172a	135	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	136	* @retval Deceleration in pps^2
julientiron	0:cba942f8172a	137	**********************************************************/
julientiron	0:cba942f8172a	138	uint16_t Easyspin::GetDeceleration(uint8_t shieldId)
julientiron	1:9efe863db15e	139	{
julientiron	1:9efe863db15e	140	return (shieldPrm[shieldId].deceleration);
julientiron	1:9efe863db15e	141	}
julientiron	0:cba942f8172a	142
julientiron	0:cba942f8172a	143	/****************************************************//
julientiron	0:cba942f8172a	144	* @brief Returns the FW version of the library
julientiron	0:cba942f8172a	145	* @param None
julientiron	0:cba942f8172a	146	* @retval Easyspin_FW_VERSION
julientiron	0:cba942f8172a	147	**********************************************************/
julientiron	0:cba942f8172a	148	uint8_t Easyspin::GetFwVersion(void)
julientiron	0:cba942f8172a	149	{
julientiron	1:9efe863db15e	150	return (Easyspin_FW_VERSION);
julientiron	0:cba942f8172a	151	}
julientiron	0:cba942f8172a	152
julientiron	0:cba942f8172a	153	/****************************************************//
julientiron	0:cba942f8172a	154	* @brief Returns the mark position of the specified shield
julientiron	0:cba942f8172a	155	* @param[in] shieldId (from 0 to 2)
julientiron	1:9efe863db15e	156	* @retval Mark register value converted in a 32b signed integer
julientiron	0:cba942f8172a	157	**********************************************************/
julientiron	0:cba942f8172a	158	int32_t Easyspin::GetMark(uint8_t shieldId)
julientiron	0:cba942f8172a	159	{
julientiron	1:9efe863db15e	160	return ConvertPosition(CmdGetParam(shieldId,Easyspin_MARK));
julientiron	0:cba942f8172a	161	}
julientiron	0:cba942f8172a	162
julientiron	0:cba942f8172a	163	/****************************************************//
julientiron	0:cba942f8172a	164	* @brief Returns the max speed of the specified shield
julientiron	0:cba942f8172a	165	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	166	* @retval maxSpeed in pps
julientiron	0:cba942f8172a	167	**********************************************************/
julientiron	0:cba942f8172a	168	uint16_t Easyspin::GetMaxSpeed(uint8_t shieldId)
julientiron	1:9efe863db15e	169	{
julientiron	1:9efe863db15e	170	return (shieldPrm[shieldId].maxSpeed);
julientiron	1:9efe863db15e	171	}
julientiron	0:cba942f8172a	172
julientiron	0:cba942f8172a	173	/****************************************************//
julientiron	0:cba942f8172a	174	* @brief Returns the min speed of the specified shield
julientiron	0:cba942f8172a	175	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	176	* @retval minSpeed in pps
julientiron	0:cba942f8172a	177	**********************************************************/
julientiron	0:cba942f8172a	178	uint16_t Easyspin::GetMinSpeed(uint8_t shieldId)
julientiron	1:9efe863db15e	179	{
julientiron	1:9efe863db15e	180	return (shieldPrm[shieldId].minSpeed);
julientiron	1:9efe863db15e	181	}
julientiron	0:cba942f8172a	182
julientiron	0:cba942f8172a	183	/****************************************************//
julientiron	0:cba942f8172a	184	* @brief Returns the ABS_POSITION of the specified shield
julientiron	0:cba942f8172a	185	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	186	* @retval ABS_POSITION register value converted in a 32b signed integer
julientiron	0:cba942f8172a	187	**********************************************************/
julientiron	0:cba942f8172a	188	int32_t Easyspin::GetPosition(uint8_t shieldId)
julientiron	0:cba942f8172a	189	{
julientiron	1:9efe863db15e	190	return ConvertPosition(CmdGetParam(shieldId,Easyspin_ABS_POS));
julientiron	0:cba942f8172a	191	}
julientiron	0:cba942f8172a	192
julientiron	0:cba942f8172a	193	/****************************************************//
julientiron	0:cba942f8172a	194	* @brief Returns the shield state
julientiron	0:cba942f8172a	195	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	196	* @retval State (ACCELERATING, DECELERATING, STEADY or INACTIVE)
julientiron	0:cba942f8172a	197	**********************************************************/
julientiron	0:cba942f8172a	198	shieldState_t Easyspin::GetShieldState(uint8_t shieldId)
julientiron	0:cba942f8172a	199	{
julientiron	1:9efe863db15e	200	return shieldPrm[shieldId].motionState;
julientiron	0:cba942f8172a	201	}
julientiron	0:cba942f8172a	202
julientiron	0:cba942f8172a	203	/****************************************************//
julientiron	0:cba942f8172a	204	* @brief Requests the motor to move to the home position (ABS_POSITION = 0)
julientiron	0:cba942f8172a	205	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	206	* @retval None
julientiron	0:cba942f8172a	207	**********************************************************/
julientiron	0:cba942f8172a	208	void Easyspin::GoHome(uint8_t shieldId)
julientiron	0:cba942f8172a	209	{
julientiron	1:9efe863db15e	210	GoTo(shieldId, 0);
julientiron	1:9efe863db15e	211	}
julientiron	1:9efe863db15e	212
julientiron	0:cba942f8172a	213	/****************************************************//
julientiron	1:9efe863db15e	214	* @brief Requests the motor to move to the mark position
julientiron	0:cba942f8172a	215	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	216	* @retval None
julientiron	0:cba942f8172a	217	**********************************************************/
julientiron	0:cba942f8172a	218	void Easyspin::GoMark(uint8_t shieldId)
julientiron	0:cba942f8172a	219	{
julientiron	0:cba942f8172a	220	uint32_t mark;
julientiron	0:cba942f8172a	221
julientiron	0:cba942f8172a	222	mark = ConvertPosition(CmdGetParam(shieldId,Easyspin_MARK));
julientiron	1:9efe863db15e	223	GoTo(shieldId,mark);
julientiron	0:cba942f8172a	224	}
julientiron	0:cba942f8172a	225
julientiron	0:cba942f8172a	226	/****************************************************//
julientiron	1:9efe863db15e	227	* @brief Requests the motor to move to the specified position
julientiron	0:cba942f8172a	228	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	229	* @param[in] targetPosition absolute position in steps
julientiron	0:cba942f8172a	230	* @retval None
julientiron	0:cba942f8172a	231	**********************************************************/
julientiron	0:cba942f8172a	232	void Easyspin::GoTo(uint8_t shieldId, int32_t targetPosition)
julientiron	0:cba942f8172a	233	{
julientiron	1:9efe863db15e	234	dir_t direction;
julientiron	1:9efe863db15e	235	int32_t steps;
julientiron	1:9efe863db15e	236
julientiron	1:9efe863db15e	237	/* Eventually deactivate motor */
julientiron	1:9efe863db15e	238	if (shieldPrm[shieldId].motionState != INACTIVE) {
julientiron	1:9efe863db15e	239	HardStop(shieldId);
julientiron	1:9efe863db15e	240	}
julientiron	1:9efe863db15e	241
julientiron	1:9efe863db15e	242	/* Get current position */
julientiron	1:9efe863db15e	243	shieldPrm[shieldId].currentPosition = ConvertPosition(CmdGetParam(shieldId,Easyspin_ABS_POS));
julientiron	1:9efe863db15e	244
julientiron	1:9efe863db15e	245	/* Compute the number of steps to perform */
julientiron	1:9efe863db15e	246	steps = targetPosition - shieldPrm[shieldId].currentPosition;
julientiron	1:9efe863db15e	247
julientiron	1:9efe863db15e	248	if (steps >= 0) {
julientiron	1:9efe863db15e	249	shieldPrm[shieldId].stepsToTake = steps;
julientiron	1:9efe863db15e	250	direction = FORWARD;
julientiron	0:cba942f8172a	251
julientiron	1:9efe863db15e	252	} else {
julientiron	1:9efe863db15e	253	shieldPrm[shieldId].stepsToTake = -steps;
julientiron	1:9efe863db15e	254	direction = BACKWARD;
julientiron	1:9efe863db15e	255	}
julientiron	1:9efe863db15e	256
julientiron	1:9efe863db15e	257	if (steps != 0) {
julientiron	1:9efe863db15e	258
julientiron	1:9efe863db15e	259	shieldPrm[shieldId].commandExecuted = MOVE_CMD;
julientiron	0:cba942f8172a	260
julientiron	1:9efe863db15e	261	/* Direction setup */
julientiron	1:9efe863db15e	262	SetDirection(shieldId,direction);
julientiron	1:9efe863db15e	263
julientiron	1:9efe863db15e	264	ComputeSpeedProfile(shieldId, shieldPrm[shieldId].stepsToTake);
julientiron	1:9efe863db15e	265
julientiron	1:9efe863db15e	266	/* Motor activation */
julientiron	1:9efe863db15e	267	StartMovement(shieldId);
julientiron	1:9efe863db15e	268	}
julientiron	0:cba942f8172a	269	}
julientiron	0:cba942f8172a	270
julientiron	0:cba942f8172a	271	/****************************************************//
julientiron	0:cba942f8172a	272	* @brief Immediatly stops the motor and disable the power bridge
julientiron	0:cba942f8172a	273	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	274	* @retval None
julientiron	0:cba942f8172a	275	**********************************************************/
julientiron	1:9efe863db15e	276	void Easyspin::HardStop(uint8_t shieldId)
julientiron	0:cba942f8172a	277	{
julientiron	1:9efe863db15e	278	/* Disable corresponding PWM */
julientiron	1:9efe863db15e	279	PwmStop(shieldId);
julientiron	0:cba942f8172a	280
julientiron	1:9efe863db15e	281	/* Disable power stage */
julientiron	1:9efe863db15e	282	CmdDisable(shieldId);
julientiron	0:cba942f8172a	283
julientiron	1:9efe863db15e	284	/* Set inactive state */
julientiron	1:9efe863db15e	285	shieldPrm[shieldId].motionState = INACTIVE;
julientiron	1:9efe863db15e	286	shieldPrm[shieldId].commandExecuted = NO_CMD;
julientiron	1:9efe863db15e	287	shieldPrm[shieldId].stepsToTake = MAX_STEPS;
julientiron	0:cba942f8172a	288
julientiron	0:cba942f8172a	289	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	290	Serial.println("Inactive\n");
julientiron	1:9efe863db15e	291	#endif
julientiron	0:cba942f8172a	292	}
julientiron	0:cba942f8172a	293
julientiron	0:cba942f8172a	294	/****************************************************//
julientiron	0:cba942f8172a	295	* @brief Moves the motor of the specified number of steps
julientiron	0:cba942f8172a	296	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	297	* @param[in] direction FORWARD or BACKWARD
julientiron	0:cba942f8172a	298	* @param[in] stepCount Number of steps to perform
julientiron	0:cba942f8172a	299	* @retval None
julientiron	0:cba942f8172a	300	**********************************************************/
julientiron	0:cba942f8172a	301	void Easyspin::Move(uint8_t shieldId, dir_t direction, uint32_t stepCount)
julientiron	0:cba942f8172a	302	{
julientiron	1:9efe863db15e	303	/* Eventually deactivate motor */
julientiron	1:9efe863db15e	304	if (shieldPrm[shieldId].motionState != INACTIVE) {
julientiron	1:9efe863db15e	305	HardStop(shieldId);
julientiron	1:9efe863db15e	306	}
julientiron	1:9efe863db15e	307
julientiron	1:9efe863db15e	308	if (stepCount != 0) {
julientiron	1:9efe863db15e	309	shieldPrm[shieldId].stepsToTake = stepCount;
julientiron	1:9efe863db15e	310
julientiron	1:9efe863db15e	311	shieldPrm[shieldId].commandExecuted = MOVE_CMD;
julientiron	1:9efe863db15e	312
julientiron	1:9efe863db15e	313	shieldPrm[shieldId].currentPosition = ConvertPosition(CmdGetParam(shieldId,Easyspin_ABS_POS));
julientiron	1:9efe863db15e	314
julientiron	1:9efe863db15e	315	/* Direction setup */
julientiron	1:9efe863db15e	316	SetDirection(shieldId,direction);
julientiron	1:9efe863db15e	317
julientiron	1:9efe863db15e	318	ComputeSpeedProfile(shieldId, stepCount);
julientiron	1:9efe863db15e	319
julientiron	1:9efe863db15e	320	/* Motor activation */
julientiron	1:9efe863db15e	321	StartMovement(shieldId);
julientiron	1:9efe863db15e	322	}
julientiron	1:9efe863db15e	323	}
julientiron	1:9efe863db15e	324
julientiron	0:cba942f8172a	325
julientiron	1:9efe863db15e	326	/****************************************************//
julientiron	1:9efe863db15e	327	* @brief Turn left or right with the specified angle
julientiron	1:9efe863db15e	328	* @param[in] rotation RIGHT or LEFT
julientiron	1:9efe863db15e	329	* @param[in] angle in degrees
julientiron	1:9efe863db15e	330	* @retval None
julientiron	1:9efe863db15e	331	**********************************************************/
julientiron	1:9efe863db15e	332	void Easyspin::Turn(rot_t rotation, uint16_t angle)
julientiron	1:9efe863db15e	333	{
julientiron	1:9efe863db15e	334	uint16_t nbStep = (10934*angle)/360;
julientiron	1:9efe863db15e	335	if(rotation==RIGHT) {
julientiron	1:9efe863db15e	336	Move(0, FORWARD, nbStep);
julientiron	1:9efe863db15e	337	Move(1, FORWARD, nbStep);
julientiron	1:9efe863db15e	338	} else {
julientiron	1:9efe863db15e	339	Move(0, BACKWARD, nbStep);
julientiron	1:9efe863db15e	340	Move(1, BACKWARD, nbStep);
julientiron	1:9efe863db15e	341	}
julientiron	1:9efe863db15e	342	}
julientiron	1:9efe863db15e	343
julientiron	1:9efe863db15e	344	/****************************************************//
julientiron	1:9efe863db15e	345	* @brief Move forward or backward with the specified distance
julientiron	1:9efe863db15e	346	* @param[in] direction FORWARD or BACKWARD
julientiron	1:9efe863db15e	347	* @param[in] distance in cm
julientiron	1:9efe863db15e	348	* @retval None
julientiron	1:9efe863db15e	349	**********************************************************/
julientiron	1:9efe863db15e	350	void Easyspin::Move_cm(dir_t direction, uint16_t distance)
julientiron	1:9efe863db15e	351	{
julientiron	1:9efe863db15e	352	uint16_t nbStep = (10000 * distance)/61;
julientiron	1:9efe863db15e	353	if(direction==FORWARD) {
julientiron	1:9efe863db15e	354	Move(0, FORWARD, nbStep);
julientiron	1:9efe863db15e	355	Move(1, BACKWARD, nbStep);
julientiron	1:9efe863db15e	356	} else {
julientiron	1:9efe863db15e	357	Move(0, BACKWARD, nbStep);
julientiron	1:9efe863db15e	358	Move(1, FORWARD, nbStep);
julientiron	1:9efe863db15e	359	}
julientiron	0:cba942f8172a	360	}
julientiron	0:cba942f8172a	361
julientiron	0:cba942f8172a	362	/****************************************************//
julientiron	0:cba942f8172a	363	* @brief Resets all Easyspin shields
julientiron	0:cba942f8172a	364	* @param None
julientiron	0:cba942f8172a	365	* @retval None
julientiron	0:cba942f8172a	366	**********************************************************/
julientiron	0:cba942f8172a	367	void Easyspin::ResetAllShields(void)
julientiron	0:cba942f8172a	368	{
julientiron	0:cba942f8172a	369	uint8_t loop;
julientiron	1:9efe863db15e	370
julientiron	1:9efe863db15e	371	for (loop = 0; loop < numberOfShields; loop++) {
julientiron	1:9efe863db15e	372	/* Stop movement and disable power stage*/
julientiron	1:9efe863db15e	373	HardStop(loop);
julientiron	1:9efe863db15e	374	}
julientiron	0:cba942f8172a	375	Reset();
julientiron	1:9efe863db15e	376	wait_us(20); // Reset pin must be forced low for at least 10us
julientiron	0:cba942f8172a	377	ReleaseReset();
julientiron	0:cba942f8172a	378	}
julientiron	0:cba942f8172a	379
julientiron	0:cba942f8172a	380	/****************************************************//
julientiron	1:9efe863db15e	381	* @brief Runs the motor. It will accelerate from the min
julientiron	0:cba942f8172a	382	* speed up to the max speed by using the shield acceleration.
julientiron	0:cba942f8172a	383	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	384	* @param[in] direction FORWARD or BACKWARD
julientiron	0:cba942f8172a	385	* @retval None
julientiron	0:cba942f8172a	386	**********************************************************/
julientiron	0:cba942f8172a	387	void Easyspin::Run(uint8_t shieldId, dir_t direction)
julientiron	0:cba942f8172a	388	{
julientiron	1:9efe863db15e	389	/* Eventually deactivate motor */
julientiron	1:9efe863db15e	390	if (shieldPrm[shieldId].motionState != INACTIVE) {
julientiron	1:9efe863db15e	391	HardStop(shieldId);
julientiron	1:9efe863db15e	392	}
julientiron	1:9efe863db15e	393
julientiron	0:cba942f8172a	394	/* Direction setup */
julientiron	0:cba942f8172a	395	SetDirection(shieldId,direction);
julientiron	0:cba942f8172a	396
julientiron	0:cba942f8172a	397	shieldPrm[shieldId].commandExecuted = RUN_CMD;
julientiron	0:cba942f8172a	398
julientiron	0:cba942f8172a	399	/* Motor activation */
julientiron	1:9efe863db15e	400	StartMovement(shieldId);
julientiron	0:cba942f8172a	401	}
julientiron	0:cba942f8172a	402
julientiron	0:cba942f8172a	403	/****************************************************//
julientiron	0:cba942f8172a	404	* @brief Changes the acceleration of the specified shield
julientiron	0:cba942f8172a	405	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	406	* @param[in] newAcc New acceleration to apply in pps^2
julientiron	0:cba942f8172a	407	* @retval true if the command is successfully executed, else false
julientiron	1:9efe863db15e	408	* @note The command is not performed is the shield is executing
julientiron	0:cba942f8172a	409	* a MOVE or GOTO command (but it can be used during a RUN command)
julientiron	0:cba942f8172a	410	**********************************************************/
julientiron	0:cba942f8172a	411	bool Easyspin::SetAcceleration(uint8_t shieldId,uint16_t newAcc)
julientiron	1:9efe863db15e	412	{
julientiron	1:9efe863db15e	413	bool cmdExecuted = false;
julientiron	1:9efe863db15e	414	if ((newAcc != 0)&&
julientiron	1:9efe863db15e	415	((shieldPrm[shieldId].motionState == INACTIVE)\|\|
julientiron	1:9efe863db15e	416	(shieldPrm[shieldId].commandExecuted == RUN_CMD))) {
julientiron	1:9efe863db15e	417	shieldPrm[shieldId].acceleration = newAcc;
julientiron	1:9efe863db15e	418	cmdExecuted = true;
julientiron	1:9efe863db15e	419	}
julientiron	1:9efe863db15e	420	return cmdExecuted;
julientiron	1:9efe863db15e	421	}
julientiron	0:cba942f8172a	422
julientiron	0:cba942f8172a	423	/****************************************************//
julientiron	0:cba942f8172a	424	* @brief Changes the deceleration of the specified shield
julientiron	0:cba942f8172a	425	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	426	* @param[in] newDec New deceleration to apply in pps^2
julientiron	0:cba942f8172a	427	* @retval true if the command is successfully executed, else false
julientiron	1:9efe863db15e	428	* @note The command is not performed is the shield is executing
julientiron	0:cba942f8172a	429	* a MOVE or GOTO command (but it can be used during a RUN command)
julientiron	0:cba942f8172a	430	**********************************************************/
julientiron	0:cba942f8172a	431	bool Easyspin::SetDeceleration(uint8_t shieldId, uint16_t newDec)
julientiron	1:9efe863db15e	432	{
julientiron	1:9efe863db15e	433	bool cmdExecuted = false;
julientiron	1:9efe863db15e	434	if ((newDec != 0)&&
julientiron	1:9efe863db15e	435	((shieldPrm[shieldId].motionState == INACTIVE)\|\|
julientiron	1:9efe863db15e	436	(shieldPrm[shieldId].commandExecuted == RUN_CMD))) {
julientiron	1:9efe863db15e	437	shieldPrm[shieldId].deceleration = newDec;
julientiron	1:9efe863db15e	438	cmdExecuted = true;
julientiron	1:9efe863db15e	439	}
julientiron	1:9efe863db15e	440	return cmdExecuted;
julientiron	1:9efe863db15e	441	}
julientiron	0:cba942f8172a	442
julientiron	0:cba942f8172a	443	/****************************************************//
julientiron	0:cba942f8172a	444	* @brief Set current position to be the Home position (ABS pos set to 0)
julientiron	0:cba942f8172a	445	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	446	* @retval None
julientiron	0:cba942f8172a	447	**********************************************************/
julientiron	0:cba942f8172a	448	void Easyspin::SetHome(uint8_t shieldId)
julientiron	0:cba942f8172a	449	{
julientiron	1:9efe863db15e	450	CmdSetParam(shieldId, Easyspin_ABS_POS, 0);
julientiron	0:cba942f8172a	451	}
julientiron	1:9efe863db15e	452
julientiron	0:cba942f8172a	453	/****************************************************//
julientiron	1:9efe863db15e	454	* @brief Sets current position to be the Mark position
julientiron	0:cba942f8172a	455	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	456	* @retval None
julientiron	0:cba942f8172a	457	**********************************************************/
julientiron	0:cba942f8172a	458	void Easyspin::SetMark(uint8_t shieldId)
julientiron	0:cba942f8172a	459	{
julientiron	1:9efe863db15e	460	uint32_t mark = CmdGetParam(shieldId,Easyspin_ABS_POS);
julientiron	1:9efe863db15e	461	CmdSetParam(shieldId,Easyspin_MARK, mark);
julientiron	0:cba942f8172a	462	}
julientiron	0:cba942f8172a	463
julientiron	0:cba942f8172a	464	/****************************************************//
julientiron	0:cba942f8172a	465	* @brief Changes the max speed of the specified shield
julientiron	0:cba942f8172a	466	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	467	* @param[in] newMaxSpeed New max speed to apply in pps
julientiron	0:cba942f8172a	468	* @retval true if the command is successfully executed, else false
julientiron	1:9efe863db15e	469	* @note The command is not performed is the shield is executing
julientiron	0:cba942f8172a	470	* a MOVE or GOTO command (but it can be used during a RUN command).
julientiron	0:cba942f8172a	471	**********************************************************/
julientiron	0:cba942f8172a	472	bool Easyspin::SetMaxSpeed(uint8_t shieldId, uint16_t newMaxSpeed)
julientiron	1:9efe863db15e	473	{
julientiron	1:9efe863db15e	474	bool cmdExecuted = false;
julientiron	1:9efe863db15e	475	if ((newMaxSpeed > Easyspin_MIN_PWM_FREQ)&&
julientiron	1:9efe863db15e	476	(newMaxSpeed <= Easyspin_MAX_PWM_FREQ) &&
julientiron	1:9efe863db15e	477	(shieldPrm[shieldId].minSpeed <= newMaxSpeed) &&
julientiron	1:9efe863db15e	478	((shieldPrm[shieldId].motionState == INACTIVE)\|\|
julientiron	1:9efe863db15e	479	(shieldPrm[shieldId].commandExecuted == RUN_CMD))) {
julientiron	1:9efe863db15e	480	shieldPrm[shieldId].maxSpeed = newMaxSpeed;
julientiron	1:9efe863db15e	481	cmdExecuted = true;
julientiron	1:9efe863db15e	482	}
julientiron	1:9efe863db15e	483	return cmdExecuted;
julientiron	1:9efe863db15e	484	}
julientiron	0:cba942f8172a	485
julientiron	0:cba942f8172a	486	/****************************************************//
julientiron	0:cba942f8172a	487	* @brief Changes the min speed of the specified shield
julientiron	0:cba942f8172a	488	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	489	* @param[in] newMinSpeed New min speed to apply in pps
julientiron	0:cba942f8172a	490	* @retval true if the command is successfully executed, else false
julientiron	1:9efe863db15e	491	* @note The command is not performed is the shield is executing
julientiron	0:cba942f8172a	492	* a MOVE or GOTO command (but it can be used during a RUN command).
julientiron	0:cba942f8172a	493	**********************************************************/
julientiron	0:cba942f8172a	494	bool Easyspin::SetMinSpeed(uint8_t shieldId, uint16_t newMinSpeed)
julientiron	1:9efe863db15e	495	{
julientiron	1:9efe863db15e	496	bool cmdExecuted = false;
julientiron	1:9efe863db15e	497	if ((newMinSpeed >= Easyspin_MIN_PWM_FREQ)&&
julientiron	1:9efe863db15e	498	(newMinSpeed < Easyspin_MAX_PWM_FREQ) &&
julientiron	1:9efe863db15e	499	(newMinSpeed <= shieldPrm[shieldId].maxSpeed) &&
julientiron	1:9efe863db15e	500	((shieldPrm[shieldId].motionState == INACTIVE)\|\|
julientiron	1:9efe863db15e	501	(shieldPrm[shieldId].commandExecuted == RUN_CMD))) {
julientiron	1:9efe863db15e	502	shieldPrm[shieldId].minSpeed = newMinSpeed;
julientiron	1:9efe863db15e	503	cmdExecuted = true;
julientiron	1:9efe863db15e	504	}
julientiron	1:9efe863db15e	505	return cmdExecuted;
julientiron	1:9efe863db15e	506	}
julientiron	0:cba942f8172a	507
julientiron	0:cba942f8172a	508	/****************************************************//
julientiron	0:cba942f8172a	509	* @brief Stops the motor by using the shield deceleration
julientiron	0:cba942f8172a	510	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	511	* @retval true if the command is successfully executed, else false
julientiron	0:cba942f8172a	512	* @note The command is not performed is the shield is in INACTIVE state.
julientiron	0:cba942f8172a	513	**********************************************************/
julientiron	0:cba942f8172a	514	bool Easyspin::SoftStop(uint8_t shieldId)
julientiron	1:9efe863db15e	515	{
julientiron	1:9efe863db15e	516	bool cmdExecuted = false;
julientiron	1:9efe863db15e	517	if (shieldPrm[shieldId].motionState != INACTIVE) {
julientiron	1:9efe863db15e	518	shieldPrm[shieldId].commandExecuted = SOFT_STOP_CMD;
julientiron	1:9efe863db15e	519	cmdExecuted = true;
julientiron	1:9efe863db15e	520	}
julientiron	1:9efe863db15e	521	return (cmdExecuted);
julientiron	0:cba942f8172a	522	}
julientiron	0:cba942f8172a	523
julientiron	0:cba942f8172a	524	/****************************************************//
julientiron	0:cba942f8172a	525	* @brief Locks until the shield state becomes Inactive
julientiron	0:cba942f8172a	526	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	527	* @retval None
julientiron	0:cba942f8172a	528	**********************************************************/
julientiron	0:cba942f8172a	529	void Easyspin::WaitWhileActive(uint8_t shieldId)
julientiron	1:9efe863db15e	530	{
julientiron	0:cba942f8172a	531	/* Wait while motor is running */
julientiron	0:cba942f8172a	532	while (GetShieldState(shieldId) != INACTIVE);
julientiron	0:cba942f8172a	533	}
julientiron	0:cba942f8172a	534
julientiron	0:cba942f8172a	535	/****************************************************//
julientiron	0:cba942f8172a	536	* @brief Issue the Disable command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	537	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	538	* @retval None
julientiron	0:cba942f8172a	539	**********************************************************/
julientiron	0:cba942f8172a	540	void Easyspin::CmdDisable(uint8_t shieldId)
julientiron	0:cba942f8172a	541	{
julientiron	1:9efe863db15e	542	SendCommand(shieldId, Easyspin_DISABLE);
julientiron	0:cba942f8172a	543	}
julientiron	0:cba942f8172a	544
julientiron	0:cba942f8172a	545	/****************************************************//
julientiron	0:cba942f8172a	546	* @brief Issues the Enable command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	547	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	548	* @retval None
julientiron	0:cba942f8172a	549	**********************************************************/
julientiron	0:cba942f8172a	550	void Easyspin::CmdEnable(uint8_t shieldId)
julientiron	0:cba942f8172a	551	{
julientiron	1:9efe863db15e	552	SendCommand(shieldId, Easyspin_ENABLE);
julientiron	0:cba942f8172a	553	}
julientiron	0:cba942f8172a	554
julientiron	0:cba942f8172a	555	/****************************************************//
julientiron	0:cba942f8172a	556	* @brief Issues the GetParam command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	557	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	558	* @param[in] param Register adress (Easyspin_ABS_POS, Easyspin_MARK,...)
julientiron	0:cba942f8172a	559	* @retval Register value
julientiron	0:cba942f8172a	560	**********************************************************/
julientiron	0:cba942f8172a	561	uint32_t Easyspin::CmdGetParam(uint8_t shieldId, Easyspin_Registers_t param)
julientiron	0:cba942f8172a	562	{
julientiron	1:9efe863db15e	563	uint32_t i;
julientiron	1:9efe863db15e	564	uint32_t spiRxData;
julientiron	1:9efe863db15e	565	uint8_t maxArgumentNbBytes = 0;
julientiron	1:9efe863db15e	566	uint8_t spiIndex = numberOfShields - shieldId - 1;
julientiron	1:9efe863db15e	567	bool itDisable = false;
julientiron	1:9efe863db15e	568
julientiron	1:9efe863db15e	569	do {
julientiron	1:9efe863db15e	570	spiPreemtionByIsr = false;
julientiron	1:9efe863db15e	571	if (itDisable) {
julientiron	1:9efe863db15e	572	/* re-enable interrupts if disable in previous iteration */
julientiron	1:9efe863db15e	573	flag.enable_irq();
julientiron	1:9efe863db15e	574	itDisable = false;
julientiron	1:9efe863db15e	575	}
julientiron	1:9efe863db15e	576
julientiron	1:9efe863db15e	577	for (i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	578	spiTxBursts[0][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	579	spiTxBursts[1][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	580	spiTxBursts[2][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	581	spiTxBursts[3][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	582	spiRxBursts[1][i] = 0;
julientiron	1:9efe863db15e	583	spiRxBursts[2][i] = 0;
julientiron	1:9efe863db15e	584	spiRxBursts[3][i] = 0;
julientiron	1:9efe863db15e	585	}
julientiron	1:9efe863db15e	586	switch (param) {
julientiron	1:9efe863db15e	587	case Easyspin_ABS_POS:
julientiron	1:9efe863db15e	588	;
julientiron	1:9efe863db15e	589	case Easyspin_MARK:
julientiron	1:9efe863db15e	590	spiTxBursts[0][spiIndex] = ((uint8_t)Easyspin_GET_PARAM )\| (param);
julientiron	1:9efe863db15e	591	maxArgumentNbBytes = 3;
julientiron	1:9efe863db15e	592	break;
julientiron	1:9efe863db15e	593	case Easyspin_EL_POS:
julientiron	1:9efe863db15e	594	;
julientiron	1:9efe863db15e	595	case Easyspin_CONFIG:
julientiron	1:9efe863db15e	596	;
julientiron	1:9efe863db15e	597	case Easyspin_STATUS:
julientiron	1:9efe863db15e	598	spiTxBursts[1][spiIndex] = ((uint8_t)Easyspin_GET_PARAM )\| (param);
julientiron	1:9efe863db15e	599	maxArgumentNbBytes = 2;
julientiron	1:9efe863db15e	600	break;
julientiron	1:9efe863db15e	601	default:
julientiron	1:9efe863db15e	602	spiTxBursts[2][spiIndex] = ((uint8_t)Easyspin_GET_PARAM )\| (param);
julientiron	1:9efe863db15e	603	maxArgumentNbBytes = 1;
julientiron	1:9efe863db15e	604	}
julientiron	1:9efe863db15e	605
julientiron	1:9efe863db15e	606	/* Disable interruption before checking */
julientiron	1:9efe863db15e	607	/* pre-emption by ISR and SPI transfers*/
julientiron	1:9efe863db15e	608	flag.disable_irq();
julientiron	1:9efe863db15e	609	itDisable = true;
julientiron	1:9efe863db15e	610	} while (spiPreemtionByIsr); // check pre-emption by ISR
julientiron	1:9efe863db15e	611
julientiron	1:9efe863db15e	612	for (i = Easyspin_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
julientiron	1:9efe863db15e	613	i < Easyspin_CMD_ARG_MAX_NB_BYTES;
julientiron	1:9efe863db15e	614	i++) {
julientiron	1:9efe863db15e	615	WriteBytes(&spiTxBursts[i][0],
julientiron	1:9efe863db15e	616	&spiRxBursts[i][0]);
julientiron	0:cba942f8172a	617	}
julientiron	1:9efe863db15e	618
julientiron	1:9efe863db15e	619	spiRxData = ((uint32_t)spiRxBursts[1][spiIndex] << 16)\|
julientiron	1:9efe863db15e	620	(spiRxBursts[2][spiIndex] << 8) \|
julientiron	1:9efe863db15e	621	(spiRxBursts[3][spiIndex]);
julientiron	1:9efe863db15e	622
julientiron	1:9efe863db15e	623	/* re-enable interrupts after SPI transfers*/
julientiron	1:9efe863db15e	624	flag.enable_irq();
julientiron	1:9efe863db15e	625
julientiron	1:9efe863db15e	626	return (spiRxData);
julientiron	0:cba942f8172a	627	}
julientiron	0:cba942f8172a	628
julientiron	0:cba942f8172a	629	/****************************************************//
julientiron	0:cba942f8172a	630	* @brief Issues the GetStatus command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	631	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	632	* @retval Status Register value
julientiron	0:cba942f8172a	633	* @note Once the GetStatus command is performed, the flags of the status register
julientiron	0:cba942f8172a	634	* are reset. This is not the case when the status register is read with the
julientiron	0:cba942f8172a	635	* GetParam command (via the functions ReadStatusRegister or CmdGetParam).
julientiron	0:cba942f8172a	636	**********************************************************/
julientiron	0:cba942f8172a	637	uint16_t Easyspin::CmdGetStatus(uint8_t shieldId)
julientiron	0:cba942f8172a	638	{
julientiron	1:9efe863db15e	639	uint32_t i;
julientiron	1:9efe863db15e	640	uint16_t status;
julientiron	1:9efe863db15e	641	uint8_t spiIndex = numberOfShields - shieldId - 1;
julientiron	1:9efe863db15e	642	bool itDisable = false;
julientiron	1:9efe863db15e	643
julientiron	1:9efe863db15e	644	do {
julientiron	1:9efe863db15e	645	spiPreemtionByIsr = false;
julientiron	1:9efe863db15e	646	if (itDisable) {
julientiron	1:9efe863db15e	647	/* re-enable interrupts if disable in previous iteration */
julientiron	1:9efe863db15e	648	flag.enable_irq();
julientiron	1:9efe863db15e	649	itDisable = false;
julientiron	1:9efe863db15e	650	}
julientiron	0:cba942f8172a	651
julientiron	1:9efe863db15e	652	for (i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	653	spiTxBursts[0][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	654	spiTxBursts[1][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	655	spiTxBursts[2][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	656	spiRxBursts[1][i] = 0;
julientiron	1:9efe863db15e	657	spiRxBursts[2][i] = 0;
julientiron	1:9efe863db15e	658	}
julientiron	1:9efe863db15e	659	spiTxBursts[0][spiIndex] = Easyspin_GET_STATUS;
julientiron	0:cba942f8172a	660
julientiron	1:9efe863db15e	661	/* Disable interruption before checking */
julientiron	1:9efe863db15e	662	/* pre-emption by ISR and SPI transfers*/
julientiron	1:9efe863db15e	663	flag.disable_irq();
julientiron	1:9efe863db15e	664	itDisable = true;
julientiron	1:9efe863db15e	665	} while (spiPreemtionByIsr); // check pre-emption by ISR
julientiron	0:cba942f8172a	666
julientiron	1:9efe863db15e	667	for (i = 0; i < Easyspin_CMD_ARG_NB_BYTES_GET_STATUS + Easyspin_RSP_NB_BYTES_GET_STATUS; i++) {
julientiron	1:9efe863db15e	668	WriteBytes(&spiTxBursts[i][0], &spiRxBursts[i][0]);
julientiron	1:9efe863db15e	669	}
julientiron	1:9efe863db15e	670	status = (spiRxBursts[1][spiIndex] << 8) \| (spiRxBursts[2][spiIndex]);
julientiron	1:9efe863db15e	671
julientiron	1:9efe863db15e	672	/* re-enable interrupts after SPI transfers*/
julientiron	1:9efe863db15e	673	flag.enable_irq();
julientiron	1:9efe863db15e	674
julientiron	1:9efe863db15e	675	return (status);
julientiron	0:cba942f8172a	676	}
julientiron	0:cba942f8172a	677
julientiron	0:cba942f8172a	678	/****************************************************//
julientiron	0:cba942f8172a	679	* @brief Issues the Nop command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	680	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	681	* @retval None
julientiron	0:cba942f8172a	682	**********************************************************/
julientiron	0:cba942f8172a	683	void Easyspin::CmdNop(uint8_t shieldId)
julientiron	0:cba942f8172a	684	{
julientiron	1:9efe863db15e	685	SendCommand(shieldId, Easyspin_NOP);
julientiron	0:cba942f8172a	686	}
julientiron	0:cba942f8172a	687
julientiron	0:cba942f8172a	688	/****************************************************//
julientiron	0:cba942f8172a	689	* @brief Issues the SetParam command to the Easyspin of the specified shield
julientiron	0:cba942f8172a	690	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	691	* @param[in] param Register adress (Easyspin_ABS_POS, Easyspin_MARK,...)
julientiron	0:cba942f8172a	692	* @param[in] value Value to set in the register
julientiron	0:cba942f8172a	693	* @retval None
julientiron	0:cba942f8172a	694	**********************************************************/
julientiron	0:cba942f8172a	695	void Easyspin::CmdSetParam(uint8_t shieldId,
julientiron	1:9efe863db15e	696	Easyspin_Registers_t param,
julientiron	1:9efe863db15e	697	uint32_t value)
julientiron	0:cba942f8172a	698	{
julientiron	1:9efe863db15e	699	uint32_t i;
julientiron	1:9efe863db15e	700	uint8_t maxArgumentNbBytes = 0;
julientiron	1:9efe863db15e	701	uint8_t spiIndex = numberOfShields - shieldId - 1;
julientiron	1:9efe863db15e	702	bool itDisable = false;
julientiron	1:9efe863db15e	703	do {
julientiron	1:9efe863db15e	704	spiPreemtionByIsr = false;
julientiron	1:9efe863db15e	705	if (itDisable) {
julientiron	1:9efe863db15e	706	/* re-enable interrupts if disable in previous iteration */
julientiron	1:9efe863db15e	707	flag.enable_irq();//interrupts();
julientiron	1:9efe863db15e	708	itDisable = false;
julientiron	1:9efe863db15e	709	}
julientiron	1:9efe863db15e	710	for (i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	711	spiTxBursts[0][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	712	spiTxBursts[1][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	713	spiTxBursts[2][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	714	spiTxBursts[3][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	715	}
julientiron	1:9efe863db15e	716	switch (param) {
julientiron	1:9efe863db15e	717	case Easyspin_ABS_POS:
julientiron	1:9efe863db15e	718	;
julientiron	1:9efe863db15e	719	case Easyspin_MARK:
julientiron	1:9efe863db15e	720	spiTxBursts[0][spiIndex] = param;
julientiron	1:9efe863db15e	721	spiTxBursts[1][spiIndex] = (uint8_t)(value >> 16);
julientiron	1:9efe863db15e	722	spiTxBursts[2][spiIndex] = (uint8_t)(value >> 8);
julientiron	1:9efe863db15e	723	maxArgumentNbBytes = 3;
julientiron	1:9efe863db15e	724	break;
julientiron	1:9efe863db15e	725	case Easyspin_EL_POS:
julientiron	1:9efe863db15e	726	;
julientiron	1:9efe863db15e	727	case Easyspin_CONFIG:
julientiron	1:9efe863db15e	728	spiTxBursts[1][spiIndex] = param;
julientiron	1:9efe863db15e	729	spiTxBursts[2][spiIndex] = (uint8_t)(value >> 8);
julientiron	1:9efe863db15e	730	maxArgumentNbBytes = 2;
julientiron	1:9efe863db15e	731	break;
julientiron	1:9efe863db15e	732	default:
julientiron	1:9efe863db15e	733	spiTxBursts[2][spiIndex] = param;
julientiron	1:9efe863db15e	734	maxArgumentNbBytes = 1;
julientiron	1:9efe863db15e	735	}
julientiron	1:9efe863db15e	736	spiTxBursts[3][spiIndex] = (uint8_t)(value);
julientiron	1:9efe863db15e	737
julientiron	1:9efe863db15e	738	/* Disable interruption before checking */
julientiron	1:9efe863db15e	739	/* pre-emption by ISR and SPI transfers*/
julientiron	1:9efe863db15e	740	flag.disable_irq();
julientiron	1:9efe863db15e	741	itDisable = true;
julientiron	1:9efe863db15e	742	} while (spiPreemtionByIsr); // check pre-emption by ISR
julientiron	1:9efe863db15e	743
julientiron	1:9efe863db15e	744	/* SPI transfer */
julientiron	1:9efe863db15e	745	for (i = Easyspin_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
julientiron	1:9efe863db15e	746	i < Easyspin_CMD_ARG_MAX_NB_BYTES;
julientiron	1:9efe863db15e	747	i++) {
julientiron	1:9efe863db15e	748	WriteBytes(&spiTxBursts[i][0],&spiRxBursts[i][0]);
julientiron	0:cba942f8172a	749	}
julientiron	1:9efe863db15e	750	/* re-enable interrupts after SPI transfers*/
julientiron	1:9efe863db15e	751	flag.enable_irq();
julientiron	0:cba942f8172a	752	}
julientiron	0:cba942f8172a	753
julientiron	0:cba942f8172a	754	/****************************************************//
julientiron	0:cba942f8172a	755	* @brief Reads the Status Register value
julientiron	0:cba942f8172a	756	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	757	* @retval Status register valued
julientiron	1:9efe863db15e	758	* @note The status register flags are not cleared
julientiron	0:cba942f8172a	759	* at the difference with CmdGetStatus()
julientiron	0:cba942f8172a	760	**********************************************************/
julientiron	0:cba942f8172a	761	uint16_t Easyspin::ReadStatusRegister(uint8_t shieldId)
julientiron	0:cba942f8172a	762	{
julientiron	1:9efe863db15e	763	return (CmdGetParam(shieldId,Easyspin_STATUS));
julientiron	0:cba942f8172a	764	}
julientiron	0:cba942f8172a	765
julientiron	0:cba942f8172a	766	/****************************************************//
julientiron	0:cba942f8172a	767	* @brief Releases the Easyspin reset (pin set to High) of all shields
julientiron	0:cba942f8172a	768	* @param None
julientiron	0:cba942f8172a	769	* @retval None
julientiron	0:cba942f8172a	770	**********************************************************/
julientiron	0:cba942f8172a	771	void Easyspin::ReleaseReset(void)
julientiron	1:9efe863db15e	772	{
julientiron	1:9efe863db15e	773	reset = 1;
julientiron	0:cba942f8172a	774	}
julientiron	0:cba942f8172a	775
julientiron	0:cba942f8172a	776	/****************************************************//
julientiron	0:cba942f8172a	777	* @brief Resets the Easyspin (reset pin set to low) of all shields
julientiron	0:cba942f8172a	778	* @param None
julientiron	0:cba942f8172a	779	* @retval None
julientiron	0:cba942f8172a	780	**********************************************************/
julientiron	0:cba942f8172a	781	void Easyspin::Reset(void)
julientiron	0:cba942f8172a	782	{
julientiron	1:9efe863db15e	783	reset = 0;
julientiron	0:cba942f8172a	784	}
julientiron	0:cba942f8172a	785
julientiron	0:cba942f8172a	786	/****************************************************//
julientiron	1:9efe863db15e	787	* @brief Set the stepping mode
julientiron	0:cba942f8172a	788	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	789	* @param[in] stepMod from full step to 1/16 microstep as specified in enum Easyspin_STEP_SEL_t
julientiron	0:cba942f8172a	790	* @retval None
julientiron	0:cba942f8172a	791	**********************************************************/
julientiron	0:cba942f8172a	792	void Easyspin::SelectStepMode(uint8_t shieldId, Easyspin_STEP_SEL_t stepMod)
julientiron	0:cba942f8172a	793	{
julientiron	1:9efe863db15e	794	uint8_t stepModeRegister;
julientiron	1:9efe863db15e	795
julientiron	1:9efe863db15e	796	/* Eventually deactivate motor */
julientiron	1:9efe863db15e	797	if (shieldPrm[shieldId].motionState != INACTIVE) {
julientiron	1:9efe863db15e	798	HardStop(shieldId);
julientiron	1:9efe863db15e	799	}
julientiron	0:cba942f8172a	800
julientiron	1:9efe863db15e	801	/* Read Step mode register and clear STEP_SEL field */
julientiron	1:9efe863db15e	802	stepModeRegister = (uint8_t)(0xF8 & CmdGetParam(shieldId,Easyspin_STEP_MODE)) ;
julientiron	1:9efe863db15e	803
julientiron	1:9efe863db15e	804	/* Apply new step mode */
julientiron	1:9efe863db15e	805	CmdSetParam(shieldId, Easyspin_STEP_MODE, stepModeRegister \| (uint8_t)stepMod);
julientiron	1:9efe863db15e	806
julientiron	1:9efe863db15e	807	/* Reset abs pos register */
julientiron	1:9efe863db15e	808	SetHome(shieldId);
julientiron	0:cba942f8172a	809	}
julientiron	0:cba942f8172a	810
julientiron	0:cba942f8172a	811	/****************************************************//
julientiron	1:9efe863db15e	812	* @brief Specifies the direction
julientiron	0:cba942f8172a	813	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	814	* @param[in] dir FORWARD or BACKWARD
julientiron	1:9efe863db15e	815	* @note The direction change is only applied if the shield
julientiron	0:cba942f8172a	816	* is in INACTIVE state
julientiron	0:cba942f8172a	817	* @retval None
julientiron	0:cba942f8172a	818	**********************************************************/
julientiron	0:cba942f8172a	819	void Easyspin::SetDirection(uint8_t shieldId, dir_t dir)
julientiron	0:cba942f8172a	820	{
julientiron	1:9efe863db15e	821	if (shieldPrm[shieldId].motionState == INACTIVE) {
julientiron	1:9efe863db15e	822	shieldPrm[shieldId].direction = dir;
julientiron	1:9efe863db15e	823
julientiron	1:9efe863db15e	824	switch (shieldId) {
julientiron	1:9efe863db15e	825	case 2:
julientiron	1:9efe863db15e	826	dir3 = dir;
julientiron	1:9efe863db15e	827	break;
julientiron	1:9efe863db15e	828	case 1:
julientiron	1:9efe863db15e	829	dir2 = dir;
julientiron	1:9efe863db15e	830	break;
julientiron	1:9efe863db15e	831	case 0:
julientiron	1:9efe863db15e	832	dir1 = dir;
julientiron	1:9efe863db15e	833	break;
julientiron	1:9efe863db15e	834	default:
julientiron	1:9efe863db15e	835	;
julientiron	1:9efe863db15e	836	}
julientiron	0:cba942f8172a	837	}
julientiron	0:cba942f8172a	838	}
julientiron	0:cba942f8172a	839
julientiron	0:cba942f8172a	840	/****************************************************//
julientiron	0:cba942f8172a	841	* @brief Gets the pointer to the Easyspin instance
julientiron	0:cba942f8172a	842	* @param None
julientiron	0:cba942f8172a	843	* @retval Pointer to the instance of Easyspin
julientiron	0:cba942f8172a	844	**********************************************************/
julientiron	0:cba942f8172a	845	class Easyspin* Easyspin::GetInstancePtr(void)
julientiron	0:cba942f8172a	846	{
julientiron	1:9efe863db15e	847	return (class Easyspin*)instancePtr;
julientiron	0:cba942f8172a	848	}
julientiron	0:cba942f8172a	849
julientiron	0:cba942f8172a	850	/****************************************************//
julientiron	0:cba942f8172a	851	* @brief Handles the shield state machine at each ste
julientiron	0:cba942f8172a	852	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	853	* @retval None
julientiron	0:cba942f8172a	854	* @note Must only be called by the timer ISR
julientiron	0:cba942f8172a	855	**********************************************************/
julientiron	0:cba942f8172a	856	void Easyspin::StepClockHandler(uint8_t shieldId)
julientiron	0:cba942f8172a	857	{
julientiron	1:9efe863db15e	858	/* Set isr flag */
julientiron	1:9efe863db15e	859	isrFlag = true;
julientiron	1:9efe863db15e	860
julientiron	1:9efe863db15e	861	/* Incrementation of the relative position */
julientiron	1:9efe863db15e	862	shieldPrm[shieldId].relativePos++;
julientiron	1:9efe863db15e	863
julientiron	1:9efe863db15e	864	/* Periodically check that estimated position is correct */
julientiron	1:9efe863db15e	865	if ((shieldPrm[shieldId].commandExecuted != RUN_CMD) &&
julientiron	1:9efe863db15e	866	((shieldPrm[shieldId].relativePos % 10) == 00)) {
julientiron	1:9efe863db15e	867	uint32_t AbsPos= ConvertPosition(CmdGetParam(shieldId,Easyspin_ABS_POS));
julientiron	1:9efe863db15e	868
julientiron	1:9efe863db15e	869	/* Correct estimated position if needed */
julientiron	1:9efe863db15e	870	if (AbsPos != 0) {
julientiron	1:9efe863db15e	871	if ((shieldPrm[shieldId].direction == FORWARD) &&
julientiron	1:9efe863db15e	872	(AbsPos != shieldPrm[shieldId].currentPosition + shieldPrm[shieldId].relativePos)) {
julientiron	0:cba942f8172a	873	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	874	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "F EstPos:%ld RealPos: %ld\n",shieldPrm[shieldId].relativePos,(AbsPos - shieldPrm[shieldId].currentPosition));
julientiron	1:9efe863db15e	875	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	876	#endif
julientiron	1:9efe863db15e	877	shieldPrm[shieldId].relativePos = AbsPos - shieldPrm[shieldId].currentPosition;
julientiron	1:9efe863db15e	878
julientiron	1:9efe863db15e	879	} else if ((shieldPrm[shieldId].direction == BACKWARD) &&
julientiron	1:9efe863db15e	880	(AbsPos != shieldPrm[shieldId].currentPosition - shieldPrm[shieldId].relativePos)) {
julientiron	0:cba942f8172a	881	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	882	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "B EstPos:%ld RealPos: %ld\n",shieldPrm[shieldId].relativePos,(AbsPos - shieldPrm[shieldId].currentPosition));
julientiron	1:9efe863db15e	883	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	884	#endif
julientiron	1:9efe863db15e	885	shieldPrm[shieldId].relativePos = shieldPrm[shieldId].currentPosition - AbsPos;
julientiron	1:9efe863db15e	886	}
julientiron	0:cba942f8172a	887	}
julientiron	0:cba942f8172a	888	}
julientiron	1:9efe863db15e	889
julientiron	1:9efe863db15e	890	switch (shieldPrm[shieldId].motionState) {
julientiron	1:9efe863db15e	891	case ACCELERATING: {
julientiron	1:9efe863db15e	892	if ((shieldPrm[shieldId].commandExecuted == SOFT_STOP_CMD)\|\|
julientiron	1:9efe863db15e	893	((shieldPrm[shieldId].commandExecuted != RUN_CMD)&&
julientiron	1:9efe863db15e	894	(shieldPrm[shieldId].relativePos == shieldPrm[shieldId].startDecPos))) {
julientiron	1:9efe863db15e	895	shieldPrm[shieldId].motionState = DECELERATING;
julientiron	1:9efe863db15e	896	shieldPrm[shieldId].accu = 0;
julientiron	0:cba942f8172a	897	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	898	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "Acc->Dec: speed: %u relativepos: %ld \n",shieldPrm[shieldId].speed,shieldPrm[shieldId].relativePos);
julientiron	1:9efe863db15e	899	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	900	#endif
julientiron	1:9efe863db15e	901	} else if ((shieldPrm[shieldId].speed >= shieldPrm[shieldId].maxSpeed)\|\|
julientiron	1:9efe863db15e	902	((shieldPrm[shieldId].commandExecuted != RUN_CMD)&&
julientiron	1:9efe863db15e	903	(shieldPrm[shieldId].relativePos == shieldPrm[shieldId].endAccPos))) {
julientiron	1:9efe863db15e	904	shieldPrm[shieldId].motionState = STEADY;
julientiron	0:cba942f8172a	905	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	906	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "Acc->Steady: speed: %u relativepos: %ld \n",shieldPrm[shieldId].speed,shieldPrm[shieldId].relativePos);
julientiron	1:9efe863db15e	907	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	908	#endif
julientiron	1:9efe863db15e	909	} else {
julientiron	1:9efe863db15e	910	bool speedUpdated = false;
julientiron	1:9efe863db15e	911	/* Go on accelerating */
julientiron	1:9efe863db15e	912	shieldPrm[shieldId].accu += ((uint32_t)shieldPrm[shieldId].acceleration << 16) / shieldPrm[shieldId].speed;
julientiron	1:9efe863db15e	913	while (shieldPrm[shieldId].accu >= (0X10000L)) {
julientiron	1:9efe863db15e	914	shieldPrm[shieldId].accu -= (0X10000L);
julientiron	1:9efe863db15e	915	shieldPrm[shieldId].speed +=1;
julientiron	1:9efe863db15e	916	speedUpdated = true;
julientiron	1:9efe863db15e	917	}
julientiron	1:9efe863db15e	918
julientiron	1:9efe863db15e	919	if (speedUpdated) {
julientiron	1:9efe863db15e	920	ApplySpeed(shieldId, shieldPrm[shieldId].speed);
julientiron	1:9efe863db15e	921	}
julientiron	1:9efe863db15e	922	}
julientiron	1:9efe863db15e	923	break;
julientiron	1:9efe863db15e	924	}
julientiron	1:9efe863db15e	925	case STEADY: {
julientiron	1:9efe863db15e	926	if ((shieldPrm[shieldId].commandExecuted == SOFT_STOP_CMD)\|\|
julientiron	1:9efe863db15e	927	((shieldPrm[shieldId].commandExecuted != RUN_CMD)&&
julientiron	1:9efe863db15e	928	(shieldPrm[shieldId].relativePos >= (shieldPrm[shieldId].startDecPos))) \|\|
julientiron	1:9efe863db15e	929	((shieldPrm[shieldId].commandExecuted == RUN_CMD)&&
julientiron	1:9efe863db15e	930	(shieldPrm[shieldId].speed > shieldPrm[shieldId].maxSpeed))) {
julientiron	1:9efe863db15e	931	shieldPrm[shieldId].motionState = DECELERATING;
julientiron	1:9efe863db15e	932	shieldPrm[shieldId].accu = 0;
julientiron	1:9efe863db15e	933	} else if ((shieldPrm[shieldId].commandExecuted == RUN_CMD)&&
julientiron	1:9efe863db15e	934	(shieldPrm[shieldId].speed < shieldPrm[shieldId].maxSpeed)) {
julientiron	1:9efe863db15e	935	shieldPrm[shieldId].motionState = ACCELERATING;
julientiron	1:9efe863db15e	936	shieldPrm[shieldId].accu = 0;
julientiron	1:9efe863db15e	937	}
julientiron	1:9efe863db15e	938	break;
julientiron	0:cba942f8172a	939	}
julientiron	1:9efe863db15e	940	case DECELERATING: {
julientiron	1:9efe863db15e	941	if (((shieldPrm[shieldId].commandExecuted == SOFT_STOP_CMD)&&(shieldPrm[shieldId].speed <= shieldPrm[shieldId].minSpeed))\|\|
julientiron	1:9efe863db15e	942	((shieldPrm[shieldId].commandExecuted != RUN_CMD)&&
julientiron	1:9efe863db15e	943	(shieldPrm[shieldId].relativePos >= shieldPrm[shieldId].stepsToTake))) {
julientiron	1:9efe863db15e	944	/* Motion process complete */
julientiron	1:9efe863db15e	945	HardStop(shieldId);
julientiron	1:9efe863db15e	946	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	947	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "Dec->Stop: speed: %u relativepos: %ld \n",shieldPrm[shieldId].speed,shieldPrm[shieldId].relativePos );
julientiron	1:9efe863db15e	948	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	949	#endif
julientiron	1:9efe863db15e	950	} else if ((shieldPrm[shieldId].commandExecuted == RUN_CMD)&&
julientiron	1:9efe863db15e	951	(shieldPrm[shieldId].speed <= shieldPrm[shieldId].maxSpeed)) {
julientiron	1:9efe863db15e	952	shieldPrm[shieldId].motionState = STEADY;
julientiron	1:9efe863db15e	953	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	954	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "Dec->Steady: speed: %u relativepos: %ld \n",shieldPrm[shieldId].speed,shieldPrm[shieldId].relativePos);
julientiron	1:9efe863db15e	955	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	956	#endif
julientiron	1:9efe863db15e	957	} else {
julientiron	1:9efe863db15e	958	/* Go on decelerating */
julientiron	1:9efe863db15e	959	if (shieldPrm[shieldId].speed > shieldPrm[shieldId].minSpeed) {
julientiron	1:9efe863db15e	960	bool speedUpdated = false;
julientiron	1:9efe863db15e	961	shieldPrm[shieldId].accu += ((uint32_t)shieldPrm[shieldId].deceleration << 16) / shieldPrm[shieldId].speed;
julientiron	1:9efe863db15e	962	while (shieldPrm[shieldId].accu >= (0X10000L)) {
julientiron	1:9efe863db15e	963	shieldPrm[shieldId].accu -= (0X10000L);
julientiron	1:9efe863db15e	964	shieldPrm[shieldId].speed -=1;
julientiron	1:9efe863db15e	965	speedUpdated = true;
julientiron	1:9efe863db15e	966	}
julientiron	1:9efe863db15e	967	if (speedUpdated) {
julientiron	1:9efe863db15e	968	ApplySpeed(shieldId, shieldPrm[shieldId].speed);
julientiron	1:9efe863db15e	969	}
julientiron	1:9efe863db15e	970	}
julientiron	1:9efe863db15e	971	}
julientiron	1:9efe863db15e	972	break;
julientiron	1:9efe863db15e	973	}
julientiron	1:9efe863db15e	974	default: {
julientiron	1:9efe863db15e	975	break;
julientiron	1:9efe863db15e	976	}
julientiron	0:cba942f8172a	977	}
julientiron	1:9efe863db15e	978	/* Set isr flag */
julientiron	1:9efe863db15e	979	isrFlag = false;
julientiron	0:cba942f8172a	980	}
julientiron	0:cba942f8172a	981
julientiron	0:cba942f8172a	982	/****************************************************//
julientiron	0:cba942f8172a	983	* @brief Updates the current speed of the shield
julientiron	0:cba942f8172a	984	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	985	* @param[in] newSpeed in pps
julientiron	0:cba942f8172a	986	* @retval None
julientiron	0:cba942f8172a	987	**********************************************************/
julientiron	0:cba942f8172a	988	void Easyspin::ApplySpeed(uint8_t shieldId, uint16_t newSpeed)
julientiron	0:cba942f8172a	989	{
julientiron	1:9efe863db15e	990	if (newSpeed < Easyspin_MIN_PWM_FREQ) {
julientiron	1:9efe863db15e	991	newSpeed = Easyspin_MIN_PWM_FREQ;
julientiron	1:9efe863db15e	992	}
julientiron	1:9efe863db15e	993	if (newSpeed > Easyspin_MAX_PWM_FREQ) {
julientiron	1:9efe863db15e	994	newSpeed = Easyspin_MAX_PWM_FREQ;
julientiron	1:9efe863db15e	995	}
julientiron	1:9efe863db15e	996
julientiron	1:9efe863db15e	997	shieldPrm[shieldId].speed = newSpeed;
julientiron	0:cba942f8172a	998
julientiron	1:9efe863db15e	999	switch (shieldId) {
julientiron	1:9efe863db15e	1000	case 0:
julientiron	1:9efe863db15e	1001	Pwm1SetFreq(newSpeed);
julientiron	1:9efe863db15e	1002	break;
julientiron	1:9efe863db15e	1003	case 1:
julientiron	1:9efe863db15e	1004	Pwm2SetFreq(newSpeed);
julientiron	1:9efe863db15e	1005	break;
julientiron	1:9efe863db15e	1006	case 2:
julientiron	1:9efe863db15e	1007	Pwm3SetFreq(newSpeed);
julientiron	1:9efe863db15e	1008	break;
julientiron	1:9efe863db15e	1009	default:
julientiron	1:9efe863db15e	1010	break; //ignore error
julientiron	1:9efe863db15e	1011	}
julientiron	0:cba942f8172a	1012	}
julientiron	0:cba942f8172a	1013
julientiron	0:cba942f8172a	1014	/****************************************************//
julientiron	0:cba942f8172a	1015	* @brief Computes the speed profile according to the number of steps to move
julientiron	0:cba942f8172a	1016	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1017	* @param[in] nbSteps number of steps to perform
julientiron	0:cba942f8172a	1018	* @retval None
julientiron	0:cba942f8172a	1019	* @note Using the acceleration and deceleration of the shield,
julientiron	0:cba942f8172a	1020	* this function determines the duration in steps of the acceleration,
julientiron	0:cba942f8172a	1021	* steady and deceleration phases.
julientiron	0:cba942f8172a	1022	* If the total number of steps to perform is big enough, a trapezoidal move
julientiron	0:cba942f8172a	1023	* is performed (i.e. there is a steady phase where the motor runs at the maximum
julientiron	0:cba942f8172a	1024	* speed.
julientiron	0:cba942f8172a	1025	* Else, a triangular move is performed (no steady phase: the maximum speed is never
julientiron	0:cba942f8172a	1026	* reached.
julientiron	0:cba942f8172a	1027	**********************************************************/
julientiron	0:cba942f8172a	1028	void Easyspin::ComputeSpeedProfile(uint8_t shieldId, uint32_t nbSteps)
julientiron	0:cba942f8172a	1029	{
julientiron	1:9efe863db15e	1030	uint32_t reqAccSteps;
julientiron	0:cba942f8172a	1031	uint32_t reqDecSteps;
julientiron	1:9efe863db15e	1032
julientiron	1:9efe863db15e	1033	/* compute the number of steps to get the targeted speed */
julientiron	1:9efe863db15e	1034	reqAccSteps = (shieldPrm[shieldId].maxSpeed - shieldPrm[shieldId].minSpeed);
julientiron	1:9efe863db15e	1035	reqAccSteps *= (shieldPrm[shieldId].maxSpeed + shieldPrm[shieldId].minSpeed);
julientiron	1:9efe863db15e	1036	reqDecSteps = reqAccSteps;
julientiron	1:9efe863db15e	1037	reqAccSteps /= (uint32_t)shieldPrm[shieldId].acceleration;
julientiron	1:9efe863db15e	1038	reqAccSteps /= 2;
julientiron	0:cba942f8172a	1039
julientiron	1:9efe863db15e	1040	/* compute the number of steps to stop */
julientiron	1:9efe863db15e	1041	reqDecSteps /= (uint32_t)shieldPrm[shieldId].deceleration;
julientiron	1:9efe863db15e	1042	reqDecSteps /= 2;
julientiron	1:9efe863db15e	1043
julientiron	1:9efe863db15e	1044	if(( reqAccSteps + reqDecSteps ) > nbSteps) {
julientiron	1:9efe863db15e	1045	/* Triangular move */
julientiron	1:9efe863db15e	1046	/* reqDecSteps = (Pos * Dec) /(Dec+Acc) */
julientiron	0:cba942f8172a	1047
julientiron	1:9efe863db15e	1048	reqDecSteps = ((uint32_t) shieldPrm[shieldId].deceleration * nbSteps) / (shieldPrm[shieldId].acceleration + shieldPrm[shieldId].deceleration);
julientiron	1:9efe863db15e	1049	if (reqDecSteps > 1) {
julientiron	1:9efe863db15e	1050	reqAccSteps = reqDecSteps - 1;
julientiron	1:9efe863db15e	1051	if(reqAccSteps == 0) {
julientiron	1:9efe863db15e	1052	reqAccSteps = 1;
julientiron	1:9efe863db15e	1053	}
julientiron	1:9efe863db15e	1054	} else {
julientiron	1:9efe863db15e	1055	reqAccSteps = 0;
julientiron	1:9efe863db15e	1056	}
julientiron	1:9efe863db15e	1057	shieldPrm[shieldId].endAccPos = reqAccSteps;
julientiron	1:9efe863db15e	1058	shieldPrm[shieldId].startDecPos = reqDecSteps;
julientiron	1:9efe863db15e	1059	} else {
julientiron	1:9efe863db15e	1060	/* Trapezoidal move */
julientiron	1:9efe863db15e	1061	/* accelerating phase to endAccPos */
julientiron	1:9efe863db15e	1062	/* steady phase from endAccPos to startDecPos */
julientiron	1:9efe863db15e	1063	/* decelerating from startDecPos to stepsToTake*/
julientiron	1:9efe863db15e	1064	shieldPrm[shieldId].endAccPos = reqAccSteps;
julientiron	1:9efe863db15e	1065	shieldPrm[shieldId].startDecPos = nbSteps - reqDecSteps - 1;
julientiron	0:cba942f8172a	1066	}
julientiron	0:cba942f8172a	1067	}
julientiron	0:cba942f8172a	1068
julientiron	0:cba942f8172a	1069	/****************************************************//
julientiron	0:cba942f8172a	1070	* @brief Converts the ABS_POSITION register value to a 32b signed integer
julientiron	0:cba942f8172a	1071	* @param[in] abs_position_reg value of the ABS_POSITION register
julientiron	1:9efe863db15e	1072	* @retval operation_result 32b signed integer corresponding to the absolute position
julientiron	0:cba942f8172a	1073	**********************************************************/
julientiron	0:cba942f8172a	1074	int32_t Easyspin::ConvertPosition(uint32_t abs_position_reg)
julientiron	0:cba942f8172a	1075	{
julientiron	0:cba942f8172a	1076	int32_t operation_result;
julientiron	0:cba942f8172a	1077
julientiron	1:9efe863db15e	1078	if (abs_position_reg & Easyspin_ABS_POS_SIGN_BIT_MASK) {
julientiron	0:cba942f8172a	1079	/* Negative register value */
julientiron	0:cba942f8172a	1080	abs_position_reg = ~abs_position_reg;
julientiron	0:cba942f8172a	1081	abs_position_reg += 1;
julientiron	0:cba942f8172a	1082
julientiron	0:cba942f8172a	1083	operation_result = (int32_t) (abs_position_reg & Easyspin_ABS_POS_VALUE_MASK);
julientiron	0:cba942f8172a	1084	operation_result = -operation_result;
julientiron	1:9efe863db15e	1085	} else {
julientiron	0:cba942f8172a	1086	operation_result = (int32_t) abs_position_reg;
julientiron	0:cba942f8172a	1087	}
julientiron	0:cba942f8172a	1088	return operation_result;
julientiron	0:cba942f8172a	1089	}
julientiron	0:cba942f8172a	1090
julientiron	0:cba942f8172a	1091	/****************************************************//
julientiron	0:cba942f8172a	1092	* @brief Handlers of the flag interrupt which calls the user callback (if defined)
julientiron	0:cba942f8172a	1093	* @param None
julientiron	0:cba942f8172a	1094	* @retval None
julientiron	0:cba942f8172a	1095	**********************************************************/
julientiron	0:cba942f8172a	1096	void Easyspin::FlagInterruptHandler(void)
julientiron	0:cba942f8172a	1097	{
julientiron	1:9efe863db15e	1098	if (flagInterruptCallback != NULL) {
julientiron	1:9efe863db15e	1099	/* Set isr flag */
julientiron	1:9efe863db15e	1100	isrFlag = true;
julientiron	1:9efe863db15e	1101
julientiron	1:9efe863db15e	1102	flagInterruptCallback();
julientiron	1:9efe863db15e	1103
julientiron	1:9efe863db15e	1104	/* Reset isr flag */
julientiron	1:9efe863db15e	1105	isrFlag = false;
julientiron	1:9efe863db15e	1106	}
julientiron	0:cba942f8172a	1107	}
julientiron	0:cba942f8172a	1108
julientiron	0:cba942f8172a	1109	/****************************************************//
julientiron	0:cba942f8172a	1110	* @brief Sends a command without arguments to the Easyspin via the SPI
julientiron	0:cba942f8172a	1111	* @param[in] shieldId (from 0 to 2)
julientiron	1:9efe863db15e	1112	* @param[in] param Command to send
julientiron	0:cba942f8172a	1113	* @retval None
julientiron	0:cba942f8172a	1114	**********************************************************/
julientiron	0:cba942f8172a	1115	void Easyspin::SendCommand(uint8_t shieldId, uint8_t param)
julientiron	0:cba942f8172a	1116	{
julientiron	1:9efe863db15e	1117	uint8_t spiIndex = numberOfShields - shieldId - 1;
julientiron	1:9efe863db15e	1118	bool itDisable = false;
julientiron	1:9efe863db15e	1119
julientiron	1:9efe863db15e	1120	do {
julientiron	1:9efe863db15e	1121	spiPreemtionByIsr = false;
julientiron	1:9efe863db15e	1122	if (itDisable) {
julientiron	1:9efe863db15e	1123	/* re-enable interrupts if disable in previous iteration */
julientiron	1:9efe863db15e	1124	flag.enable_irq();
julientiron	1:9efe863db15e	1125	itDisable = false;
julientiron	1:9efe863db15e	1126	}
julientiron	0:cba942f8172a	1127
julientiron	1:9efe863db15e	1128	for (uint32_t i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	1129	spiTxBursts[3][i] = Easyspin_NOP;
julientiron	1:9efe863db15e	1130	}
julientiron	1:9efe863db15e	1131	spiTxBursts[3][spiIndex] = param;
julientiron	1:9efe863db15e	1132
julientiron	1:9efe863db15e	1133	/* Disable interruption before checking */
julientiron	1:9efe863db15e	1134	/* pre-emption by ISR and SPI transfers*/
julientiron	1:9efe863db15e	1135	flag.disable_irq();
julientiron	1:9efe863db15e	1136	itDisable = true;
julientiron	1:9efe863db15e	1137	} while (spiPreemtionByIsr); // check pre-emption by ISR
julientiron	1:9efe863db15e	1138
julientiron	1:9efe863db15e	1139	WriteBytes(&spiTxBursts[3][0], &spiRxBursts[3][0]);
julientiron	1:9efe863db15e	1140
julientiron	1:9efe863db15e	1141	/* re-enable interrupts after SPI transfers*/
julientiron	1:9efe863db15e	1142	flag.enable_irq();
julientiron	0:cba942f8172a	1143	}
julientiron	0:cba942f8172a	1144
julientiron	0:cba942f8172a	1145	/****************************************************//
julientiron	1:9efe863db15e	1146	* @brief Sets the registers of the Easyspin to their predefined values
julientiron	0:cba942f8172a	1147	* from Easyspin_target_config.h
julientiron	0:cba942f8172a	1148	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1149	* @retval None
julientiron	0:cba942f8172a	1150	**********************************************************/
julientiron	0:cba942f8172a	1151	void Easyspin::SetRegisterToPredefinedValues(uint8_t shieldId)
julientiron	0:cba942f8172a	1152	{
julientiron	1:9efe863db15e	1153	CmdSetParam(shieldId,
julientiron	1:9efe863db15e	1154	Easyspin_ABS_POS,
julientiron	1:9efe863db15e	1155	0);
julientiron	1:9efe863db15e	1156	CmdSetParam(shieldId,
julientiron	1:9efe863db15e	1157	Easyspin_EL_POS,
julientiron	1:9efe863db15e	1158	0);
julientiron	1:9efe863db15e	1159	CmdSetParam(shieldId,
julientiron	1:9efe863db15e	1160	Easyspin_MARK,
julientiron	1:9efe863db15e	1161	0);
julientiron	1:9efe863db15e	1162	switch (shieldId) {
julientiron	1:9efe863db15e	1163	case 0:
julientiron	1:9efe863db15e	1164	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1165	Easyspin_TVAL,
julientiron	0:cba942f8172a	1166	Tval_Current_to_Par(Easyspin_CONF_PARAM_TVAL_SHIELD_0));
julientiron	1:9efe863db15e	1167	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1168	Easyspin_T_FAST,
julientiron	0:cba942f8172a	1169	(uint8_t)Easyspin_CONF_PARAM_TOFF_FAST_SHIELD_0 \|
julientiron	0:cba942f8172a	1170	(uint8_t)Easyspin_CONF_PARAM_FAST_STEP_SHIELD_0);
julientiron	1:9efe863db15e	1171	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1172	Easyspin_TON_MIN,
julientiron	0:cba942f8172a	1173	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TON_MIN_SHIELD_0));
julientiron	1:9efe863db15e	1174	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1175	Easyspin_TOFF_MIN,
julientiron	0:cba942f8172a	1176	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TOFF_MIN_SHIELD_0));
julientiron	1:9efe863db15e	1177	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1178	Easyspin_OCD_TH,
julientiron	0:cba942f8172a	1179	Easyspin_CONF_PARAM_OCD_TH_SHIELD_0);
julientiron	1:9efe863db15e	1180	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1181	Easyspin_STEP_MODE,
julientiron	0:cba942f8172a	1182	(uint8_t)Easyspin_CONF_PARAM_STEP_SEL_SHIELD_0 \|
julientiron	0:cba942f8172a	1183	(uint8_t)Easyspin_CONF_PARAM_SYNC_SEL_SHIELD_0);
julientiron	1:9efe863db15e	1184	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1185	Easyspin_ALARM_EN,
julientiron	0:cba942f8172a	1186	Easyspin_CONF_PARAM_ALARM_EN_SHIELD_0);
julientiron	1:9efe863db15e	1187	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1188	Easyspin_CONFIG,
julientiron	0:cba942f8172a	1189	(uint16_t)Easyspin_CONF_PARAM_CLOCK_SETTING_SHIELD_0 \|
julientiron	0:cba942f8172a	1190	(uint16_t)Easyspin_CONF_PARAM_TQ_REG_SHIELD_0 \|
julientiron	0:cba942f8172a	1191	(uint16_t)Easyspin_CONF_PARAM_OC_SD_SHIELD_0 \|
julientiron	0:cba942f8172a	1192	(uint16_t)Easyspin_CONF_PARAM_SR_SHIELD_0 \|
julientiron	0:cba942f8172a	1193	(uint16_t)Easyspin_CONF_PARAM_TOFF_SHIELD_0);
julientiron	1:9efe863db15e	1194	break;
julientiron	1:9efe863db15e	1195	case 1:
julientiron	1:9efe863db15e	1196	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1197	Easyspin_TVAL,
julientiron	0:cba942f8172a	1198	Tval_Current_to_Par(Easyspin_CONF_PARAM_TVAL_SHIELD_1));
julientiron	1:9efe863db15e	1199	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1200	Easyspin_T_FAST,
julientiron	0:cba942f8172a	1201	(uint8_t)Easyspin_CONF_PARAM_TOFF_FAST_SHIELD_1 \|
julientiron	0:cba942f8172a	1202	(uint8_t)Easyspin_CONF_PARAM_FAST_STEP_SHIELD_1);
julientiron	1:9efe863db15e	1203	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1204	Easyspin_TON_MIN,
julientiron	0:cba942f8172a	1205	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TON_MIN_SHIELD_1));
julientiron	1:9efe863db15e	1206	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1207	Easyspin_TOFF_MIN,
julientiron	0:cba942f8172a	1208	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TOFF_MIN_SHIELD_1));
julientiron	1:9efe863db15e	1209	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1210	Easyspin_OCD_TH,
julientiron	0:cba942f8172a	1211	Easyspin_CONF_PARAM_OCD_TH_SHIELD_1);
julientiron	1:9efe863db15e	1212	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1213	Easyspin_STEP_MODE,
julientiron	0:cba942f8172a	1214	(uint8_t)Easyspin_CONF_PARAM_STEP_SEL_SHIELD_1 \|
julientiron	0:cba942f8172a	1215	(uint8_t)Easyspin_CONF_PARAM_SYNC_SEL_SHIELD_1);
julientiron	1:9efe863db15e	1216	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1217	Easyspin_ALARM_EN,
julientiron	0:cba942f8172a	1218	Easyspin_CONF_PARAM_ALARM_EN_SHIELD_1);
julientiron	1:9efe863db15e	1219	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1220	Easyspin_CONFIG,
julientiron	0:cba942f8172a	1221	(uint16_t)Easyspin_CONF_PARAM_CLOCK_SETTING_SHIELD_1 \|
julientiron	0:cba942f8172a	1222	(uint16_t)Easyspin_CONF_PARAM_TQ_REG_SHIELD_1 \|
julientiron	0:cba942f8172a	1223	(uint16_t)Easyspin_CONF_PARAM_OC_SD_SHIELD_1 \|
julientiron	0:cba942f8172a	1224	(uint16_t)Easyspin_CONF_PARAM_SR_SHIELD_1 \|
julientiron	0:cba942f8172a	1225	(uint16_t)Easyspin_CONF_PARAM_TOFF_SHIELD_1);
julientiron	1:9efe863db15e	1226	break;
julientiron	1:9efe863db15e	1227	case 2:
julientiron	1:9efe863db15e	1228	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1229	Easyspin_TVAL,
julientiron	0:cba942f8172a	1230	Tval_Current_to_Par(Easyspin_CONF_PARAM_TVAL_SHIELD_2));
julientiron	1:9efe863db15e	1231	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1232	Easyspin_T_FAST,
julientiron	0:cba942f8172a	1233	(uint8_t)Easyspin_CONF_PARAM_TOFF_FAST_SHIELD_2 \|
julientiron	0:cba942f8172a	1234	(uint8_t)Easyspin_CONF_PARAM_FAST_STEP_SHIELD_2);
julientiron	1:9efe863db15e	1235	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1236	Easyspin_TON_MIN,
julientiron	0:cba942f8172a	1237	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TON_MIN_SHIELD_2));
julientiron	1:9efe863db15e	1238	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1239	Easyspin_TOFF_MIN,
julientiron	0:cba942f8172a	1240	Tmin_Time_to_Par(Easyspin_CONF_PARAM_TOFF_MIN_SHIELD_2));
julientiron	1:9efe863db15e	1241	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1242	Easyspin_OCD_TH,
julientiron	0:cba942f8172a	1243	Easyspin_CONF_PARAM_OCD_TH_SHIELD_2);
julientiron	1:9efe863db15e	1244	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1245	Easyspin_STEP_MODE,
julientiron	0:cba942f8172a	1246	(uint8_t)Easyspin_CONF_PARAM_STEP_SEL_SHIELD_2 \|
julientiron	0:cba942f8172a	1247	(uint8_t)Easyspin_CONF_PARAM_SYNC_SEL_SHIELD_2);
julientiron	1:9efe863db15e	1248	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1249	Easyspin_ALARM_EN,
julientiron	0:cba942f8172a	1250	Easyspin_CONF_PARAM_ALARM_EN_SHIELD_2);
julientiron	1:9efe863db15e	1251	CmdSetParam(shieldId,
julientiron	0:cba942f8172a	1252	Easyspin_CONFIG,
julientiron	0:cba942f8172a	1253	(uint16_t)Easyspin_CONF_PARAM_CLOCK_SETTING_SHIELD_2 \|
julientiron	0:cba942f8172a	1254	(uint16_t)Easyspin_CONF_PARAM_TQ_REG_SHIELD_2 \|
julientiron	0:cba942f8172a	1255	(uint16_t)Easyspin_CONF_PARAM_OC_SD_SHIELD_2 \|
julientiron	0:cba942f8172a	1256	(uint16_t)Easyspin_CONF_PARAM_SR_SHIELD_2 \|
julientiron	0:cba942f8172a	1257	(uint16_t)Easyspin_CONF_PARAM_TOFF_SHIELD_2);
julientiron	1:9efe863db15e	1258	break;
julientiron	1:9efe863db15e	1259	default:
julientiron	1:9efe863db15e	1260	;
julientiron	1:9efe863db15e	1261	}
julientiron	0:cba942f8172a	1262	}
julientiron	0:cba942f8172a	1263
julientiron	0:cba942f8172a	1264	/****************************************************//
julientiron	1:9efe863db15e	1265	* @brief Sets the registers of the Easyspin to their predefined values
julientiron	0:cba942f8172a	1266	* from Easyspin_target_config.h
julientiron	0:cba942f8172a	1267	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1268	* @retval None
julientiron	0:cba942f8172a	1269	**********************************************************/
julientiron	0:cba942f8172a	1270	void Easyspin::WriteBytes(uint8_t pByteToTransmit, uint8_t pReceivedByte)
julientiron	0:cba942f8172a	1271	{
julientiron	1:9efe863db15e	1272	CS = 0;
julientiron	1:9efe863db15e	1273	for (uint32_t i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	1274	pReceivedByte = spi.write(pByteToTransmit);
julientiron	1:9efe863db15e	1275	pByteToTransmit++;
julientiron	1:9efe863db15e	1276	pReceivedByte++;
julientiron	1:9efe863db15e	1277	}
julientiron	1:9efe863db15e	1278	CS = 1;
julientiron	1:9efe863db15e	1279	if (isrFlag) {
julientiron	1:9efe863db15e	1280	spiPreemtionByIsr = true;
julientiron	1:9efe863db15e	1281	}
julientiron	0:cba942f8172a	1282	}
julientiron	0:cba942f8172a	1283
julientiron	0:cba942f8172a	1284	/****************************************************//
julientiron	0:cba942f8172a	1285	* @brief Initialises the PWM uses by the specified shield
julientiron	0:cba942f8172a	1286	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1287	* @retval None
julientiron	1:9efe863db15e	1288	* @note Shield 0 uses PW1 based on timer 1
julientiron	0:cba942f8172a	1289	* Shield 1 uses PWM 2 based on timer 2
julientiron	0:cba942f8172a	1290	* Shield 2 uses PWM3 based timer 0
julientiron	0:cba942f8172a	1291	**********************************************************/
julientiron	0:cba942f8172a	1292	void Easyspin::PwmInit(uint8_t shieldId)
julientiron	0:cba942f8172a	1293	{
julientiron	1:9efe863db15e	1294	switch (shieldId) {
julientiron	1:9efe863db15e	1295	case 0:
julientiron	1:9efe863db15e	1296	/* PWM1 uses timer 1 */
julientiron	1:9efe863db15e	1297	/* Initialise timer by setting waveform generation mode
julientiron	1:9efe863db15e	1298	to PWM phase and Frequency correct: mode = 8
julientiron	1:9efe863db15e	1299	(WGM10 = 0, WGM11 = 0, WGM12 = 0, WGM13 = 1) */
julientiron	1:9efe863db15e	1300
julientiron	1:9efe863db15e	1301	/* Stop timer1 by clearing CSS bits and set WGM13 and WGM12 */
julientiron	1:9efe863db15e	1302	//TCCR1B = 0x10;
julientiron	1:9efe863db15e	1303
julientiron	1:9efe863db15e	1304	/* Set WGM10 and WGM11 */
julientiron	1:9efe863db15e	1305	//TCCR1A = 0x00;
julientiron	1:9efe863db15e	1306
julientiron	1:9efe863db15e	1307	/* Disable Timer1 interrupt */
julientiron	1:9efe863db15e	1308	//TIMSK1 = 0;
julientiron	1:9efe863db15e	1309	//pwm1.period_us(400);
julientiron	1:9efe863db15e	1310	//pwm1.pulsewidth_us(200);
julientiron	1:9efe863db15e	1311
julientiron	1:9efe863db15e	1312	break;
julientiron	1:9efe863db15e	1313	case 1:
julientiron	1:9efe863db15e	1314	/* PWM2 uses timer 2 */
julientiron	1:9efe863db15e	1315	/* Initialise timer by setting waveform generation mode
julientiron	1:9efe863db15e	1316	to PWM phase correct: mode = 5
julientiron	1:9efe863db15e	1317	(WGM0 = 1, WGM21 = 0, WGM22 = 1) */
julientiron	1:9efe863db15e	1318
julientiron	1:9efe863db15e	1319	/* Stop timer2 by clearing CSS bits and set WGM22 */
julientiron	1:9efe863db15e	1320	//TCCR2B = 0x08;
julientiron	1:9efe863db15e	1321
julientiron	1:9efe863db15e	1322	/* Set WGM20 and WGM21 */
julientiron	1:9efe863db15e	1323	//TCCR2A = 0x01;
julientiron	1:9efe863db15e	1324
julientiron	1:9efe863db15e	1325	/* Disable Timer2 interrupt */
julientiron	1:9efe863db15e	1326	//TIMSK2 = 0;
julientiron	1:9efe863db15e	1327	//pwm2.period_us(500);
julientiron	1:9efe863db15e	1328	//pwm2.pulsewidth_us(100);
julientiron	1:9efe863db15e	1329	break;
julientiron	0:cba942f8172a	1330
julientiron	0:cba942f8172a	1331
julientiron	1:9efe863db15e	1332	case 2:
julientiron	1:9efe863db15e	1333	/* PWM3 uses timer 0 */
julientiron	1:9efe863db15e	1334	/* !!!!! Caution: Calling this configuration will break */
julientiron	1:9efe863db15e	1335	/* all default Arduino's timing functions as delay(),millis()... */
julientiron	1:9efe863db15e	1336
julientiron	1:9efe863db15e	1337	/* Initialise timer by setting waveform generation mode
julientiron	1:9efe863db15e	1338	to PWM phase correct: mode = 5
julientiron	1:9efe863db15e	1339	(WGM0 = 1, WGM21 = 0, WGM22 = 1) */
julientiron	1:9efe863db15e	1340
julientiron	1:9efe863db15e	1341	/* Stop timer0 by clearing CSS bits and set WGM22 */
julientiron	1:9efe863db15e	1342	//TCCR0B = 0x08;
julientiron	1:9efe863db15e	1343
julientiron	1:9efe863db15e	1344	/* Set WGM00 and WGM01 */
julientiron	1:9efe863db15e	1345	//TCCR0A = 0x01;
julientiron	1:9efe863db15e	1346
julientiron	1:9efe863db15e	1347	/* Disable Timer0 interrupt */
julientiron	1:9efe863db15e	1348	//TIMSK0 = 0;
julientiron	1:9efe863db15e	1349	//pwm3.period_ms(10);
julientiron	1:9efe863db15e	1350	//pwm3.pulsewidth_ms(1);
julientiron	1:9efe863db15e	1351	break;
julientiron	1:9efe863db15e	1352	default:
julientiron	1:9efe863db15e	1353	break;//ignore error
julientiron	1:9efe863db15e	1354	}
julientiron	1:9efe863db15e	1355	}
julientiron	1:9efe863db15e	1356
julientiron	1:9efe863db15e	1357	/****************************************************//
julientiron	1:9efe863db15e	1358	* @brief Ticker1
julientiron	1:9efe863db15e	1359	* @param[in]
julientiron	1:9efe863db15e	1360	* @retval
julientiron	1:9efe863db15e	1361	**********************************************************/
julientiron	1:9efe863db15e	1362	void Easyspin::tick1()
julientiron	1:9efe863db15e	1363	{
julientiron	1:9efe863db15e	1364	class Easyspin* instancePtr = Easyspin::GetInstancePtr();
julientiron	1:9efe863db15e	1365	pwm1 = !pwm1;
julientiron	1:9efe863db15e	1366	if (instancePtr != NULL) {
julientiron	1:9efe863db15e	1367	if (instancePtr->GetShieldState(0) != INACTIVE) {
julientiron	1:9efe863db15e	1368	instancePtr->StepClockHandler(0);
julientiron	1:9efe863db15e	1369	}
julientiron	1:9efe863db15e	1370	}
julientiron	1:9efe863db15e	1371	}
julientiron	1:9efe863db15e	1372
julientiron	1:9efe863db15e	1373	/****************************************************//
julientiron	1:9efe863db15e	1374	* @brief Ticker2
julientiron	1:9efe863db15e	1375	* @param[in]
julientiron	1:9efe863db15e	1376	* @retval
julientiron	1:9efe863db15e	1377	**********************************************************/
julientiron	1:9efe863db15e	1378	void Easyspin::tick2()
julientiron	1:9efe863db15e	1379	{
julientiron	1:9efe863db15e	1380	class Easyspin* instancePtr = Easyspin::GetInstancePtr();
julientiron	1:9efe863db15e	1381	pwm2 = !pwm2;
julientiron	1:9efe863db15e	1382	if (instancePtr != NULL) {
julientiron	1:9efe863db15e	1383	if (instancePtr->GetShieldState(1) != INACTIVE) {
julientiron	1:9efe863db15e	1384	instancePtr->StepClockHandler(1);
julientiron	1:9efe863db15e	1385	}
julientiron	1:9efe863db15e	1386	}
julientiron	0:cba942f8172a	1387	}
julientiron	0:cba942f8172a	1388
julientiron	0:cba942f8172a	1389	/****************************************************//
julientiron	0:cba942f8172a	1390	* @brief Sets the frequency of PWM1 used by shield 0
julientiron	0:cba942f8172a	1391	* @param[in] newFreq in Hz
julientiron	0:cba942f8172a	1392	* @retval None
julientiron	0:cba942f8172a	1393	* @note The frequency is directly the current speed of the shield
julientiron	0:cba942f8172a	1394	**********************************************************/
julientiron	0:cba942f8172a	1395	void Easyspin::Pwm1SetFreq(uint16_t newFreq)
julientiron	0:cba942f8172a	1396	{
julientiron	1:9efe863db15e	1397	uint16_t us;
julientiron	1:9efe863db15e	1398	us = (1000000 / (newFreq * 2));
julientiron	1:9efe863db15e	1399	ticker1.attach_us(this, &Easyspin::tick1, us);
julientiron	0:cba942f8172a	1400	}
julientiron	0:cba942f8172a	1401
julientiron	0:cba942f8172a	1402	/****************************************************//
julientiron	0:cba942f8172a	1403	* @brief Sets the frequency of PWM2 used by shield 1
julientiron	0:cba942f8172a	1404	* @param[in] newFreq in Hz
julientiron	0:cba942f8172a	1405	* @retval None
julientiron	0:cba942f8172a	1406	* @note The frequency is directly the current speed of the shield
julientiron	0:cba942f8172a	1407	**********************************************************/
julientiron	0:cba942f8172a	1408	void Easyspin::Pwm2SetFreq(uint16_t newFreq)
julientiron	0:cba942f8172a	1409	{
julientiron	1:9efe863db15e	1410	uint16_t us;
julientiron	1:9efe863db15e	1411	us = (1000000 / (newFreq * 2));
julientiron	1:9efe863db15e	1412	ticker2.attach_us(this, &Easyspin::tick2, us);
julientiron	0:cba942f8172a	1413	}
julientiron	0:cba942f8172a	1414
julientiron	0:cba942f8172a	1415	/****************************************************//
julientiron	0:cba942f8172a	1416	* @brief Sets the frequency of PWM3 used by shield 2
julientiron	0:cba942f8172a	1417	* @param[in] newFreq in Hz
julientiron	0:cba942f8172a	1418	* @retval None
julientiron	0:cba942f8172a	1419	* @note The frequency is directly the current speed of the shield
julientiron	0:cba942f8172a	1420	**********************************************************/
julientiron	0:cba942f8172a	1421	void Easyspin::Pwm3SetFreq(uint16_t newFreq)
julientiron	0:cba942f8172a	1422	{
julientiron	1:9efe863db15e	1423
julientiron	0:cba942f8172a	1424	}
julientiron	0:cba942f8172a	1425
julientiron	0:cba942f8172a	1426	/****************************************************//
julientiron	0:cba942f8172a	1427	* @brief Stops the PWM uses by the specified shield
julientiron	0:cba942f8172a	1428	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1429	* @retval None
julientiron	0:cba942f8172a	1430	**********************************************************/
julientiron	0:cba942f8172a	1431	void Easyspin::PwmStop(uint8_t shieldId)
julientiron	0:cba942f8172a	1432	{
julientiron	1:9efe863db15e	1433	switch (shieldId) {
julientiron	1:9efe863db15e	1434	case 0:
julientiron	1:9efe863db15e	1435	ticker1.detach();
julientiron	1:9efe863db15e	1436	break;
julientiron	1:9efe863db15e	1437	case 1:
julientiron	1:9efe863db15e	1438	ticker2.detach();
julientiron	1:9efe863db15e	1439	break;
julientiron	1:9efe863db15e	1440	case 2:
julientiron	1:9efe863db15e	1441	ticker3.detach();
julientiron	1:9efe863db15e	1442	break;
julientiron	1:9efe863db15e	1443	default:
julientiron	1:9efe863db15e	1444	break;//ignore error
julientiron	1:9efe863db15e	1445	}
julientiron	0:cba942f8172a	1446	}
julientiron	0:cba942f8172a	1447
julientiron	0:cba942f8172a	1448	/****************************************************//
julientiron	0:cba942f8172a	1449	* @brief Sets the parameters of the shield to predefined values
julientiron	0:cba942f8172a	1450	* from Easyspin_target_config.h
julientiron	0:cba942f8172a	1451	* @param None
julientiron	0:cba942f8172a	1452	* @retval None
julientiron	0:cba942f8172a	1453	**********************************************************/
julientiron	0:cba942f8172a	1454	void Easyspin::SetShieldParamsToPredefinedValues(void)
julientiron	0:cba942f8172a	1455	{
julientiron	1:9efe863db15e	1456	shieldPrm[0].acceleration = Easyspin_CONF_PARAM_ACC_SHIELD_0;
julientiron	1:9efe863db15e	1457	shieldPrm[0].deceleration = Easyspin_CONF_PARAM_DEC_SHIELD_0;
julientiron	1:9efe863db15e	1458	shieldPrm[0].maxSpeed = Easyspin_CONF_PARAM_MAX_SPEED_SHIELD_0;
julientiron	1:9efe863db15e	1459	shieldPrm[0].minSpeed = Easyspin_CONF_PARAM_MIN_SPEED_SHIELD_0;
julientiron	1:9efe863db15e	1460
julientiron	1:9efe863db15e	1461	shieldPrm[1].acceleration = Easyspin_CONF_PARAM_ACC_SHIELD_1;
julientiron	1:9efe863db15e	1462	shieldPrm[1].deceleration = Easyspin_CONF_PARAM_DEC_SHIELD_1;
julientiron	1:9efe863db15e	1463	shieldPrm[1].maxSpeed = Easyspin_CONF_PARAM_MAX_SPEED_SHIELD_1;
julientiron	1:9efe863db15e	1464	shieldPrm[1].minSpeed = Easyspin_CONF_PARAM_MIN_SPEED_SHIELD_1;
julientiron	1:9efe863db15e	1465
julientiron	1:9efe863db15e	1466	shieldPrm[2].acceleration = Easyspin_CONF_PARAM_ACC_SHIELD_2;
julientiron	1:9efe863db15e	1467	shieldPrm[2].deceleration = Easyspin_CONF_PARAM_DEC_SHIELD_2;
julientiron	1:9efe863db15e	1468	shieldPrm[2].maxSpeed = Easyspin_CONF_PARAM_MAX_SPEED_SHIELD_2;
julientiron	1:9efe863db15e	1469	shieldPrm[2].minSpeed = Easyspin_CONF_PARAM_MIN_SPEED_SHIELD_2;
julientiron	1:9efe863db15e	1470
julientiron	1:9efe863db15e	1471	for (uint8_t i = 0; i < numberOfShields; i++) {
julientiron	1:9efe863db15e	1472	SetRegisterToPredefinedValues(i);
julientiron	1:9efe863db15e	1473	}
julientiron	0:cba942f8172a	1474	}
julientiron	0:cba942f8172a	1475
julientiron	0:cba942f8172a	1476	/****************************************************//
julientiron	0:cba942f8172a	1477	* @brief Initialises the bridge parameters to start the movement
julientiron	0:cba942f8172a	1478	* and enable the power bridge
julientiron	0:cba942f8172a	1479	* @param[in] shieldId (from 0 to 2)
julientiron	0:cba942f8172a	1480	* @retval None
julientiron	0:cba942f8172a	1481	**********************************************************/
julientiron	1:9efe863db15e	1482	void Easyspin::StartMovement(uint8_t shieldId)
julientiron	0:cba942f8172a	1483	{
julientiron	1:9efe863db15e	1484	/* Enable Easyspin powerstage */
julientiron	1:9efe863db15e	1485	CmdEnable(shieldId);
julientiron	0:cba942f8172a	1486
julientiron	1:9efe863db15e	1487	if (shieldPrm[shieldId].endAccPos != 0) {
julientiron	1:9efe863db15e	1488	shieldPrm[shieldId].motionState = ACCELERATING;;
julientiron	1:9efe863db15e	1489	} else {
julientiron	1:9efe863db15e	1490	shieldPrm[shieldId].motionState = DECELERATING;
julientiron	1:9efe863db15e	1491	}
julientiron	0:cba942f8172a	1492
julientiron	1:9efe863db15e	1493	shieldPrm[shieldId].accu = 0;
julientiron	1:9efe863db15e	1494	shieldPrm[shieldId].relativePos = 0;
julientiron	1:9efe863db15e	1495	ApplySpeed(shieldId, shieldPrm[shieldId].minSpeed);
julientiron	0:cba942f8172a	1496	#ifdef _DEBUG_Easyspin
julientiron	1:9efe863db15e	1497	snprintf(EasyspinStrOut, DEBUG_BUFFER_SIZE, "Stop->Acc: speed: %u relPos: %ld\n", shieldPrm[shieldId].minSpeed, shieldPrm[shieldId].relativePos) ;
julientiron	1:9efe863db15e	1498	Serial.println(EasyspinStrOut);
julientiron	1:9efe863db15e	1499	#endif
julientiron	0:cba942f8172a	1500	}
julientiron	0:cba942f8172a	1501
julientiron	0:cba942f8172a	1502	/****************************************************//
julientiron	1:9efe863db15e	1503	* @brief Converts mA in compatible values for TVAL register
julientiron	0:cba942f8172a	1504	* @param[in] Tval
julientiron	0:cba942f8172a	1505	* @retval TVAL values
julientiron	0:cba942f8172a	1506	**********************************************************/
julientiron	0:cba942f8172a	1507	inline uint8_t Easyspin::Tval_Current_to_Par(double Tval)
julientiron	0:cba942f8172a	1508	{
julientiron	1:9efe863db15e	1509	return ((uint8_t)(((Tval - 31.25)/31.25)+0.5));
julientiron	0:cba942f8172a	1510	}
julientiron	0:cba942f8172a	1511
julientiron	0:cba942f8172a	1512	/****************************************************//
julientiron	1:9efe863db15e	1513	* @brief Convert time in us in compatible values
julientiron	0:cba942f8172a	1514	* for TON_MIN register
julientiron	0:cba942f8172a	1515	* @param[in] Tmin
julientiron	0:cba942f8172a	1516	* @retval TON_MIN values
julientiron	0:cba942f8172a	1517	**********************************************************/
julientiron	0:cba942f8172a	1518	inline uint8_t Easyspin::Tmin_Time_to_Par(double Tmin)
julientiron	0:cba942f8172a	1519	{
julientiron	1:9efe863db15e	1520	return ((uint8_t)(((Tmin - 0.5)*2)+0.5));
julientiron	0:cba942f8172a	1521	}

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	26 Aug 2015
Imports:	4
Forks:	0
Commits:	2
Dependents:	0
Dependencies:	0
Followers:	10

easyspin.cpp@1:9efe863db15e, 2015-08-26 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning