ST Expansion SW Team
/
X_NUCLEO_IHM14A1
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: ST_INTERFACES
Dependents: HelloWorld_IHM14A1
Fork of
X_NUCLEO_IHM14A1
by 
Davide Aliprandi
Diff: Components/STSPIN820/STSPIN820.cpp
- Revision:
- 2:4fd08b67958c
- Parent:
- 1:bc265521eb00
--- a/Components/STSPIN820/STSPIN820.cpp Fri Apr 27 17:02:08 2018 +0000
+++ b/Components/STSPIN820/STSPIN820.cpp Thu Sep 27 14:05:44 2018 +0000
@@ -1,40 +1,40 @@
/**
- ******************************************************************************
- * @file STSPIN820.cpp
- * @author STM
- * @version V1.0.0
- * @date August 7th, 2017
- * @brief STSPIN820 driver (fully integrated microstepping motor driver)
- * @note (C) COPYRIGHT 2017 STMicroelectronics
- ******************************************************************************
- * @attention
- *
- * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * 3. Neither the name of STMicroelectronics nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************
- */
+ *******************************************************************************
+ * @file STSPIN820.cpp
+ * @author STM
+ * @version V1.0.0
+ * @date August 7th, 2017
+ * @brief STSPIN820 driver (fully integrated microstepping motor driver).
+ * @note (C) COPYRIGHT 2017 STMicroelectronics
+ *******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *******************************************************************************
+ */
/* Generated with STM32CubeTOO -----------------------------------------------*/
@@ -53,6 +53,13 @@
#include "STSPIN820.h"
+
+/* Variables ----------------------------------------------------------------*/
+
+/* Number of devices. */
+uint8_t STSPIN820::number_of_devices = 0;
+
+
/* Private function prototypes -----------------------------------------------*/
/** @defgroup STSPIN820_Private_Functions STSPIN820 Private Functions
@@ -68,33 +75,22 @@
* @{
*/
-/******************************************************//**
- * @brief Return motor handle (pointer to the STSPIN820 motor driver structure)
- * @retval Pointer to the MOTOR_vt_t structure
+/**********************************************************
+ * @brief Starts the STSPIN820 library
+ * @param init Initialization structure.
+ * @retval COMPONENT_OK in case of success.
**********************************************************/
-MOTOR_vt_t* STSPIN820::STSPIN820_GetMotorHandle(void)
+status_t STSPIN820::STSPIN820_Init(void *init)
{
- return (&STSPIN820_drv);
-}
-
-/******************************************************//**
- * @brief Start the STSPIN820 library
- * @param[in] pInit pointer to the initialization data
- * @retval None
- **********************************************************/
-void STSPIN820::STSPIN820_Init(void* pInit)
-{
- device_instance++;
-
/* Initialise the GPIOs */
- STSPIN820_Board_GpioInit();
+ STSPIN820_GpioInit();
/* Initialise the timer used for the step clock and ------------------------*/
/* the PWM for the reference voltage generation ----------------------------*/
- STSPIN820_Board_TimStckInit();
- STSPIN820_Board_PwmRefInit();
+ STSPIN820_TimStckInit();
+ STSPIN820_PwmRefInit();
- if (pInit == 0)
+ if (init == 0)
{
/* Set all context variables to the predefined values */
/* from STSPIN820_config.h */
@@ -102,20 +98,25 @@
}
else
{
- STSPIN820_SetDeviceParamsToGivenValues((STSPIN820_init_t*) pInit);
+ STSPIN820_SetDeviceParamsToGivenValues((STSPIN820_init_t*) init);
}
+
+ return COMPONENT_OK;
}
-/******************************************************//**
+/**********************************************************
* @brief Read id
- * @retval Id of the STSPIN820 Driver Instance
+ * @param id pointer to the identifier to be read.
+ * @retval COMPONENT_OK in case of success.
**********************************************************/
-uint16_t STSPIN820::STSPIN820_ReadId(void)
+status_t STSPIN820::STSPIN820_ReadId(uint8_t *id)
{
- return (device_instance);
+ *id = device_instance;
+
+ return COMPONENT_OK;
}
-/******************************************************//**
+/**********************************************************
* @brief Attach a user callback to the error Handler.
* The call back will be then called each time the library
* detects an error
@@ -128,7 +129,7 @@
error_handler_callback = (void (*)(uint16_t error))callback;
}
-/******************************************************//**
+/**********************************************************
* @brief Attach a user callback to the flag Interrupt
* The call back will be then called each time the status
* flag pin will be pulled down due to the occurrence of
@@ -143,13 +144,13 @@
flag_interrupt_callback = (void (*)(void))callback;
}
-/******************************************************//**
+/**********************************************************
* @brief Check if STSPIN820 has a fault by reading EN pin position.
* @retval One if STSPIN820 has EN pin down, otherwise zero
**********************************************************/
uint8_t STSPIN820::STSPIN820_CheckStatusHw(void)
{
- if(!STSPIN820_Board_EN_AND_FAULT_PIN_GetState())
+ if(!STSPIN820_EN_FAULT_PIN_GetState())
{
return 0x01;
}
@@ -159,27 +160,25 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Disable the power bridges (leave the output bridges HiZ)
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_Disable(uint8_t deviceId)
+void STSPIN820::STSPIN820_Disable(void)
{
- STSPIN820_Board_Disable();
+ STSPIN820_Disable_Power_Bridges();
}
-/******************************************************//**
+/**********************************************************
* @brief Enable the power bridges
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_Enable(uint8_t deviceId)
+void STSPIN820::STSPIN820_Enable(void)
{
- STSPIN820_Board_Enable();
+ STSPIN820_Enable_Power_Bridges();
}
-/******************************************************//**
+/**********************************************************
* @brief Error handler which calls the user callback (if defined)
* @param[in] error Number of the error
* @retval None
@@ -199,30 +198,29 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Exit STSPIN820 device from standby (low power consumption)
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_ExitDeviceFromStandby(uint8_t deviceId)
+void STSPIN820::STSPIN820_ExitDeviceFromStandby(void)
{
uint32_t sequencerPosition = device_prm.sequencerPosition;
/* Exit standby and set step mode */
/* Disable step clock */
- if (STSPIN820_Board_TimStckStop(&toggle_odd) == 0)
+ if (STSPIN820_TimStckStop(&toggle_odd) == 0)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_STEP_CLOCK);
}
/* Let the PWM REF and bridges enabled at least for DISABLE_DELAY time */
/* after the last step clock rising edge triggering the last step */
- STSPIN820_Board_Delay(DISABLE_DELAY);
+ STSPIN820_Delay(DISABLE_DELAY);
/* Set reference voltage to 0 */
- STSPIN820_SetTorque(0, CURRENT_TORQUE, 0);
+ STSPIN820_SetTorque( CURRENT_TORQUE, 0);
/* Disable power bridges */
- STSPIN820_Board_Disable();
+ STSPIN820_Disable_Power_Bridges();
device_prm.commandExecuted = NO_CMD;
device_prm.stepsToTake = 0;
@@ -235,27 +233,27 @@
device_prm.currentPosition = 0;
device_prm.markPosition = 0;
- STSPIN820_SetStepMode(deviceId, device_prm.stepMode);
- STSPIN820_Board_ReleaseReset();
- STSPIN820_Board_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
+ STSPIN820_SetStepMode(device_prm.stepMode);
+ STSPIN820_ReleaseReset();
+ STSPIN820_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
- STSPIN820_SetHome(deviceId);
- STSPIN820_SetMark(deviceId);
+ STSPIN820_SetHome();
+ STSPIN820_SetMark();
if (device_prm.sequencerPosition != 0)
{
/* Set direction to FORWARD to ensure the HW sequencer is increased at */
/* each step clock rising edge */
- STSPIN820_SetDirection(0, FORWARD);
+ STSPIN820_SetDirection(FORWARD);
/* Going out of standby */
device_prm.motionState = STANDBYTOINACTIVE;
/* Initialize the step clock timer */
- STSPIN820_Board_TimStckInit();
+ STSPIN820_TimStckInit();
/* Program the step clock */
- STSPIN820_Board_TimStckCompareInit();
- STSPIN820_Board_TimStckSetFreq(STSPIN820_MAX_STCK_FREQ);
+ STSPIN820_TimStckCompareInit();
+ STSPIN820_TimStckSetFreq(STSPIN820_MAX_STCK_FREQ);
toggle_odd = 0;
- STSPIN820_Board_TimStckStart();
+ STSPIN820_TimStckStart();
while (device_prm.sequencerPosition != 0);
while (toggle_odd!=0);
device_prm.sequencerPosition = sequencerPosition;
@@ -264,35 +262,32 @@
device_prm.motionState = INACTIVE;
}
-/******************************************************//**
+/**********************************************************
* @brief Return the acceleration of the specified device
- * @param[in] deviceId Unused parameter
* @retval Acceleration in pps^2
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetAcceleration(int8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetAcceleration(void)
{
return (device_prm.acceleration);
}
-/******************************************************//**
+/**********************************************************
* @brief Return the current speed of the specified device
- * @param[in] deviceId Unused parameter
* @retval Speed in pps
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetCurrentSpeed(int8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetCurrentSpeed(void)
{
return device_prm.speed;
}
-/******************************************************//**
+/**********************************************************
* @brief Return the decay mode of the specified device
- * @param[in] deviceId Unused parameter
* @retval Decay Mode State (SLOW or MIXED)
**********************************************************/
-motor_decay_mode_t STSPIN820::STSPIN820_GetDecayMode(uint8_t deviceId)
+motor_decay_mode_t STSPIN820::STSPIN820_GetDecayMode(void)
{
motor_decay_mode_t status;
- if (STSPIN820_Board_GetDecayGpio() != 0)
+ if (STSPIN820_GetDecayGpio() != 0)
{
status = SLOW_DECAY;
}
@@ -304,37 +299,34 @@
return status;
}
-/******************************************************//**
+/**********************************************************
* @brief Return the deceleration of the specified device
- * @param[in] deviceId Unused parameter
* @retval Deceleration in pps^2
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetDeceleration(uint8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetDeceleration(void)
{
return (device_prm.deceleration);
}
-/******************************************************//**
+/**********************************************************
* @brief Return the device state
- * @param[in] deviceId Unused parameter
* @retval State (ACCELERATING, DECELERATING, STEADY or INACTIVE)
**********************************************************/
-motor_state_t STSPIN820::STSPIN820_GetDeviceState(uint8_t deviceId)
+motor_state_t STSPIN820::STSPIN820_GetDeviceState(void)
{
return device_prm.motionState;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the motor current direction
- * @param[in] deviceId Unused parameter
* @retval direction
**********************************************************/
-motor_direction_t STSPIN820::STSPIN820_GetDirection(uint8_t deviceId)
+motor_direction_t STSPIN820::STSPIN820_GetDirection(void)
{
return device_prm.direction;
}
-/******************************************************//**
+/**********************************************************
* @brief Return the FW version of the library
* @retval Stspin220_FW_VERSION
**********************************************************/
@@ -343,37 +335,34 @@
return (STSPIN820_FW_VERSION);
}
-/******************************************************//**
+/**********************************************************
* @brief Return the mark position of the specified device
- * @param[in] deviceId Unused parameter
* @retval mark position value
**********************************************************/
-int32_t STSPIN820::STSPIN820_GetMark(uint8_t deviceId)
+int32_t STSPIN820::STSPIN820_GetMark(void)
{
return device_prm.markPosition;
}
-/******************************************************//**
+/**********************************************************
* @brief Return the max speed of the specified device
- * @param[in] deviceId Unused parameter
* @retval maxSpeed in pps
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetMaxSpeed(uint8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetMaxSpeed(void)
{
return (device_prm.maxSpeed);
}
-/******************************************************//**
+/**********************************************************
* @brief Return the min speed of the specified device
- * @param[in] deviceId Unused parameter
* @retval minSpeed in pps
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetMinSpeed(uint8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetMinSpeed(void)
{
return (device_prm.minSpeed);
}
-/******************************************************//**
+/**********************************************************
* @brief Returns the number of devices
* @retval number of devices
**********************************************************/
@@ -382,44 +371,40 @@
return (number_of_devices);
}
-/******************************************************//**
+/**********************************************************
* @brief Return the current position value of the specified device
- * @param[in] deviceId Unused parameter
* @retval current position value
**********************************************************/
-int32_t STSPIN820::STSPIN820_GetPosition(uint8_t deviceId)
+int32_t STSPIN820::STSPIN820_GetPosition(void)
{
return device_prm.currentPosition;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the motor step mode
- * @param[in] deviceId Unused parameter
* @retval step mode
**********************************************************/
-motor_step_mode_t STSPIN820::STSPIN820_GetStepMode(uint8_t deviceId)
+motor_step_mode_t STSPIN820::STSPIN820_GetStepMode(void)
{
return device_prm.stepMode;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the selected stop mode
- * @param[in] deviceId Unused parameter
* @retval the selected stop mode
**********************************************************/
-motor_stop_mode_t STSPIN820::STSPIN820_GetStopMode(uint8_t deviceId)
+motor_stop_mode_t STSPIN820::STSPIN820_GetStopMode(void)
{
return device_prm.stopMode;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the torque of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] torqueMode torque mode
* @retval the torqueValue in % (from 0 to 100)
* @note
**********************************************************/
-uint8_t STSPIN820::STSPIN820_GetTorque(uint8_t deviceId, motor_torque_mode_t torqueMode)
+uint8_t STSPIN820::STSPIN820_GetTorque(motor_torque_mode_t torqueMode)
{
uint8_t torqueValue = 0;
switch(torqueMode)
@@ -445,54 +430,46 @@
return torqueValue;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the torque boost feature status
- * @param[in] deviceId Unused parameter
* @retval TRUE if enabled, FALSE if disabled
**********************************************************/
-bool STSPIN820::STSPIN820_GetTorqueBoostEnable(uint8_t deviceId)
+bool STSPIN820::STSPIN820_GetTorqueBoostEnable(void)
{
return device_prm.torqueBoostEnable;
}
-/******************************************************//**
+/**********************************************************
* @brief Get the torque boost threshold
- * @param[in] deviceId (from 0 to MAX_NUMBER_OF_DEVICES - 1)
+ * @param[in] (from 0 to MAX_NUMBER_OF_DEVICES - 1)
* @retval the torque boost threshold above which the step mode is
* changed to full step
**********************************************************/
-uint16_t STSPIN820::STSPIN820_GetTorqueBoostThreshold(uint8_t deviceId)
+uint16_t STSPIN820::STSPIN820_GetTorqueBoostThreshold(void)
{
return device_prm.torqueBoostSpeedThreshold;
}
-/******************************************************//**
+/**********************************************************
* @brief Request the motor to move to the home position (ABS_POSITION = 0)
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_GoHome(uint8_t deviceId)
+void STSPIN820::STSPIN820_GoHome(void)
{
- deviceId = 0;
-
- STSPIN820_GoTo(deviceId, 0);
+ STSPIN820_GoTo(0);
}
-/******************************************************//**
+/**********************************************************
* @brief Request the motor to move to the mark position
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_GoMark(uint8_t deviceId)
+void STSPIN820::STSPIN820_GoMark(void)
{
- deviceId = 0;
-
- STSPIN820_GoTo(deviceId, device_prm.markPosition);
+ STSPIN820_GoTo(device_prm.markPosition);
}
-/******************************************************//**
+/**********************************************************
* @brief Request the motor to move to the specified position
- * @param[in] deviceId Unused parameter
* @param[in] targetPosition absolute position in steps
* @retval None
* @note The position is at the resolution corresponding to the
@@ -507,20 +484,19 @@
* STEP_MODE_1_256 : 1/256 step
* @note The 1/64 step mode is not allowed
**********************************************************/
-void STSPIN820::STSPIN820_GoTo(uint8_t deviceId, int32_t targetPosition)
+void STSPIN820::STSPIN820_GoTo(int32_t targetPosition)
{
motor_direction_t direction;
- deviceId = 0;
/* Exit from standby if needed */
if (device_prm.motionState == STANDBY)
{
- STSPIN820_ExitDeviceFromStandby(deviceId);
+ STSPIN820_ExitDeviceFromStandby();
}
/* Deactivate motor if needed */
else if (device_prm.motionState != INACTIVE)
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
if (targetPosition > device_prm.currentPosition)
@@ -559,18 +535,17 @@
device_prm.commandExecuted = MOVE_CMD;
/* Direction setup */
- STSPIN820_SetDirection(deviceId, direction);
+ STSPIN820_SetDirection(direction);
- STSPIN820_ComputeSpeedProfile(deviceId, device_prm.stepsToTake);
+ STSPIN820_ComputeSpeedProfile(device_prm.stepsToTake);
/* Motor activation */
- STSPIN820_StartMovement(deviceId);
+ STSPIN820_StartMovement();
}
}
-/******************************************************//**
+/**********************************************************
* @brief Move the motor to the absolute position
- * @param[in] deviceId Unused parameter
* @param[in] direction FORWARD or BACKWARD
* @param[in] targetPosition 32 bit signed value position
* @retval None
@@ -586,19 +561,17 @@
* STEP_MODE_1_256 : 1/256 step
* @note The 1/64 step mode is not allowed
**********************************************************/
-void STSPIN820::STSPIN820_GoToDir(uint8_t deviceId, motor_direction_t direction, int32_t targetPosition)
+void STSPIN820::STSPIN820_GoToDir(motor_direction_t direction, int32_t targetPosition)
{
- deviceId = 0;
-
/* Exit from standby if needed */
if (device_prm.motionState == STANDBY)
{
- STSPIN820_ExitDeviceFromStandby(deviceId);
+ STSPIN820_ExitDeviceFromStandby();
}
/* Deactivate motor if needed */
else if (device_prm.motionState != INACTIVE)
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
if (direction != BACKWARD)
@@ -635,46 +608,45 @@
device_prm.commandExecuted = MOVE_CMD;
/* Direction setup */
- STSPIN820_SetDirection(deviceId, direction);
+ STSPIN820_SetDirection(direction);
- STSPIN820_ComputeSpeedProfile(deviceId, device_prm.stepsToTake);
+ STSPIN820_ComputeSpeedProfile(device_prm.stepsToTake);
/* Motor activation */
- STSPIN820_StartMovement(deviceId);
+ STSPIN820_StartMovement();
}
}
-/******************************************************//**
+/**********************************************************
* @brief Immediatly stop the motor and disable the power bridge
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_HardHiZ(uint8_t deviceId)
+void STSPIN820::STSPIN820_HardHiZ(void)
{
/* Set inactive state */
device_prm.motionState = INACTIVE;
/* Disable step clock */
- if (STSPIN820_Board_TimStckStop(handle &toggle_odd) == 0)
+ if (STSPIN820_TimStckStop(&toggle_odd) == 0)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_STEP_CLOCK);
}
/* Let the PWM REF and bridges enabled at least for DISABLE_DELAY time */
/* after the last step clock rising edge triggering the last step */
- STSPIN820_Board_Delay(DISABLE_DELAY);
+ STSPIN820_Delay(DISABLE_DELAY);
/* Set reference voltage to 0 */
- STSPIN820_SetTorque(0, CURRENT_TORQUE, 0);
+ STSPIN820_SetTorque(CURRENT_TORQUE, 0);
/* Disable power bridges */
- STSPIN820_Board_Disable();
+ STSPIN820_Disable_Power_Bridges();
/* Comeback to nominal step mode */
if (device_prm.stepModeLatched != device_prm.stepMode)
{
motor_step_mode_t StepMode = device_prm.stepModeLatched;
- STSPIN820_SetStepMode(0, StepMode);
+ STSPIN820_SetStepMode(StepMode);
device_prm.stepMode = device_prm.stepModeLatched;
}
@@ -683,37 +655,34 @@
device_prm.speed = 0;
}
-/******************************************************//**
+/**********************************************************
* @brief Immediatly stop the motor
* and either set holding torque when stop mode is HOLD_MODE,
* or call STSPIN820_HardHiz function when stop mode is HIZ_MODE,
* or call STSPIN820_PutDeviceInStandby function when stop mode is STANDBY_MODE
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_HardStop(uint8_t deviceId)
+void STSPIN820::STSPIN820_HardStop(void)
{
- deviceId = 0;
-
if (device_prm.stopMode == HOLD_MODE)
{
/* Set inactive state */
device_prm.motionState = INACTIVE;
/* Disable step clock */
- if (STSPIN820_Board_TimStckStop(&toggle_odd) == 0)
+ if (STSPIN820_TimStckStop(&toggle_odd) == 0)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_STEP_CLOCK);
}
/* Set holding torque */
- STSPIN820_ApplyTorque(deviceId, HOLD_TORQUE);
+ STSPIN820_ApplyTorque(HOLD_TORQUE);
/* Comeback to nominal step mode */
if (device_prm.stepModeLatched != device_prm.stepMode)
{
motor_step_mode_t StepMode = device_prm.stepModeLatched;
- STSPIN820_SetStepMode(0, StepMode);
+ STSPIN820_SetStepMode(StepMode);
device_prm.stepMode = device_prm.stepModeLatched;
}
@@ -723,34 +692,31 @@
}
else if (device_prm.stopMode == HIZ_MODE)
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
else if (device_prm.stopMode == STANDBY_MODE)
{
- STSPIN820_PutDeviceInStandby(deviceId);
+ STSPIN820_PutDeviceInStandby();
}
}
-/******************************************************//**
+/**********************************************************
* @brief Moves the motor of the specified number of steps
- * @param[in] deviceId Unused parameter
* @param[in] direction FORWARD or BACKWARD
* @param[in] stepCount Number of steps to perform
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_Move(uint8_t deviceId, motor_direction_t direction, uint32_t stepCount)
+void STSPIN820::STSPIN820_Move(motor_direction_t direction, uint32_t stepCount)
{
- deviceId = 0;
-
/* Exit from standby if needed */
if (device_prm.motionState == STANDBY)
{
- STSPIN820_ExitDeviceFromStandby(deviceId);
+ STSPIN820_ExitDeviceFromStandby();
}
/* Deactivate motor if needed */
else if (device_prm.motionState != INACTIVE)
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
if (stepCount != 0)
@@ -759,67 +725,64 @@
device_prm.commandExecuted = MOVE_CMD;
/* Direction setup */
- STSPIN820_SetDirection(deviceId, direction);
+ STSPIN820_SetDirection(direction);
- STSPIN820_ComputeSpeedProfile(deviceId, stepCount);
+ STSPIN820_ComputeSpeedProfile(stepCount);
/* Motor activation */
- STSPIN820_StartMovement(deviceId);
+ STSPIN820_StartMovement();
}
}
-/******************************************************//**
+/**********************************************************
* @brief Put STSPIN820 device in standby (low power consumption)
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_PutDeviceInStandby(uint8_t deviceId)
+void STSPIN820::STSPIN820_PutDeviceInStandby(void)
{
/* Stop movement */
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
/* Enter standby */
- STSPIN820_Board_Reset();
+ STSPIN820_Reset();
device_prm.motionState = STANDBY;
}
-/******************************************************//**
+/**********************************************************
* @brief Runs the motor. It will accelerate from the min
* speed up to the max speed by using the device acceleration.
- * @param[in] deviceId Unused parameter
* @param[in] direction FORWARD or BACKWARD
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_Run(uint8_t deviceId, motor_direction_t direction)
+void STSPIN820::STSPIN820_Run(motor_direction_t direction)
{
/* Exit from standby if needed */
if (device_prm.motionState == STANDBY)
{
- STSPIN820_ExitDeviceFromStandby(deviceId);
+ STSPIN820_ExitDeviceFromStandby();
}
/* Deactivate motor if needed */
else if (device_prm.motionState != INACTIVE)
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
/* Direction setup */
- STSPIN820_SetDirection(deviceId,direction);
+ STSPIN820_SetDirection(direction);
device_prm.commandExecuted = RUN_CMD;
/* Motor activation */
- STSPIN820_StartMovement(deviceId);
+ STSPIN820_StartMovement();
}
-/******************************************************//**
+/**********************************************************
* @brief Changes the acceleration of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] newAcc New acceleration to apply in pps^2
* @retval true if the command is successfully executed, else false
* @note The command is not performed if the device is executing
* a MOVE or GOTO command (but it can be used during a RUN command)
**********************************************************/
-bool STSPIN820::STSPIN820_SetAcceleration(uint8_t deviceId, uint16_t newAcc)
+bool STSPIN820::STSPIN820_SetAcceleration(uint16_t newAcc)
{
bool cmdExecuted = FALSE;
if ((newAcc != 0)&&
@@ -832,33 +795,31 @@
return cmdExecuted;
}
-/******************************************************//**
+/**********************************************************
* @brief Specifies the decay mode
- * @param[in] deviceId Unused parameter
* @param[in] decay SLOW_DECAY or MIXED_DECAY
* @retval true if the command is successfully executed, else false
**********************************************************/
-void STSPIN820::STSPIN820_SetDecayMode(uint8_t deviceId, motor_decay_mode_t decay)
+void STSPIN820::STSPIN820_SetDecayMode(motor_decay_mode_t decay)
{
if (decay == SLOW_DECAY)
{
- STSPIN820_Board_SetDecayGpio(1);
+ STSPIN820_SetDecayGpio(1);
}
else if (decay == MIXED_DECAY)
{
- STSPIN820_Board_SetDecayGpio(0);
+ STSPIN820_SetDecayGpio(0);
}
}
-/******************************************************//**
+/**********************************************************
* @brief Changes the deceleration of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] newDec New deceleration to apply in pps^2
* @retval true if the command is successfully executed, else false
* @note The command is not performed if the device is executing
* a MOVE or GOTO command (but it can be used during a RUN command)
**********************************************************/
-bool STSPIN820::STSPIN820_SetDeceleration(uint8_t deviceId, uint16_t newDec)
+bool STSPIN820::STSPIN820_SetDeceleration(uint16_t newDec)
{
bool cmdExecuted = FALSE;
if ((newDec != 0)&&
@@ -871,65 +832,61 @@
return cmdExecuted;
}
-/******************************************************//**
+/**********************************************************
* @brief Specifies the direction
- * @param[in] deviceId Unused parameter
* @param[in] dir FORWARD or BACKWARD
* @note The direction change is applied if the device
* is in INACTIVE or STANDBY state or if the device is
* executing a run command
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetDirection(uint8_t deviceId, motor_direction_t dir)
+void STSPIN820::STSPIN820_SetDirection(motor_direction_t dir)
{
if ((device_prm.motionState == INACTIVE)||\
(device_prm.motionState == STANDBY))
{
device_prm.direction = dir;
- STSPIN820_Board_SetDirectionGpio(dir);
+ STSPIN820_SetDirectionGpio(dir);
}
else if ((device_prm.commandExecuted&RUN_CMD)!=0)
{
- device_prm.commandExecuted|=STSPIN820_DIR_CHANGE_BIT_MASK;
+ device_prm.commandExecuted = (device_command_t) (device_prm.commandExecuted | STSPIN820_DIR_CHANGE_BIT_MASK);
}
}
-/******************************************************//**
+/**********************************************************
* @brief Set current position to be the Home position
* (current position set to 0)
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetHome(uint8_t deviceId)
+void STSPIN820::STSPIN820_SetHome(void)
{
device_prm.currentPosition = 0;
}
-/******************************************************//**
+/**********************************************************
* @brief Set current position to be the Mark position
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetMark(uint8_t deviceId)
+void STSPIN820::STSPIN820_SetMark(void)
{
device_prm.markPosition = device_prm.currentPosition;
}
-/******************************************************//**
+/**********************************************************
* @brief Changes the max speed of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] newMaxSpeed New max speed to apply in pps
* @retval true if the command is successfully executed, else false
* @note The command is not performed is the device is executing
* a MOVE or GOTO command (but it can be used during a RUN command).
**********************************************************/
-bool STSPIN820::STSPIN820_SetMaxSpeed(uint8_t deviceId, uint16_t newMaxSpeed)
+bool STSPIN820::STSPIN820_SetMaxSpeed(uint16_t newMaxSpeed)
{
bool cmdExecuted = FALSE;
if ((newMaxSpeed >= STSPIN820_MIN_STCK_FREQ)&&\
((newMaxSpeed <= STSPIN820_MAX_STCK_FREQ)||\
((device_prm.torqueBoostEnable != FALSE)&&\
- ((newMaxSpeed>>STSPIN820_GetStepMode(deviceId))<= STSPIN820_MAX_STCK_FREQ)))&&\
+ ((newMaxSpeed>>STSPIN820_GetStepMode())<= STSPIN820_MAX_STCK_FREQ)))&&\
(device_prm.minSpeed <= newMaxSpeed) &&\
(((device_prm.motionState & INACTIVE) == INACTIVE)||\
(device_prm.commandExecuted == RUN_CMD)))
@@ -940,15 +897,14 @@
return cmdExecuted;
}
-/******************************************************//**
+/**********************************************************
* @brief Changes the min speed of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] newMinSpeed New min speed to apply in pps
* @retval true if the command is successfully executed, else false
* @note The command is not performed is the device is executing
* a MOVE or GOTO command (but it can be used during a RUN command).
**********************************************************/
-bool STSPIN820::STSPIN820_SetMinSpeed(uint8_t deviceId, uint16_t newMinSpeed)
+bool STSPIN820::STSPIN820_SetMinSpeed(uint16_t newMinSpeed)
{
bool cmdExecuted = FALSE;
if ((newMinSpeed >= STSPIN820_MIN_STCK_FREQ)&&
@@ -963,7 +919,7 @@
return cmdExecuted;
}
-/******************************************************//**
+/**********************************************************
* @brief Sets the number of devices to be used
* @param[in] nbDevices (from 1 to MAX_NUMBER_OF_DEVICES)
* @retval TRUE if successfull, FALSE if failure, attempt to set a number of
@@ -982,15 +938,14 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Set the stepping mode
- * @param[in] deviceId Unused parameter
* @param[in] stepMode from full step to 1/256 microstep
* as specified in enum motor_step_mode_t
* 1/64 microstep mode not supported by STSPIN820
* @retval true if the command is successfully executed, else false
**********************************************************/
-bool STSPIN820::STSPIN820_SetStepMode(uint8_t deviceId, motor_step_mode_t stepMode)
+bool STSPIN820::STSPIN820_SetStepMode(motor_step_mode_t stepMode)
{
/* Store step mode */
device_prm.stepMode = stepMode;
@@ -1000,28 +955,28 @@
switch (stepMode)
{
case STEP_MODE_FULL:
- STSPIN820_Board_SetFullStep();
+ STSPIN820_SetFullStep();
break;
case STEP_MODE_HALF:
- STSPIN820_Board_SetModePins(1, 0, 0);
+ STSPIN820_SetModePins(1, 0, 0);
break;
case STEP_MODE_1_4:
- STSPIN820_Board_SetModePins(0, 1, 0);
+ STSPIN820_SetModePins(0, 1, 0);
break;
case STEP_MODE_1_8:
- STSPIN820_Board_SetModePins(1, 1, 0);
+ STSPIN820_SetModePins(1, 1, 0);
break;
case STEP_MODE_1_16:
- STSPIN820_Board_SetModePins(0, 0, 1);
+ STSPIN820_SetModePins(0, 0, 1);
break;
case STEP_MODE_1_32:
- STSPIN820_Board_SetModePins(1, 0, 1);
+ STSPIN820_SetModePins(1, 0, 1);
break;
case STEP_MODE_1_128:
- STSPIN820_Board_SetModePins(0, 1, 1);
+ STSPIN820_SetModePins(0, 1, 1);
break;
case STEP_MODE_1_256:
- STSPIN820_Board_SetModePins(1, 1, 1);
+ STSPIN820_SetModePins(1, 1, 1);
break;
default:
return FALSE;
@@ -1031,26 +986,24 @@
}
-/******************************************************//**
+/**********************************************************
* @brief Select the mode to stop the motor.
- * @param[in] deviceId Unused parameter
* @param[in] stopMode HOLD_MODE to let power bridge enabled
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetStopMode(uint8_t deviceId, motor_stop_mode_t stopMode)
+void STSPIN820::STSPIN820_SetStopMode(motor_stop_mode_t stopMode)
{
device_prm.stopMode = stopMode;
}
-/******************************************************//**
+/**********************************************************
* @brief Set the torque of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] torqueMode Torque mode as specified in enum motor_torque_mode_t
* @param[in] torqueValue in % (from 0 to 100)
* @retval None
* @note
**********************************************************/
-void STSPIN820::STSPIN820_SetTorque(uint8_t deviceId, motor_torque_mode_t torqueMode, uint8_t torqueValue)
+void STSPIN820::STSPIN820_SetTorque(motor_torque_mode_t torqueMode, uint8_t torqueValue)
{
device_prm.updateTorque = TRUE;
if (torqueValue>100)
@@ -1076,97 +1029,91 @@
}
case CURRENT_TORQUE:
device_prm.currentTorque = torqueValue;
- STSPIN820_Board_PwmRefSetFreqAndDutyCycle(device_prm.refPwmFreq,torqueValue);
+ STSPIN820_PwmRefSetFreqAndDutyCycle(device_prm.refPwmFreq,torqueValue);
default:
device_prm.updateTorque = FALSE;
break; //ignore error
}
}
-/******************************************************//**
+/**********************************************************
* @brief Enable or disable the torque boost feature
- * @param[in] deviceId Unused parameter
* @param[in] enable true to enable torque boost, false to disable
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetTorqueBoostEnable(uint8_t deviceId, bool enable)
+void STSPIN820::STSPIN820_SetTorqueBoostEnable(bool enable)
{
device_prm.torqueBoostEnable = enable;
}
-/******************************************************//**
+/**********************************************************
* @brief Set the torque boost threshold
- * @param[in] deviceId (from 0 to MAX_NUMBER_OF_DEVICES - 1)
+ * @param[in] (from 0 to MAX_NUMBER_OF_DEVICES - 1)
* @param[in] speedThreshold speed threshold above which the step mode is
* changed to full step
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_SetTorqueBoostThreshold(uint8_t deviceId, uint16_t speedThreshold)
+void STSPIN820::STSPIN820_SetTorqueBoostThreshold(uint16_t speedThreshold)
{
device_prm.torqueBoostSpeedThreshold = speedThreshold;
}
-/******************************************************//**
+/**********************************************************
* @brief Stops the motor by using the device deceleration
- * @param[in] deviceId Unused parameter
* @retval true if the command is successfully executed, else false
* @note The command is not performed if the device is in INACTIVE,
* STANDBYTOINACTIVE or STANDBY state.
**********************************************************/
-bool STSPIN820::STSPIN820_SoftStop(uint8_t deviceId)
+bool STSPIN820::STSPIN820_SoftStop(void)
{
bool cmdExecuted = FALSE;
if ((device_prm.motionState & INACTIVE) != INACTIVE)
{
- device_prm.commandExecuted |= STSPIN820_SOFT_STOP_BIT_MASK;
+ device_prm.commandExecuted = (device_command_t) (device_prm.commandExecuted | STSPIN820_SOFT_STOP_BIT_MASK);
cmdExecuted = TRUE;
}
return (cmdExecuted);
}
-/******************************************************//**
+/**********************************************************
* @brief Get the frequency of REF PWM of the specified device
- * @param[in] deviceId Unused parameter
* @retval the frequency of REF PWM in Hz
* @note
**********************************************************/
-uint32_t STSPIN820::STSPIN820_VrefPwmGetFreq(uint8_t deviceId)
+uint32_t STSPIN820::STSPIN820_VrefPwmGetFreq(void)
{
return device_prm.refPwmFreq;
}
-/******************************************************//**
+/**********************************************************
* @brief Set the frequency of REF PWM of the specified device
- * @param[in] deviceId Unused parameter
* @param[in] newFreq in Hz
* @retval None
* @note
**********************************************************/
-void STSPIN820::STSPIN820_VrefPwmSetFreq(uint8_t deviceId, uint32_t newFreq)
+void STSPIN820::STSPIN820_VrefPwmSetFreq(uint32_t newFreq)
{
device_prm.refPwmFreq = newFreq;
- STSPIN820_Board_PwmRefSetFreqAndDutyCycle(newFreq,device_prm.currentTorque);
+ STSPIN820_PwmRefSetFreqAndDutyCycle(newFreq,device_prm.currentTorque);
}
-/******************************************************//**
+/**********************************************************
* @brief Locks until the device state becomes Inactive
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_WaitWhileActive(uint8_t deviceId)
+void STSPIN820::STSPIN820_WaitWhileActive(void)
{
/* Wait while motor is running */
- while (((STSPIN820_GetDeviceState(deviceId)&INACTIVE)!=INACTIVE)||\
- (((STSPIN820_GetDeviceState(deviceId)&INACTIVE)==INACTIVE)&&(toggle_odd!=0)));
+ while (((STSPIN820_GetDeviceState()&INACTIVE)!=INACTIVE)||\
+ (((STSPIN820_GetDeviceState()&INACTIVE)==INACTIVE)&&(toggle_odd!=0)));
}
-/******************************************************//**
+/**********************************************************
* @brief Updates the current speed of the device
- * @param[in] deviceId Unused parameter
* @param[in] newSpeed in pps
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_ApplySpeed(uint8_t deviceId, uint16_t newSpeed)
+void STSPIN820::STSPIN820_ApplySpeed(uint16_t newSpeed)
{
if (device_prm.torqueBoostEnable != FALSE)
{
@@ -1184,8 +1131,8 @@
{
if ((device_prm.sequencerPosition & 0xFF) == 0x80)
{
- STSPIN820_Board_SetFullStep();
- device_prm.stepMode = STEP_MODE_FULL;
+ STSPIN820_SetFullStep();
+ device_prm.stepMode = (motor_step_mode_t) STEP_MODE_FULL;
device_prm.accu >>= device_prm.stepModeLatched;
newSpeed >>= device_prm.stepModeLatched;
}
@@ -1197,7 +1144,7 @@
((device_prm.stepsToTake-device_prm.relativePos)<=\
(1<<device_prm.stepModeLatched))))
{
- STSPIN820_SetStepMode(0, device_prm.stepModeLatched);
+ STSPIN820_SetStepMode(device_prm.stepModeLatched);
device_prm.stepMode = device_prm.stepModeLatched;
device_prm.accu <<= device_prm.stepModeLatched;
newSpeed <<= device_prm.stepModeLatched;
@@ -1206,7 +1153,7 @@
else if (device_prm.stepMode != device_prm.stepModeLatched)
{
//torqueBoostEnable has just been disabled
- STSPIN820_SetStepMode(0, device_prm.stepModeLatched);
+ STSPIN820_SetStepMode(device_prm.stepModeLatched);
device_prm.stepMode = device_prm.stepModeLatched;
device_prm.accu <<= device_prm.stepModeLatched;
newSpeed <<= device_prm.stepModeLatched;
@@ -1222,18 +1169,17 @@
}
device_prm.speed = newSpeed;
- STSPIN820_Board_TimStckSetFreq(newSpeed);
+ STSPIN820_TimStckSetFreq(newSpeed);
}
-/******************************************************//**
+/**********************************************************
* @brief Apply the set torque to the specified device
- * @param[in] deviceId Unused parameter
* @param[in] torqueMode torque mode
* @retval None
* @note
**********************************************************/
-void STSPIN820::STSPIN820_ApplyTorque(uint8_t deviceId, motor_torque_mode_t torqueMode)
+void STSPIN820::STSPIN820_ApplyTorque(motor_torque_mode_t torqueMode)
{
uint8_t torqueValue = 0;
device_prm.updateTorque = FALSE;
@@ -1257,12 +1203,11 @@
return; //ignore error
}
torqueValue = device_prm.currentTorque;
- STSPIN820_Board_PwmRefSetFreqAndDutyCycle(device_prm.refPwmFreq,torqueValue);
+ STSPIN820_PwmRefSetFreqAndDutyCycle(device_prm.refPwmFreq,torqueValue);
}
-/******************************************************//**
+/**********************************************************
* @brief Computes the speed profile according to the number of steps to move
- * @param[in] deviceId Unused parameter
* @param[in] nbSteps number of steps to perform
* @retval None
* @note Using the acceleration and deceleration of the device,
@@ -1274,7 +1219,7 @@
* Else, a triangular move is performed (no steady phase: the maximum speed is never
* reached.
**********************************************************/
-void STSPIN820::STSPIN820_ComputeSpeedProfile(uint8_t deviceId, uint32_t nbSteps)
+void STSPIN820::STSPIN820_ComputeSpeedProfile(uint32_t nbSteps)
{
uint32_t reqAccSteps;
uint32_t reqDecSteps;
@@ -1325,7 +1270,7 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Handlers of the flag interrupt which calls the user callback (if defined)
* @retval None
**********************************************************/
@@ -1337,7 +1282,7 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Set the parameters of the device whose values are not defined in
* STSPIN820_config.h
* @retval None
@@ -1366,7 +1311,7 @@
}
}
-/******************************************************//**
+/**********************************************************
* @brief Set the parameters of the device to values of initDevicePrm structure
* @param pInitDevicePrm structure containing values to initialize the device
* parameters
@@ -1374,45 +1319,50 @@
**********************************************************/
void STSPIN820::STSPIN820_SetDeviceParamsToGivenValues(STSPIN820_init_t* pInitDevicePrm)
{
+ int i = 100;
+ printf("%d\r\n", i++);
device_prm.motionState = STANDBY;;
- if (STSPIN820_SetAcceleration(0,pInitDevicePrm->acceleration)==FALSE)
+ if (STSPIN820_SetAcceleration(pInitDevicePrm->acceleration)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_ACCELERATION);
}
- if (STSPIN820_SetDeceleration(0,pInitDevicePrm->deceleration)==FALSE)
+ printf("%d\r\n", i++);
+ if (STSPIN820_SetDeceleration(pInitDevicePrm->deceleration)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_DECELERATION);
}
- if (STSPIN820_SetMaxSpeed(0,pInitDevicePrm->maxSpeed)==FALSE)
+ printf("%d\r\n", i++);
+ if (STSPIN820_SetMaxSpeed(pInitDevicePrm->maxSpeed)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_MAX_SPEED);
}
- if (STSPIN820_SetMinSpeed(0,pInitDevicePrm->minSpeed)==FALSE)
+ printf("%d\r\n", i++);
+ if (STSPIN820_SetMinSpeed(pInitDevicePrm->minSpeed)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_MIN_SPEED);
}
-
- STSPIN820_VrefPwmSetFreq(0,pInitDevicePrm->vrefPwmFreq);
- STSPIN820_SetTorque(0,ACC_TORQUE,pInitDevicePrm->accelTorque);
- STSPIN820_SetTorque(0,DEC_TORQUE,pInitDevicePrm->decelTorque);
- STSPIN820_SetTorque(0,RUN_TORQUE,pInitDevicePrm->runTorque);
- STSPIN820_SetTorque(0,HOLD_TORQUE,pInitDevicePrm->holdTorque);
+ printf("%d\r\n", i++);
+ STSPIN820_VrefPwmSetFreq(pInitDevicePrm->vrefPwmFreq);
+ STSPIN820_SetTorque(ACC_TORQUE,pInitDevicePrm->accelTorque);
+ STSPIN820_SetTorque(DEC_TORQUE,pInitDevicePrm->decelTorque);
+ STSPIN820_SetTorque(RUN_TORQUE,pInitDevicePrm->runTorque);
+ STSPIN820_SetTorque(HOLD_TORQUE,pInitDevicePrm->holdTorque);
device_prm.torqueBoostEnable = pInitDevicePrm->torqueBoostEnable;
device_prm.torqueBoostSpeedThreshold = pInitDevicePrm->torqueBoostSpeedThreshold;
- STSPIN820_SetStopMode(0,pInitDevicePrm->stopMode);
-
+ STSPIN820_SetStopMode(pInitDevicePrm->stopMode);
+ printf("%d\r\n", i++);
STSPIN820_SetDeviceParamsOtherValues();
-
+ printf("%d\r\n", i++);
/* Eventually deactivate motor */
if ((device_prm.motionState != INACTIVE)&&\
(device_prm.motionState != STANDBY))
{
- STSPIN820_HardHiZ(0);
+ STSPIN820_HardHiZ();
}
/* Enter standby */
- STSPIN820_Board_Reset();
+ STSPIN820_Reset();
/* Reset the microstepping sequencer position */
device_prm.sequencerPosition = 0;
@@ -1422,20 +1372,20 @@
device_prm.markPosition = 0;
/* Set predefined step mode */
- STSPIN820_SetStepMode(0, pInitDevicePrm->stepMode);
+ STSPIN820_SetStepMode(pInitDevicePrm->stepMode);
/* Wait */
- STSPIN820_Board_Delay(SELECT_STEP_MODE_DELAY);
+ STSPIN820_Delay(SELECT_STEP_MODE_DELAY);
/* Exit standby */
- STSPIN820_Board_ReleaseReset();
+ STSPIN820_ReleaseReset();
/* Let a delay after reset release*/
- STSPIN820_Board_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
+ STSPIN820_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
}
-/******************************************************//**
+/**********************************************************
* @brief Sets the parameters of the device to predefined values
* from STSPIN820_config.h
* @retval None
@@ -1444,31 +1394,31 @@
{
device_prm.motionState = STANDBY;
- if (STSPIN820_SetAcceleration(0,STSPIN820_CONF_PARAM_ACC)==FALSE)
+ if (STSPIN820_SetAcceleration(STSPIN820_CONF_PARAM_ACC)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_ACCELERATION);
}
- if (STSPIN820_SetDeceleration(0,STSPIN820_CONF_PARAM_DEC)==FALSE)
+ if (STSPIN820_SetDeceleration(STSPIN820_CONF_PARAM_DEC)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_DECELERATION);
}
- if (STSPIN820_SetMaxSpeed(0,STSPIN820_CONF_PARAM_RUNNING_SPEED)==FALSE)
+ if (STSPIN820_SetMaxSpeed(STSPIN820_CONF_PARAM_RUNNING_SPEED)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_MAX_SPEED);
}
- if (STSPIN820_SetMinSpeed(0,STSPIN820_CONF_PARAM_MIN_SPEED)==FALSE)
+ if (STSPIN820_SetMinSpeed(STSPIN820_CONF_PARAM_MIN_SPEED)==FALSE)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_SET_MIN_SPEED);
}
- STSPIN820_VrefPwmSetFreq(0,STSPIN820_CONF_PARAM_REF_PWM_FREQUENCY);
- STSPIN820_SetTorque(0,ACC_TORQUE,STSPIN820_CONF_PARAM_ACC_TORQUE);
- STSPIN820_SetTorque(0,DEC_TORQUE,STSPIN820_CONF_PARAM_DEC_TORQUE);
- STSPIN820_SetTorque(0,RUN_TORQUE,STSPIN820_CONF_PARAM_RUNNING_TORQUE);
- STSPIN820_SetTorque(0,HOLD_TORQUE,STSPIN820_CONF_PARAM_HOLDING_TORQUE);
+ STSPIN820_VrefPwmSetFreq(STSPIN820_CONF_PARAM_REF_PWM_FREQUENCY);
+ STSPIN820_SetTorque(ACC_TORQUE,STSPIN820_CONF_PARAM_ACC_TORQUE);
+ STSPIN820_SetTorque(DEC_TORQUE,STSPIN820_CONF_PARAM_DEC_TORQUE);
+ STSPIN820_SetTorque(RUN_TORQUE,STSPIN820_CONF_PARAM_RUNNING_TORQUE);
+ STSPIN820_SetTorque(HOLD_TORQUE,STSPIN820_CONF_PARAM_HOLDING_TORQUE);
device_prm.torqueBoostEnable = STSPIN820_CONF_PARAM_TORQUE_BOOST_EN;
device_prm.torqueBoostSpeedThreshold = STSPIN820_CONF_PARAM_TORQUE_BOOST_TH;
- STSPIN820_SetStopMode(0,STSPIN820_CONF_PARAM_AUTO_HIZ_STOP);
+ STSPIN820_SetStopMode(STSPIN820_CONF_PARAM_AUTO_HIZ_STOP);
STSPIN820_SetDeviceParamsOtherValues();
@@ -1476,11 +1426,11 @@
if ((device_prm.motionState != INACTIVE)&&\
(device_prm.motionState != STANDBY))
{
- STSPIN820_HardHiZ(0);
+ STSPIN820_HardHiZ();
}
/* Enter standby */
- STSPIN820_Board_Reset();
+ STSPIN820_Reset();
/* Reset the microstepping sequencer position */
device_prm.sequencerPosition = 0;
@@ -1490,30 +1440,27 @@
device_prm.markPosition = 0;
/* Set predefined step mode */
- STSPIN820_SetStepMode(0, STSPIN820_CONF_PARAM_STEP_MODE);
+ STSPIN820_SetStepMode((motor_step_mode_t) STSPIN820_CONF_PARAM_STEP_MODE);
/* Wait */
- STSPIN820_Board_Delay(SELECT_STEP_MODE_DELAY);
+ STSPIN820_Delay(SELECT_STEP_MODE_DELAY);
/* Exit standby */
- STSPIN820_Board_ReleaseReset();
+ STSPIN820_ReleaseReset();
/* Let a delay after reset release*/
- STSPIN820_Board_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
+ STSPIN820_Delay(AFTER_STANDBY_EXIT_DEAD_TIME);
}
-/******************************************************//**
+/**********************************************************
* @brief Initialises the bridge parameters to start the movement
* and enable the power bridge
- * @param[in] deviceId Unused parameter
* @retval None
**********************************************************/
-void STSPIN820::STSPIN820_StartMovement(uint8_t deviceId)
+void STSPIN820::STSPIN820_StartMovement(void)
{
- deviceId = 0;
-
/* Enable STSPIN820 powerstage */
- STSPIN820_Enable(deviceId);
+ STSPIN820_Enable();
toggle_odd = 0;
device_prm.accu = 0;
device_prm.relativePos = 0;
@@ -1521,34 +1468,32 @@
(device_prm.commandExecuted != RUN_CMD))
{
device_prm.motionState = DECELERATING;
- STSPIN820_ApplyTorque(deviceId, DEC_TORQUE);
+ STSPIN820_ApplyTorque(DEC_TORQUE);
}
else
{
device_prm.motionState = ACCELERATING;
- STSPIN820_ApplyTorque(deviceId, ACC_TORQUE);
+ STSPIN820_ApplyTorque(ACC_TORQUE);
}
- STSPIN820_Board_PwmRefStart();
+ STSPIN820_PwmRefStart();
/* Initialize the step clock timer */
- STSPIN820_Board_TimStckInit();
+ STSPIN820_TimStckInit();
/* Program the step clock */
- STSPIN820_Board_TimStckCompareInit();
- STSPIN820_ApplySpeed(deviceId, device_prm.minSpeed);
- STSPIN820_Board_TimStckStart();
+ STSPIN820_TimStckCompareInit();
+ STSPIN820_ApplySpeed(device_prm.minSpeed);
+ STSPIN820_TimStckStart();
}
-/******************************************************//**
+/**********************************************************
* @brief Handles the device state machine at each pulse
- * @param[in] deviceId Unused parameter
* @retval None
* @note Must only be called by the timer ISR
**********************************************************/
-void STSPIN820::STSPIN820_StepClockHandler(uint8_t deviceId)
+void STSPIN820::STSPIN820_StepClockHandler(void)
{
uint32_t stepModeShift = device_prm.stepModeLatched - device_prm.stepMode;
uint16_t tmp;
- deviceId = 0;
-
+
if (device_prm.motionState == STANDBYTOINACTIVE)
{
if (toggle_odd != 0)
@@ -1556,7 +1501,7 @@
toggle_odd = 0;
if (device_prm.sequencerPosition == 0)
{
- if (STSPIN820_Board_TimStckStop(&toggle_odd) == 0)
+ if (STSPIN820_TimStckStop(&toggle_odd) == 0)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_STEP_CLOCK);
}
@@ -1569,7 +1514,7 @@
tmp = (1 << (STEP_MODE_1_256-device_prm.stepMode));
device_prm.sequencerPosition -= tmp;
}
- STSPIN820_Board_TimStckSetFreq(STSPIN820_MAX_STCK_FREQ);
+ STSPIN820_TimStckSetFreq(STSPIN820_MAX_STCK_FREQ);
return;
}
@@ -1620,14 +1565,14 @@
device_prm.motionState = DECELERATING;
device_prm.accu = 0;
/* Apply decelerating torque */
- STSPIN820_ApplyTorque(deviceId, DEC_TORQUE);
+ STSPIN820_ApplyTorque(DEC_TORQUE);
}
else if ((speed>=(device_prm.maxSpeed>>stepModeShift))||\
((device_prm.commandExecuted==MOVE_CMD)&&(relPos >= endAccPos)))
{
device_prm.motionState = STEADY;
/* Apply running torque */
- STSPIN820_ApplyTorque(deviceId, RUN_TORQUE);
+ STSPIN820_ApplyTorque(RUN_TORQUE);
}
else
{
@@ -1657,7 +1602,7 @@
if (device_prm.updateTorque!=FALSE)
{
/* Apply accelerating torque */
- STSPIN820_ApplyTorque(deviceId, ACC_TORQUE);
+ STSPIN820_ApplyTorque(ACC_TORQUE);
}
}
break;
@@ -1669,7 +1614,7 @@
if (device_prm.updateTorque!=FALSE)
{
/* Apply accelerating torque */
- STSPIN820_ApplyTorque(deviceId, RUN_TORQUE);
+ STSPIN820_ApplyTorque(RUN_TORQUE);
}
if (((device_prm.commandExecuted&(STSPIN820_SOFT_STOP_BIT_MASK|STSPIN820_DIR_CHANGE_BIT_MASK))!=0)||\
((device_prm.commandExecuted==MOVE_CMD)&&\
@@ -1680,14 +1625,14 @@
device_prm.motionState = DECELERATING;
device_prm.accu = 0;
/* Apply decelerating torque */
- STSPIN820_ApplyTorque(deviceId, DEC_TORQUE);
+ STSPIN820_ApplyTorque(DEC_TORQUE);
}
else if ((device_prm.commandExecuted==RUN_CMD)&&(device_prm.speed<maxSpeed))
{
device_prm.motionState = ACCELERATING;
device_prm.accu = 0;
/* Apply accelerating torque */
- STSPIN820_ApplyTorque(deviceId, ACC_TORQUE);
+ STSPIN820_ApplyTorque(ACC_TORQUE);
}
break;
}
@@ -1703,33 +1648,33 @@
/* Motion process complete */
if ((device_prm.commandExecuted&STSPIN820_DIR_CHANGE_BIT_MASK)!=0)
{
- device_prm.commandExecuted&=~STSPIN820_DIR_CHANGE_BIT_MASK;
+ device_prm.commandExecuted = (device_command_t) (device_prm.commandExecuted & ~STSPIN820_DIR_CHANGE_BIT_MASK);
if (device_prm.direction==BACKWARD)
{
device_prm.direction=FORWARD;
}
else device_prm.direction=BACKWARD;
- STSPIN820_Board_SetDirectionGpio(device_prm.direction);
+ STSPIN820_SetDirectionGpio(device_prm.direction);
if ((device_prm.commandExecuted&STSPIN820_SOFT_STOP_BIT_MASK)==0)
{
device_prm.motionState = ACCELERATING;
device_prm.accu = 0;
/* Apply accelerating torque */
- STSPIN820_ApplyTorque(deviceId, ACC_TORQUE);
+ STSPIN820_ApplyTorque(ACC_TORQUE);
break;
}
}
if (device_prm.stopMode==HOLD_MODE)
{
- STSPIN820_HardStop(deviceId);
+ STSPIN820_HardStop();
}
else if (device_prm.stopMode==STANDBY_MODE)
{
- STSPIN820_PutDeviceInStandby(deviceId);
+ STSPIN820_PutDeviceInStandby();
}
else
{
- STSPIN820_HardHiZ(deviceId);
+ STSPIN820_HardHiZ();
}
}
else if ((device_prm.commandExecuted==RUN_CMD)&&
@@ -1737,7 +1682,7 @@
{
device_prm.motionState = STEADY;
/* Apply running torque */
- STSPIN820_ApplyTorque(deviceId, RUN_TORQUE);
+ STSPIN820_ApplyTorque(RUN_TORQUE);
}
else
{
@@ -1772,7 +1717,7 @@
if (device_prm.updateTorque!=FALSE)
{
/* Apply decelerating torque */
- STSPIN820_ApplyTorque(deviceId, DEC_TORQUE);
+ STSPIN820_ApplyTorque(DEC_TORQUE);
}
}
}
@@ -1786,14 +1731,15 @@
}
if ((device_prm.motionState & INACTIVE) != INACTIVE)
{
- STSPIN820_ApplySpeed(deviceId, device_prm.speed);
+ STSPIN820_ApplySpeed(device_prm.speed);
}
else
{
- if (STSPIN820_Board_TimStckStop(&toggle_odd) == 0)
+ if (STSPIN820_TimStckStop(&toggle_odd) == 0)
{
STSPIN820_ErrorHandler(STSPIN820_ERROR_STEP_CLOCK);
}
}
}
+
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/