- add torque, load limits. Need plus/minus limits on all
following modes
- verify parameter components definitions are complete
virtual STDMETHODIMP getActualPosition(/*[out,retval]*/ Length * a);
Should rotational and translational Axis or at least Parametric components be defined?
Axis may be of two kinds: rotational and translational, modeled as respective subclasses. Each subclass may be further specialized, corresponding to constituent physical components and control components and their interconnections. The properties of an axis of motion may be derived from its constituent model, at the time of configuration, setup, or calibration. Such a modeling framework allows uniform integration of design information into control information.
TODO: This has not been integrated into API.
This must all be predetermined. The outer level servo loop is responsible for sequencing the position servo, then the velocity servo, etc. This would have to be specialized to account for the type of hardware the servos are attached to and the kind of setpoints they expect to receive (e.g., velocity or torque). The only other option is configuration through lots of innsies/outsies "switches".
errorFollowingAccelerationAction()
for cleanup (FIXME: this cycle or next?)
/*
* Get the commanded input (or desired) position for the axis.
* @parameter pVal pointer to AxisPositionCmd variable, with units in meters.
* Returned value is numeric_limits::quiet_NaN() if undefined or not implemented.
* @return S_OK -
if successful.
* @return E_FAIL -
if implemented but not defined.
* @return E_NOTIMP -
if not implemented.
*/
STDMETHODIMP CAxisCommandedInput::getPositionCmdInput(/*[out,retval]*/ AxisPositionCmd * pVal)
STDMETHODIMP CAxisCommandedInput::updateCommandedInput()
IOPoint->isEnabled()
?
If so, does it throw an error? Who does scaling and conversion?
* Method to run an Axis Commanded Output module cycle.
* Before writing output, clamp the servo output.
* The IO will scale output values and convert to raw units.
* Update will actually write to output IO points.
* FIXME: does this module need to know if IO is enabled.
* Action to update axis motion under incrementing control.
* FIXME: At a higher level, an update event causes this action to be undertaken.
* Is this true.
Not sure.
Some ask axis to home.
Some command axis that this is home. Someone smarter that the axis can tell some offset
from the current position to use as home. Provide better axis homing API. Maybe UnsetHome()
.
Setting zero position. Problem comes in when you are in the ENABLED, you want to be
servoing. This can lead to a problem when you go into enabled. Should, be holding
position. Difficult to do. Stop following velocity, causes velocity to go to zero. Now,
holding zero velocity.
interface AxisAccelerationServo;
interface CAxisAcclerationServo() : IAxisAccelerationServo
{ IControlLaw acclerationcontrollaw;
};
double getAbsolutePosition()
removed from API? Therefore, took getAbsolutePosition()
out of API. Use frames instead of
datum to modify origin.
HRESULT _stdcall getMaxAcceleration([out, retval] LinearAcceleration *pVal);
is no longer a problem. Assume marshal by value, not reference. (Receive a copy of the value.)
Approach says to define a specialization of axis base container class.
Now have an axis actuator class specialization. It is felt that this case is common enough (especially in robotics) to be added into the reference architecture.
isDone()
? Does stopFollowingPosition stop
within one cycle? Yes, added Stopping state and stoppingAction to most pluggable motion control components (e.g., followPosition, jogging, etc.).
To localize parameter information. Although used by Axis Group, is accessible via Axis.
Assume higher level component is monitoring for these errors. But, should we assume/specify some sort of safeguards for some and not for others? For example, if a limit has been exceeded, Axis will automatically go into a certain mode and ignore further commands?
The dynamics is in the Axis only for informative purposes, to localize information about the axis and to allow others to query it about its capabilities/limits.