stepcfg.c -- Configure a motor as a stepper motor
/* stepcfg.c */
/* Copyright(c) 1991-2006 by Motion Engineering, Inc. All rights reserved.
*
* This software contains proprietary and confidential information of
* Motion Engineering Inc., and its suppliers. Except as may be set forth
* in the license agreement under which this software is supplied, use,
* disclosure, or reproduction is prohibited without the prior express
* written consent of Motion Engineering, Inc.
*/
/*
:Configure a motor as a stepper motor
This program will configure the motor and filter parameters for a motor to allow
the motor to control a stepper motor. The motor type is set to stepper, and
the pulse width is set (default is 25.5 microseconds), and the loop back mode
is set. If loop back is set to TRUE, then the stepper pusles are read by the
encoder input that is attached to the motor.
Warning! This is a sample program to assist in the integration of an
MEI motion controller with your application. It may not contain all
of the logic and safety features that your application requires.
*/
#include <stdlib.h>
#include <stdio.h>
#include "stdmpi.h"
#include "stdmei.h"
#include "..\sqNodeLib\include\mei_rmb.h"
#include "apputil.h"
#if defined(ARG_MAIN_RENAME)
#define main stepcfgMain
argMainRENAME(main, stepcfg)
#endif
#define MOTION_NUMBER (0)
#define AXIS_NUMBER (0)
#define FILTER_NUMBER (0)
#define MOTOR_NUMBER (0)
/* LOOPBACK_CONFIG : TRUE = enable stepper loopback, FALSE = no loopback */
#define LOOPBACK_CONFIG TRUE
/* output pulse width (seconds) */
#define PULSE_WIDTH_VALUE (2.55e-5)
#undef CW_CCW_STEPPERS
#if defined CW_CCW_STEPPERS
#define IO_CONFIG_A (MEIMotorStepperPulseTypeCW)
#define IO_CONFIG_B (MEIMotorStepperPulseTypeCCW)
#else
#define IO_CONFIG_A (MEIMotorStepperPulseTypeSTEP)
#define IO_CONFIG_B (MEIMotorStepperPulseTypeDIR)
#endif
#define TRANSCEIVER_ID_A (RMBMotorIoConfigXCVR_A)
#define TRANSCEIVER_ID_B (RMBMotorIoConfigXCVR_B)
#define INVERT_BIT (FALSE)
/* Perform basic command line parsing. (-control -server -port -trace) */
void basicParsing(int argc,
char *argv[],
MPIControlType *controlType,
MPIControlAddress *controlAddress)
{
long argIndex;
/* Parse command line for Control type and address */
argIndex = argControl(argc, argv, controlType, controlAddress);
/* Check for unknown/invalid command line arguments */
if (argIndex < argc) {
fprintf(stderr,"usage: %s %s\n", argv[0], ArgUSAGE);
exit(MPIMessageARG_INVALID);
}
}
/* Create and initialize MPI objects */
void programInit(MPIControl *control,
MPIControlType controlType,
MPIControlAddress *controlAddress,
MPIMotion *motion,
long motionNumber,
MPIAxis *axis,
long axisNumber,
MPIFilter *filter,
long filterNumber,
MPIMotor *motor,
long motorNumber)
{
long returnValue;
/* Create motion controller object */
*control =
mpiControlCreate(controlType,
controlAddress);
msgCHECK(mpiControlValidate(*control));
/* Initialize motion controller */
returnValue =
mpiControlInit(*control);
msgCHECK(returnValue);
/* Create axis object */
*axis =
mpiAxisCreate(*control,
axisNumber);
msgCHECK(mpiAxisValidate(*axis));
/* Create motion supervisor object with axis */
*motion =
mpiMotionCreate(*control,
motionNumber,
*axis);
msgCHECK(mpiMotionValidate(*motion));
/* Create filter object */
*filter =
mpiFilterCreate(*control,
filterNumber);
msgCHECK(mpiFilterValidate(*filter));
/* Create motor object */
*motor =
mpiMotorCreate(*control,
motorNumber);
msgCHECK(mpiMotorValidate(*motor));
}
/* Perform certain cleanup actions and delete MPI objects */
void programCleanup(MPIControl *control,
MPIMotion *motion,
MPIAxis *axis,
MPIFilter *filter,
MPIMotor *motor)
{
long returnValue;
/* Delete motor object */
returnValue =
mpiMotorDelete(*motor);
msgCHECK(returnValue);
/* Delete filter object */
returnValue =
mpiFilterDelete(*filter);
msgCHECK(returnValue);
/* Delete motion supervisor object */
returnValue =
mpiMotionDelete(*motion);
msgCHECK(returnValue);
/* Delete axis object */
returnValue =
mpiAxisDelete(*axis);
msgCHECK(returnValue);
/* Delete motion controller object */
returnValue =
mpiControlDelete(*control);
msgCHECK(returnValue);
}
/* Disable Filter Algorithm */
void disableFilterAlgorithm(MPIFilter filter)
{
MEIFilterConfig filterConfigXmp;
long returnValue;
/* Read filter configuration */
returnValue =
mpiFilterConfigGet(filter,
NULL,
&filterConfigXmp);
msgCHECK(returnValue);
/* Set filter algorithm to NONE */
filterConfigXmp.Algorithm = MEIXmpAlgorithmNONE;
/* Set filter configuration */
returnValue =
mpiFilterConfigSet(filter,
NULL,
&filterConfigXmp);
msgCHECK(returnValue);
}
/* Configure motor for use as a stepper motor */
void configureStepperMotor(MPIMotor motor,
MEIMotorStepperPulseType xcvrAType,
long xcvrAInvert,
MEIMotorStepperPulseType xcvrBType,
long xcvrBInvert,
float pulseWidth,
long loopBack)
{
MPIMotorConfig motorConfigMPI;
MEIMotorConfig motorConfigXMP;
long returnValue;
/* Read motor configuration */
returnValue =
mpiMotorConfigGet(motor,
&motorConfigMPI,
&motorConfigXMP);
msgCHECK(returnValue);
/* Setup motor as a stepper motor */
motorConfigMPI.type = (MPIMotorType)MEIXmpMotorTypeSTEPPER;
motorConfigMPI.event[MPIEventTypeAMP_FAULT].action = MPIActionNONE;
motorConfigMPI.event[MPIEventTypeLIMIT_ERROR].action = MPIActionNONE;
motorConfigXMP.Io[TRANSCEIVER_ID_A].Type = MEIMotorIoTypePULSE_A;
motorConfigXMP.Io[TRANSCEIVER_ID_B].Type = MEIMotorIoTypePULSE_B;
motorConfigXMP.Stepper.pulseA.type = xcvrAType;
motorConfigXMP.Stepper.pulseB.type = xcvrBType;
motorConfigXMP.Stepper.pulseA.invert = xcvrAInvert;
motorConfigXMP.Stepper.pulseB.invert = xcvrBInvert;
motorConfigXMP.Stepper.pulseWidth = pulseWidth;
motorConfigXMP.Stepper.loopback = loopBack;
motorConfigXMP.disableAction = MEIMotorDisableActionNONE;
/* Set motor configuration */
returnValue =
mpiMotorConfigSet(motor,
&motorConfigMPI,
&motorConfigXMP);
msgCHECK(returnValue);
}
/* Set in position fine tolerance */
void setAxisFineTolerance(MPIAxis axis,
float fineTolerance)
{
MPIAxisConfig axisConfig;
long returnValue;
/* Read axis configuration */
returnValue =
mpiAxisConfigGet(axis,
&axisConfig,
NULL);
msgCHECK(returnValue);
/* Set axis in position fine tolerance */
axisConfig.inPosition.tolerance.positionFine = fineTolerance;
/* Set axis configuration */
returnValue =
mpiAxisConfigSet(axis,
&axisConfig,
NULL);
msgCHECK(returnValue);
}
int main(int argc,
char *argv[])
{
MPIControl control;
MPIControlType controlType;
MPIControlAddress controlAddress;
MPIMotion motion;
MPIAxis axis;
MPIFilter filter;
MPIMotor motor;
/* Perform basic command line parsing. (-control -server -port -trace) */
basicParsing(argc,
argv,
&controlType,
&controlAddress);
/* Create and initialize MPI objects */
programInit(&control,
controlType,
&controlAddress,
&motion,
MOTION_NUMBER,
&axis,
AXIS_NUMBER,
&filter,
FILTER_NUMBER,
&motor,
MOTOR_NUMBER);
/* Disable Filter Algorithm */
disableFilterAlgorithm(filter);
/* Configure motor for use as a stepper motor */
configureStepperMotor(motor,
IO_CONFIG_A,
INVERT_BIT,
IO_CONFIG_B,
INVERT_BIT,
(float)PULSE_WIDTH_VALUE,
LOOPBACK_CONFIG);
/* Set in position fine tolerance */
setAxisFineTolerance(axis,
(float)1.E8);
/* Perform certain cleanup actions and delete MPI objects */
programCleanup(&control,
&motion,
&axis,
&filter,
&motor);
return MPIMessageOK;
}
|
