UNRESOLVED TODO/ISSUES/FAQ/TBD LIST FOR AXIS MODULE

• TODO:

  - add torque, load limits. Need plus/minus limits on all following modes
  - verify parameter components definitions are complete

• only have inPosition() under Axis. What about atPosition()?, atVelocity(), atAcceleration/Torque(), atForce()?
  
• How/where is the cyclic timing parameter is specified in the Axis API?
• Do we need units? What if axis needs radians instead of positional length? Should we distinguish between linear and rotary axis? Units?

   
      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.

• How are errors signaled? Deciphered? Resolved? Check for Axis FSM state, then determine if in error state? How do you query axis about error?
  TBD. Should we have error codes: E_AMPFAULT, E_OVERHOOT, E_UNDERSHOOT, E_FOLLOWINGERROR, E_TRIPLIMIT, E_IOERROR, E_ENABLEFAULT. Error return information {initial state, event, cause, description, help pointer}. Any other trace information. Error handling wouldn't be so hard to do, if there wasn't event queuing.
  
• How is overtravel different than overshoot? Isn't overtravel in point-to-point via control or in blending?
  
• Traditional servo is position->torque output, read encoder for position feedback. Can followingVelocity just by a pass-through (possibly interpolated) to the amplifier? When is followingAcceleration used? Do we have velocity and acceleration control law so that we can do jogging trajectories?
  
• Event handling. Always assume successful event delivery? If you queue events, you can't expect to interpret the queue to interpret if the event is valid.
  
• Who is responsible for coordinating the positioning to velocity to acceleration control law propagation? How does the Axis class know what kind of desired input (such as position) to send commanded output (e.g., torque) sequence it must handle?

  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".

• Any errors during following acceleration control would result in invoking errorFollowingAccelerationAction() for cleanup (FIXME: this cycle or next?)
  
• What if getPositionCmdInput is not implemented, versus not used?

   
  /*
  * 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)
  

• Can cubic interpolation be added to IAxisCommandedInput?

   
  STDMETHODIMP CAxisCommandedInput::updateCommandedInput()
  

• Does Axis Commanded Output need to know if IO is enabled? Should it cause the IOPoint to be enabled? Does it determine it, by asking 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.

• IAxisIncrementPos:: updateIncrementingAction() who does event handling?

   
  * 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.
  

• AxisLimits::getFollowingErrorWarnLim is this for position only?
  
• How do you add a Control Plan Unit to the Axis Module? How does this effect the API, FSM, etc.?
  o How do position compare and latch enter into this?
  o How about guarded moves?
• Does enable means high power enabled (amps on) and disabled means high power disabled?
• Error/Fault and e-stop may not be the same, do all errors disable high power? (may only be an issue with axis group)
• Interpolation Issues:
  - Do I need fine interpolating mode for each following mode (rel, abs, vel, torque)? Fine interpolators need buffers (complicates error recovery)
  - For position, fine interpolators need an interpolation type and depending on type, different data (e.g. position and time, PVT, PVAJT, etc.)
  - Stop on path vs stop as fast as possible vs stop at end of current move (may be an issue with fine interpolation with a buffer, may be another reason that this belongs in axis group not axis)
  - How would you handle resume vs abort with fine interpolation? (may only be an issue with axis group)

• Who is responsible for updating AxisSensedState? Is the Axis class, through its FSM, is it responsible for calling the AxisSensedState?

  Not sure.

• How do you handle the different homing strategies? Further, have to have separate homed state before you can do certain operations.

  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. 

RESOLVED ISSUES LIST FOR AXIS MODULE

• How does one attach a Control Law to a Position/Velocity/Acceleration/Force Servo? Revisited. Where does the specialization occur? Axis Container or AxisControl class?
  • Use Specialization to extend Base Class to contain Control Law component e.g., AxisAccelerationServo may not need control law component if connected to SERCOS drive and can use the base class:

     
        interface AxisAccelerationServo;
    

  • but may need control law component if doing software servoing and required a derived class:

     
        interface CAxisAcclerationServo() : IAxisAccelerationServo 
        { IControlLaw acclerationcontrollaw;
        };
    

  • Can do this at configuration time.

• Why was double getAbsolutePosition() removed from API?
  1. There is a difference between homing and zero.
  2. Axis is not at zero when home.
  3. Consider it similar to a relative offset, or as a redefinition of origin.

  Therefore, took getAbsolutePosition() out of API. Use frames instead of datum to modify origin.

• Problem here with typedef derivative of double, versus real class definition? For example:

   
  HRESULT _stdcall getMaxAcceleration([out, retval] LinearAcceleration *pVal);
  

  is no longer a problem. Assume marshal by value, not reference. (Receive a copy of the value.)

• How does one handle multiple actuators associated to one axis?

  Approach says to define a specialization of axis base container class.

• Should actuators be a module?

  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.

• Can joggingStopping or stopFollowingPosition event take more than one cycle? How do you determine when it is done isDone()? Does stopFollowingPosition stop within one cycle?

  Yes, added Stopping state and stoppingAction to most pluggable motion control components (e.g., followPosition, jogging, etc.).

• IAxisDyn::setMaxVelAccLim - Why is this in Axis?

  To localize parameter information. Although used by Axis Group, is accessible via Axis.

• For AxisLimits::getOvershootViolationLimit, what happens upon error? Likewise, what happens for a warning.

  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?

• Dynamics appears to be in the wrong place. Why isn't it in Axis Group? The reason is due to the cross coupling of axes in a machine. For machines with varying inertia, the Axis Group cannot calculate the velocity profile without knowledge of the dynamics.

  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.

AXIS MODULE FAQ

• Error and e-stop appear to be the same, do all errors disable high power?
  No, they are different. ESTOP is handled by coming to a stop as fast as possible and then disabling power. ERROR notifies any observers that the Axis has failed, and goes into a "safe" state.
  
• How does Axis determine if there is an ESTOP?
  Axis could poll the ESTOP IOPoint, or the Axis could publish an optional ESTOP event-in. Then, a system designer could wire the system to advise the ESTOP event broker that the Axis module is a sink for the ETOP IOPoint events. The system would have to support an ESTOP IOPoint and an ESTOP Broker. These two could be combined if the ESTOP IOPoint supports the IConnectionPointContainer interface and is thus the broker as well as the IO point. The reason you would want a separate ESTOP Event Broker, is that it could centralize the management of the ESTOP and provide service to different vendor ESTOP Sink Event-In Interfaces.
  
• Who is responsible for detecting hardware limit switches tripped and reporting about it?
  The control strategy in charge is responsible for monitoring the AxisLimits, such as AxisFollowingPosition. It is also reponsible for updating the AxisSensedState, and commanded input and output.