32343
843447835d
- IPS200 display menu with real-time status and parameter settings - Camera image processing and line tracking - IMU attitude solution and PID control - WiFi SPI oscilloscope data transmission
584 lines
20 KiB
C
584 lines
20 KiB
C
/**
|
|
* \file IfxStdIf_Pos.h
|
|
* \brief Standard interface: Position interface
|
|
* \ingroup IfxStdIf
|
|
*
|
|
* \version disabled
|
|
* \copyright Copyright (c) 2013 Infineon Technologies AG. All rights reserved.
|
|
*
|
|
*
|
|
* IMPORTANT NOTICE
|
|
*
|
|
*
|
|
* Use of this file is subject to the terms of use agreed between (i) you or
|
|
* the company in which ordinary course of business you are acting and (ii)
|
|
* Infineon Technologies AG or its licensees. If and as long as no such
|
|
* terms of use are agreed, use of this file is subject to following:
|
|
|
|
|
|
* Boost Software License - Version 1.0 - August 17th, 2003
|
|
|
|
* Permission is hereby granted, free of charge, to any person or
|
|
* organization obtaining a copy of the software and accompanying
|
|
* documentation covered by this license (the "Software") to use, reproduce,
|
|
* display, distribute, execute, and transmit the Software, and to prepare
|
|
* derivative works of the Software, and to permit third-parties to whom the
|
|
* Software is furnished to do so, all subject to the following:
|
|
|
|
* The copyright notices in the Software and this entire statement, including
|
|
* the above license grant, this restriction and the following disclaimer, must
|
|
* be included in all copies of the Software, in whole or in part, and all
|
|
* derivative works of the Software, unless such copies or derivative works are
|
|
* solely in the form of machine-executable object code generated by a source
|
|
* language processor.
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
|
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
|
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
*
|
|
* \defgroup library_srvsw_stdif_posif Standard interface: Position interface
|
|
* \ingroup library_srvsw_stdif
|
|
*
|
|
* The standard interface position interface (IfxStdIf_Pos) abstract the hardware used for position interface feature like encoder, hall, resolver, ... It provide, after proper initialization an hardware
|
|
* Independent way to interact with the position sensor like getting position, speed, direction, ...
|
|
*
|
|
* The figure below shows the standard position interface.
|
|
*
|
|
* \image html "stdif_PosIf.png" "Standard position interface"
|
|
*
|
|
* This interface defines the following features:
|
|
* -
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifndef IFXSTDIF_POSIF_H
|
|
#define IFXSTDIF_POSIF_H 1
|
|
|
|
#include "Cpu/Std/Ifx_Types.h"
|
|
#include "IfxStdIf.h"
|
|
#include "IfxStdIf_DPipe.h"
|
|
|
|
/** \brief Output event enable / disable */
|
|
typedef enum
|
|
{
|
|
IfxStdIf_Pos_MotionType_rotating, /**< \brief Rotating sensor */
|
|
IfxStdIf_Pos_MotionType_linear /**< \brief Linear sensor */
|
|
} IfxStdIf_Pos_MotionType;
|
|
|
|
/** \brief Output event enable / disable */
|
|
typedef enum
|
|
{
|
|
IfxStdIf_Pos_ResolutionFactor_oneFold = 1, /**< \brief Default, no multipluication factor */
|
|
IfxStdIf_Pos_ResolutionFactor_twoFold = 2, /**< \brief 2-fold resolution. Valid for encoder */
|
|
IfxStdIf_Pos_ResolutionFactor_fourFold = 4 /**< \brief 4-fold resolution. Valid for encoder */
|
|
} IfxStdIf_Pos_ResolutionFactor;
|
|
|
|
/** \brief Position sensor Types */
|
|
typedef enum
|
|
{
|
|
IfxStdIf_Pos_SensorType_encoder,
|
|
IfxStdIf_Pos_SensorType_hall,
|
|
IfxStdIf_Pos_SensorType_resolver,
|
|
IfxStdIf_Pos_SensorType_angletrk,
|
|
IfxStdIf_Pos_SensorType_igmr,
|
|
IfxStdIf_Pos_SensorType_virtual
|
|
} IfxStdIf_Pos_SensorType;
|
|
|
|
/** \brief Position sensor direction definition */
|
|
typedef enum
|
|
{
|
|
IfxStdIf_Pos_Dir_forward, /**< \brief Forward direction. For rotating position sensor, forward is clockwise rotation */
|
|
IfxStdIf_Pos_Dir_backward, /**< \brief Backward direction. For rotating position sensor, fackward is counter-clockwise rotation */
|
|
IfxStdIf_Pos_Dir_unknown /**< \brief Unknown direction */
|
|
} IfxStdIf_Pos_Dir;
|
|
|
|
/** \brief Position sensor status definition */
|
|
typedef union
|
|
{
|
|
uint32 status; /**< \brief Global status access */
|
|
struct
|
|
{
|
|
uint32 notSynchronised : 1; /**< \brief Sensor is not synchronized */
|
|
uint32 signalLoss : 1; /**< \brief Loss of signal error */
|
|
uint32 signalDegradation : 1; /**< \brief Signal degradation warning */
|
|
uint32 trackingLoss : 1; /**< \brief Tracking loss error */
|
|
uint32 commError : 1; /**< \brief Communication error*/
|
|
} B; /**< \brief Bitfielf status access */
|
|
} IfxStdIf_Pos_Status;
|
|
|
|
typedef sint32 IfxStdIf_Pos_RawAngle;
|
|
|
|
/** \brief Forward declaration */
|
|
typedef struct IfxStdIf_Pos_ IfxStdIf_Pos;
|
|
|
|
/** \brief Return the position, inclusive turns
|
|
*
|
|
* Return the sensor position in rad for rotating sensor inclusive turns, or in m for linear sensors.
|
|
* For linear sensor the effect is the same as IfxStdIf_Pos_GetPosition.
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the position inclusive turns in rad
|
|
*/
|
|
typedef float32 (*IfxStdIf_Pos_GetAbsolutePosition)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Handles the zero interrupt
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return none
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_OnZeroIrq)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the raw position sensor offset
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the raw position sensor offset sensor in ticks
|
|
*/
|
|
typedef sint32 (*IfxStdIf_Pos_GetOffset)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the position
|
|
*
|
|
* Return the sensor position in rad for rotating sensor or in m for linear sensors.
|
|
* For rotating sensor, the position is always between 0 and 2*IFX_PI.
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the position in rad or m
|
|
*/
|
|
typedef float32 (*IfxStdIf_Pos_GetPosition)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the direction
|
|
*
|
|
* Return the sensor direction.
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the direction
|
|
*/
|
|
typedef IfxStdIf_Pos_Dir (*IfxStdIf_Pos_GetDirection)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the sensor status
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the sensor status
|
|
*/
|
|
typedef IfxStdIf_Pos_Status (*IfxStdIf_Pos_GetFault)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the period per rotation setting
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the period per rotation setting
|
|
*/
|
|
typedef uint16 (*IfxStdIf_Pos_GetPeriodPerRotation)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the raw position in ticks
|
|
*
|
|
* Return the sensor raw position in ticks.
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the raw position in ticks
|
|
*/
|
|
typedef sint32 (*IfxStdIf_Pos_GetRawPosition)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Get the update period
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the update period in s
|
|
*/
|
|
typedef float32 (*IfxStdIf_Pos_GetRefreshPeriod)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Get the resolution
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the resolution
|
|
*/
|
|
typedef sint32 (*IfxStdIf_Pos_GetResolution)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Get the sensor type
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the sensor type
|
|
*/
|
|
typedef IfxStdIf_Pos_SensorType (*IfxStdIf_Pos_GetSensorType)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return the speed
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return the speed in rad/s or m/s
|
|
*/
|
|
typedef float32 (*IfxStdIf_Pos_GetSpeed)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Return position in turn
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return Return position in turn
|
|
*/
|
|
typedef sint32 (*IfxStdIf_Pos_GetTurn)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Handles the A sensor event
|
|
* Event A is a sensor defined event. it is optional.
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return none
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_OnEventA)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Refresh the status
|
|
*
|
|
* Update the stdIf state like speed, position, status, taking into account the updatePeriod
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_Update)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Reset the driver
|
|
*
|
|
* Clear faults, reset speed and position to 0
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_Reset)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Reset the driver fault
|
|
*
|
|
* Clear faults
|
|
*
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_ResetFaults)(IfxStdIf_InterfaceDriver stdIf);
|
|
|
|
/** \brief Set the sensor offset
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \param offset Offset in sensor ticks
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_SetOffset)(IfxStdIf_InterfaceDriver stdIf, sint32 offset);
|
|
|
|
/** \brief Set the sensor position (virtual sensor)
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \param position Position sensor rad
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_SetPosition)(IfxStdIf_InterfaceDriver stdIf, float32 position);
|
|
/** \brief Set the sensor position (virtual sensor)
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \param position Position sensor ticks
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_SetRawPosition)(IfxStdIf_InterfaceDriver stdIf, sint32 position);
|
|
|
|
/** \brief Set the sensor speed (virtual sensor)
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \param speed speed in rad/s
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_SetSpeed)(IfxStdIf_InterfaceDriver stdIf, float32 speed);
|
|
|
|
/** \brief Set the update period
|
|
* \param stdIf Pointer to the interface driver object
|
|
* \param updatePeriod Refresh period in s
|
|
* \return None
|
|
*/
|
|
typedef void (*IfxStdIf_Pos_SetRefreshPeriod)(IfxStdIf_InterfaceDriver stdIf, float32 updatePeriod);
|
|
|
|
/** \brief Standard interface object
|
|
*/
|
|
struct IfxStdIf_Pos_
|
|
{
|
|
IfxStdIf_InterfaceDriver driver; /**< \brief Interface driver object */
|
|
IfxStdIf_Pos_OnZeroIrq onZeroIrq; /**< \brief \see IfxStdIf_Pos_OnZeroIrq */
|
|
IfxStdIf_Pos_GetAbsolutePosition getAbsolutePosition; /**< \brief Return the absolute position */
|
|
IfxStdIf_Pos_GetOffset getOffset; /**< \brief \see IfxStdIf_Pos_GetOffset */
|
|
IfxStdIf_Pos_GetPosition getPosition; /**< \brief \see IfxStdIf_Pos_GetPosition */
|
|
IfxStdIf_Pos_GetDirection getDirection; /**< \brief \see IfxStdIf_Pos_GetDirection */
|
|
IfxStdIf_Pos_GetFault getFault; /**< \brief \see IfxStdIf_Pos_GetFault */
|
|
IfxStdIf_Pos_GetRawPosition getRawPosition; /**< \brief \see IfxStdIf_Pos_GetRawPosition */
|
|
IfxStdIf_Pos_GetPeriodPerRotation getPeriodPerRotation; /**< \brief \see IfxStdIf_Pos_GetPeriodPerRotation */
|
|
IfxStdIf_Pos_GetRefreshPeriod getRefreshPeriod; /**< \brief \see IfxStdIf_Pos_GetRefreshPeriod */
|
|
IfxStdIf_Pos_GetResolution getResolution; /**< \brief \see IfxStdIf_Pos_GetResolution */
|
|
IfxStdIf_Pos_GetSensorType getSensorType; /**< \brief \see IfxStdIf_Pos_GetSensorType */
|
|
IfxStdIf_Pos_GetTurn getTurn; /**< \brief \see IfxStdIf_Pos_GetTurn */
|
|
IfxStdIf_Pos_OnEventA onEventA; /**< \brief \see IfxStdIf_Pos_OnEventA */
|
|
IfxStdIf_Pos_Reset reset; /**< \brief \see IfxStdIf_Pos_Reset */
|
|
IfxStdIf_Pos_ResetFaults resetFaults; /**< \brief \see IfxStdIf_Pos_ResetFaults */
|
|
IfxStdIf_Pos_GetSpeed getSpeed; /**< \brief \see IfxStdIf_Pos_GetSpeed */
|
|
IfxStdIf_Pos_Update update; /**< \brief \see IfxStdIf_Pos_Update */
|
|
IfxStdIf_Pos_SetOffset setOffset; /**< \brief \see IfxStdIf_Pos_SetOffset */
|
|
IfxStdIf_Pos_SetPosition setPosition; /**< \brief \see IfxStdIf_Pos_SetPosition */
|
|
IfxStdIf_Pos_SetRawPosition setRawPosition; /**< \brief \see IfxStdIf_Pos_SetRawPosition */
|
|
IfxStdIf_Pos_SetSpeed setSpeed; /**< \brief \see IfxStdIf_Pos_SetSpeed */
|
|
IfxStdIf_Pos_SetRefreshPeriod setRefreshPeriod; /**< \brief \see IfxStdIf_Pos_SetRefreshPeriod */
|
|
};
|
|
|
|
/** \brief Position interface configuration */
|
|
typedef struct
|
|
{
|
|
sint32 offset; /**< \brief Position sensor offset */
|
|
boolean reversed; /**< \brief If true, the sensor direction is reversed */
|
|
sint32 resolution; /**< \brief Sensor resolution. For encoder with 1024 pulse per revolution, the value should be 1024 */
|
|
uint16 periodPerRotation; /**< \brief Number of period per rotation. Is usually 1 for encoder */
|
|
IfxStdIf_Pos_ResolutionFactor resolutionFactor; /**< \brief Resolution multiplier for encoder interface, valid is 2, 4. */
|
|
float32 updatePeriod; /**< \brief period in seconds, at which the application calls IfxStdIf_Pos_update() */
|
|
float32 speedModeThreshold; /**< \brief Speed threshold used for the speed calculation mode. For encoder, above the threshold the pulse count mode is used, below the threshold, the time delta is used */
|
|
float32 minSpeed; /**< \brief Absolute minimal allowed speed. below speed is recognized as 0rad/s */
|
|
float32 maxSpeed; /**< \brief Absolute maximal allowed speed. Above speed is recognized as error */
|
|
boolean speedFilterEnabled; /**< \brief Enable / disable the speed low pass filter */
|
|
float32 speedFilerCutOffFrequency; /**< \brief Speed low pass filter cut off frequency */
|
|
} IfxStdIf_Pos_Config;
|
|
|
|
/** \addtogroup library_srvsw_stdif_posif
|
|
* \{
|
|
*/
|
|
|
|
/** \copydoc IfxStdIf_Pos_OnZeroIrq
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_onZeroIrq(IfxStdIf_Pos *stdIf)
|
|
{
|
|
stdIf->onZeroIrq(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetAbsolutePosition
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_getAbsolutePosition(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getAbsolutePosition(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetFault MCMETILLD-521
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE IfxStdIf_Pos_Status IfxStdIf_Pos_getFault(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getFault(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetOffset
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE sint32 IfxStdIf_Pos_getOffset(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getOffset(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetPosition
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_getPosition(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getPosition(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetDirection
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE IfxStdIf_Pos_Dir IfxStdIf_Pos_getDirection(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getDirection(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetPeriodPerRotation
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE uint16 IfxStdIf_Pos_getPeriodPerRotation(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getPeriodPerRotation(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetRawPosition
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE sint32 IfxStdIf_Pos_getRawPosition(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getRawPosition(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetRefreshPeriod
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_getRefreshPeriod(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getRefreshPeriod(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetResolution
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE sint32 IfxStdIf_Pos_getResolution(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getResolution(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetTurn
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE sint32 IfxStdIf_Pos_getTurn(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getTurn(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetSensorType
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE IfxStdIf_Pos_SensorType IfxStdIf_Pos_getSensorType(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getSensorType(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_GetSpeed
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_getSpeed(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return stdIf->getSpeed(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** Check whether the sensor is faulty
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE boolean IfxStdIf_Pos_isFault(IfxStdIf_Pos *stdIf)
|
|
{
|
|
return IfxStdIf_Pos_getFault(stdIf).status != 0;
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_OnEventA
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_onEventA(IfxStdIf_Pos *stdIf)
|
|
{
|
|
stdIf->onEventA(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_Update
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_update(IfxStdIf_Pos *stdIf)
|
|
{
|
|
stdIf->update(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_Reset
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_reset(IfxStdIf_Pos *stdIf)
|
|
{
|
|
stdIf->reset(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_ResetFaults
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_resetFaults(IfxStdIf_Pos *stdIf)
|
|
{
|
|
stdIf->resetFaults(stdIf->driver);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_SetOffset
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_setOffset(IfxStdIf_Pos *stdIf, sint32 offset)
|
|
{
|
|
stdIf->setOffset(stdIf->driver, offset);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_SetPosition
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_setPosition(IfxStdIf_Pos *stdIf, float32 position)
|
|
{
|
|
stdIf->setPosition(stdIf->driver, position);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_SetRawPosition
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_setRawPosition(IfxStdIf_Pos *stdIf, sint32 position)
|
|
{
|
|
stdIf->setRawPosition(stdIf->driver, position);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_SetSpeed
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_setSpeed(IfxStdIf_Pos *stdIf, float32 speed)
|
|
{
|
|
stdIf->setSpeed(stdIf->driver, speed);
|
|
}
|
|
|
|
|
|
/** \copydoc IfxStdIf_Pos_SetRefreshPeriod
|
|
* \param stdIf Standard interface pointer
|
|
*/
|
|
IFX_INLINE void IfxStdIf_Pos_setRefreshPeriod(IfxStdIf_Pos *stdIf, float32 updatePeriod)
|
|
{
|
|
stdIf->setRefreshPeriod(stdIf->driver, updatePeriod);
|
|
}
|
|
|
|
|
|
/** \} */
|
|
|
|
/** \brief Converts from rad/s to rpm
|
|
*
|
|
* \param speed Specifies the speed in rad/s.
|
|
*
|
|
* \return returns the converted speed in rpm.
|
|
* \see IfxStdIf_Pos_rpmToRads()
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_radsToRpm(float32 speed)
|
|
{
|
|
return (60.0 / (2.0 * IFX_PI)) * speed;
|
|
}
|
|
|
|
|
|
/** \brief Converts from rpm to rad/s
|
|
*
|
|
* \param speed Specifies the speed in rpm.
|
|
*
|
|
* \return returns the converted speed in rad/s.
|
|
* \see IfxStdIf_Pos_radsToRpm()
|
|
*/
|
|
IFX_INLINE float32 IfxStdIf_Pos_rpmToRads(float32 speed)
|
|
{
|
|
return speed * ((2.0 * IFX_PI) / 60.0);
|
|
}
|
|
|
|
|
|
/** Initialize the configuration structure to default
|
|
*
|
|
* \param config Position interface configuration. This parameter is initialized by the function
|
|
*
|
|
*/
|
|
IFX_EXTERN void IfxStdIf_Pos_initConfig(IfxStdIf_Pos_Config *config);
|
|
|
|
/** \brief Print the device status
|
|
*
|
|
* \param driver driver handle
|
|
* \param io Interface to which the status is output
|
|
* \return none
|
|
*/
|
|
IFX_EXTERN void IfxStdIf_Pos_printStatus(IfxStdIf_Pos *driver, IfxStdIf_DPipe *io);
|
|
|
|
|
|
#endif /* IFXSTDIF_POSIF_H */
|