seq4.c -- Perform a repeated multi-axis motion sequence, wait for
I/O, & monitor location
/* seq4.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.
*/
/*
:Perform a repeated multi-axis motion sequence, wait for I/O, & monitor location
This sample program creates a program sequencer that will generate a multi-axis
motion beween two points. The program sequencer waits for the motion to
complete in between moves. After commanding the two motions the program
sequencer waits for a transceiver I/O bit to change state (defined by
TRANSCEIVER_WAIT_ID and TRIGGER_STATE at the top of the program). Then the
sequence loops back to the beginning of the motion command sequence, and
repeats the motion until the user presses a key.
In addition there is a second program sequencer that monitors the position of
the X and Y axes. If their positions fall within a rectangle, defined by the
position array, then a transceiver bit is set (defined by TRANSCEIVER_SET_ID).
This can be used to signal process or inspection equipment to begin their
actions.
The program execution is handled entirely on the controller, with no host
computer intervention. The motion can be viewed by the Motion Console and
Motion Scope utilities.
The XMP program sequencer controls the execution of a single command or a
series of commands on the XMP controller. The program sequencer provides the
ability to execute programs directly on the XMP controller without host
intervention. Examples of individual commands that can be executed by the
program sequencer are motion, looping, conditional branching, computation,
reading and writing of memory, time delays, waiting for conditions, setting
inputs/outputs, and generation of events. This rich command set provides
capability similar to, and beyond, that provided by Programmable Logic
Controller (PLC) programs.
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 <math.h>
#include "stdmpi.h"
#include "stdmei.h"
#include "apputil.h"
#if defined(ARG_MAIN_RENAME)
#define main seq4Main
argMainRENAME(main, seq4)
#endif
#define MOTION_COUNT (2)
#define AXIS_COUNT (2)
/* Command line arguments and defaults */
long axisNumber[AXIS_COUNT] = { 0, 1, };
long motionNumber = 0;
long motorNumber = 0;
long sequenceNumber = 0;
long sequenceSize = 128;
MPIMotionType motionType = MPIMotionTypeTRAPEZOIDAL;
Arg argList[] = {
{ "-axis", ArgTypeLONG, &axisNumber[0], },
{ "-motion", ArgTypeLONG, &motionNumber, },
{ "-motor", ArgTypeLONG, &motorNumber, },
{ "-sequence", ArgTypeLONG, &sequenceNumber, },
{ "-size", ArgTypeLONG, &sequenceSize, },
{ "-type", ArgTypeLONG, &motionType, },
{ NULL, ArgTypeINVALID, NULL, }
};
double position[MOTION_COUNT][AXIS_COUNT] = {
{ 20000.0, 0.0, },
{ 0.0, 20000.0, },
};
MPITrajectory trajectory[MOTION_COUNT][AXIS_COUNT] = {
{ /* velocity accel decel jerkPercent */
{ 10000.0, 100000.0, 100000.0, 50.0, },
{ 10000.0, 100000.0, 100000.0, 50.0, },
},
{ /* velocity accel decel jerkPercent */
{ 10000.0, 100000.0, 100000.0, 50.0, },
{ 10000.0, 100000.0, 100000.0, 50.0, },
},
};
/* motion parameters */
MPIMotionSCurve sCurve[MOTION_COUNT] = {
{ &trajectory[0][0], &position[0][0], },
{ &trajectory[1][0], &position[1][0], },
};
MPIMotionTrapezoidal trapezoidal[MOTION_COUNT] = {
{ &trajectory[0][0], &position[0][0], },
{ &trajectory[1][0], &position[1][0], },
};
MPIMotionVelocity velocity[MOTION_COUNT] = {
{ &trajectory[0][0], },
{ &trajectory[1][0], },
};
typedef enum {
ExternalEventSEQUENCE_DONE,
} ExternalEvent;
/* 4 => START + MOTION_DONE + I/O + EVENT */
/* 2 => EXTERNAL_EVENT + BRANCH */
MPICommand CommandTable[(MOTION_COUNT * 4) + 2];
#define COMMAND_COUNT (sizeof(CommandTable) / sizeof(MPICommand))
#define IO_CONFIG (MEIMotorIoTypeOUTPUT) /* INPUT or OUTPUT */
/* Toggle the transceiver associated with the motor. In this case, toggle
transceiver B
*/
#define TRANSCEIVER_SET_ID (MEIMotorIoConfigIndex1) /* Motor I/O Index */
/* Define the transceiver to wait for in between motion sequences */
#define TRANSCEIVER_WAIT_ID (MEIMotorIoConfigIndex0) /* Motor I/O Index */
/* Define the trigger value for the transceiver,
MPICommandOperatorBIT_SET or MPICommandOperatorBIT_CLEAR
*/
#define TRIGGER_STATE (MPICommandOperatorBIT_SET)
MPISequence
monitorPosition(MPIControl control,
MPIMotor motor,
MPIAxis axisX,
MPIAxis axisY,
double *limitX,
double *limitY);
int
main(int argc,
char *argv[])
{
MPIControl control; /* motion controller handle */
MPIMotion motion; /* motion handle */
MPIAxis axis[AXIS_COUNT]; /* axis handles */
MPIMotor motor; /* motor handle */
MPISequence sequence; /* sequence handle */
MPISequence sequenceMonitor; /* sequence handle */
MPINotify notify; /* notification handle */
MPIEventMgr eventMgr; /* event manager handle */
MPIEventMask eventMask;
Service service;
MPICommandType type; /* command type */
MPICommandParams commandParams; /* command parameters */
MPIControlConfig controlConfig;
double limitX[AXIS_COUNT];
double limitY[AXIS_COUNT];
double limit;
long returnValue; /* return value from library */
long commandIndex; /* CommandTable[] index */
long index;
MPIControlType controlType;
MPIControlAddress controlAddress;
long argIndex;
argIndex =
argControl(argc,
argv,
&controlType,
&controlAddress);
/* Parse command line for application-specific arguments */
while (argIndex < argc) {
long argIndexNew;
argIndexNew = argSet(argList, argIndex, argc, argv);
if (argIndexNew <= argIndex) {
argIndex = argIndexNew;
break;
}
else {
argIndex = argIndexNew;
}
}
/* Check for unknown/invalid command line arguments */
if ((argIndex < argc) ||
(axisNumber[0] > (MEIXmpMAX_Axes - AXIS_COUNT)) ||
(motionNumber >= MEIXmpMAX_MSs) ||
(motorNumber >= MEIXmpMAX_Motors) ||
(sequenceNumber >= MEIXmpMAX_PSs) ||
(motionType < MPIMotionTypeFIRST) ||
(motionType >= MEIMotionTypeLAST)) {
meiPlatformConsole("usage: %s %s\n"
"\t\t[-axis # (0 .. %d)]\n"
"\t\t[-motion # (0 .. %d)]\n"
"\t\t[-motor # (0 .. %d)]\n"
"\t\t[-sequence # (0 .. %d)]\n"
"\t\t[-size # (%d)]\n"
"\t\t[-type # (0 .. %d)]\n",
argv[0],
ArgUSAGE,
MEIXmpMAX_Axes - AXIS_COUNT,
MEIXmpMAX_MSs - 1,
MEIXmpMAX_Motors - 1,
MEIXmpMAX_PSs - 1,
sequenceSize,
MEIMotionTypeLAST - 1);
exit(MPIMessageARG_INVALID);
}
switch (motionType) {
case MPIMotionTypeS_CURVE:
case MPIMotionTypeTRAPEZOIDAL:
case MPIMotionTypeVELOCITY: {
break;
}
default: {
meiPlatformConsole("%s: %d: motion type not available\n",
argv[0],
motionType);
exit(MPIMessageUNSUPPORTED);
break;
}
}
axisNumber[1] = axisNumber[0] + 1;
/* Create motion controller object */
control =
mpiControlCreate(controlType,
&controlAddress);
msgCHECK(mpiControlValidate(control));
/* Initialize motion controller */
returnValue = mpiControlInit(control);
msgCHECK(returnValue);
/* Enable a sequence engine on the controller */
returnValue =
mpiControlConfigGet(control,
&controlConfig,
NULL);
msgCHECK(returnValue);
if (controlConfig.sequenceCount <= sequenceNumber) {
controlConfig.sequenceCount = (sequenceNumber + 1);
}
returnValue =
mpiControlConfigSet(control,
&controlConfig,
NULL);
msgCHECK(returnValue);
/* Create motion object for MS number */
motion =
mpiMotionCreate(control,
motionNumber,
MPIHandleVOID);
msgCHECK(mpiMotionValidate(motion));
/* Create axis object for X_AXIS number */
axis[0] =
mpiAxisCreate(control,
axisNumber[0]);
msgCHECK(mpiAxisValidate(axis[0]));
/* Create axis object for Y_AXIS number */
axis[1] =
mpiAxisCreate(control,
axisNumber[1]);
msgCHECK(mpiAxisValidate(axis[1]));
/* Create motion axis list */
returnValue =
mpiMotionAxisListSet(motion,
AXIS_COUNT,
axis);
msgCHECK(returnValue);
/* Request notification of all events from motion */
mpiEventMaskCLEAR(eventMask);
mpiEventMaskALL(eventMask);
returnValue =
mpiMotionEventNotifySet(motion,
eventMask,
NULL);
msgCHECK(returnValue);
/* Create motor objects */
motor =
mpiMotorCreate(control,
motorNumber);
msgCHECK(mpiMotorValidate(motor));
/* Create Sequence */
sequence =
mpiSequenceCreate(control,
sequenceNumber,
sequenceSize);
msgCHECK(mpiSequenceValidate(sequence));
#if defined(_DEBUG)
returnValue =
meiObjectTraceSet(sequence,
MEISequenceTraceLOAD);
msgCHECK(returnValue);
#endif
/* Request notification of all events from sequence */
returnValue =
mpiSequenceEventNotifySet(sequence,
eventMask,
NULL);
msgCHECK(returnValue);
/* CommandTable[commandIndex] */
commandIndex = 0;
/* Create motion Commands */
for (index = 0; index < MOTION_COUNT; index++) {
MPIMotionParams *motionParams;
/* mpiMotionStart(motion, type, params); */
type = MPICommandTypeMOTION;
commandParams.motion.motionCommand = MPICommandMotionSTART;
commandParams.motion.motion = motion;
commandParams.motion.type = motionType;
motionParams = &commandParams.motion.params;
switch (motionType) {
case MPIMotionTypeS_CURVE: {
motionParams->sCurve = sCurve[index];
break;
}
case MPIMotionTypeTRAPEZOIDAL: {
motionParams->trapezoidal = trapezoidal[index];
break;
}
case MPIMotionTypeVELOCITY: {
motionParams->velocity = velocity[index];
break;
}
default: {
meiAssert(FALSE);
break;
}
}
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(type,
&commandParams,
(commandIndex == 0) ? "First" : NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
commandParams.waitEvent.handle = motion;
commandParams.waitEvent.oper = MPICommandOperatorBIT_SET;
mpiEventMaskCLEAR(commandParams.waitEvent.mask);
mpiEventMaskSET(commandParams.waitEvent.mask, MPIEventTypeMOTION_DONE);
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(MPICommandTypeWAIT_EVENT,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
commandParams.branchEvent.label = NULL;
commandParams.branchEvent.handle = motion;
commandParams.branchEvent.oper = MPICommandOperatorBIT_SET;
mpiEventMaskCLEAR(commandParams.branchEvent.mask);
mpiEventMaskMOTOR(commandParams.branchEvent.mask);
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(MPICommandTypeBRANCH_EVENT,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
/* while (mpiControlUserIoGet(control, &io), (io.input[0] & mask) == 0); */
commandParams.waitIO.type = MPIIoTypeMOTOR_GENERAL;
commandParams.waitIO.source.motor = motor;
commandParams.waitIO.oper = TRIGGER_STATE;
commandParams.waitIO.mask = 0x1 << TRANSCEIVER_WAIT_ID; /* bit 0 */
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(MPICommandTypeWAIT_IO,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
}
/* MPIEventTypeEXTERNAL */
commandParams.event.value = ExternalEventSEQUENCE_DONE;
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(MPICommandTypeEVENT,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
/* Branch to the first command of the sequence */
commandParams.branch.label = "First"; /* First command */
commandParams.branch.expr.oper = MPICommandOperatorALWAYS;
/* Create Command */
CommandTable[commandIndex] =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(CommandTable[commandIndex]));
commandIndex++;
/* Create sequence command list */
returnValue =
mpiSequenceCommandListSet(sequence,
commandIndex,
CommandTable);
msgCHECK(returnValue);
/* Create event notification object */
notify =
mpiNotifyCreate(eventMask, /* Notify of all MPI events */
MPIHandleVOID); /* Notify from all sources */
msgCHECK(mpiNotifyValidate(notify));
/* Create event manager object */
eventMgr = mpiEventMgrCreate(control);
msgCHECK(mpiEventMgrValidate(eventMgr));
/* Add notify to event manager's list */
returnValue =
mpiEventMgrNotifyAppend(eventMgr,
notify);
msgCHECK(returnValue);
/* Create service thread */
service =
serviceCreate(eventMgr,
-1, /* default (max) priority */
-1); /* -1 => enable interrupts */
meiAssert(service != NULL);
limit =
fabs(position[0][0] - position[1][0]) /
(AXIS_COUNT + 2);
if (position[0][0] < position[1][0]) {
limitX[0] = position[0][0] + limit;
limitX[1] = position[1][0] - limit;
}
else {
limitX[0] = position[1][0] + limit;
limitX[1] = position[0][0] - limit;
}
limit =
fabs(position[0][1] - position[1][1]) /
(AXIS_COUNT + 2);
if (position[0][1] < position[1][1]) {
limitY[0] = position[0][1] + limit;
limitY[1] = position[1][1] - limit;
}
else {
limitY[0] = position[1][1] + limit;
limitY[1] = position[0][1] - limit;
}
sequenceMonitor =
monitorPosition(control,
motor,
axis[0],
axis[1],
limitX,
limitY);
msgCHECK(mpiSequenceValidate(sequenceMonitor));
/* Start sequence */
returnValue =
mpiSequenceStart(sequence,
MPIHandleVOID);
if (returnValue != MPIMessageOK) {
fprintf(stderr, "%s: mpiSequenceStart() returns 0x%x: %s\n",
argv[0],
returnValue,
mpiMessage(returnValue, NULL));
exit(2);
}
meiPlatformConsole("Press any key to stop sequence\n");
while (returnValue == MPIMessageOK) {
MPIEventStatus status;
returnValue =
mpiNotifyEventWait(notify,
&status,
MPIWaitFOREVER);
if (returnValue == MPIMessageOK) {
MEIEventStatusInfo *info;
info = (MEIEventStatusInfo *)status.info;
switch (status.type) {
case MPIEventTypeNONE: { /* ignore */
meiPlatformConsole("No event ...\n");
break;
}
case MPIEventTypeAMP_FAULT:
case MPIEventTypeHOME:
case MPIEventTypeLIMIT_ERROR:
case MPIEventTypeLIMIT_HW_NEG:
case MPIEventTypeLIMIT_HW_POS:
case MPIEventTypeLIMIT_SW_NEG:
case MPIEventTypeLIMIT_SW_POS: { /* error */
long number;
number = info->type.number;
meiPlatformConsole("Event %d on motor #%d\n",
status.type,
number);
break;
}
case MPIEventTypeMOTION_DONE: {
meiPlatformConsole("Motion done\n");
break;
}
case MPIEventTypeEXTERNAL: {
switch (info->type.value) {
case ExternalEventSEQUENCE_DONE: {
meiPlatformConsole("Sequence done\n");
break;
}
default: {
meiPlatformConsole("Unknown external event: %d\n",
info->type.value);
break;
}
}
break;
}
default: {
break;
}
}
}
if (returnValue == MPIMessageOK) {
if (meiPlatformKey(MPIWaitPOLL) >= 0) {
break;
}
}
}
meiPlatformConsole("Exiting ... returnValue 0x%x: %s\n",
returnValue,
mpiMessage(returnValue, NULL));
/* Stop sequence */
returnValue = mpiSequenceStop(sequenceMonitor);
msgCHECK(returnValue);
returnValue = mpiSequenceStop(sequence);
msgCHECK(returnValue);
returnValue = mpiSequenceDelete(sequenceMonitor);
msgCHECK(returnValue);
returnValue = mpiSequenceDelete(sequence);
msgCHECK(returnValue);
returnValue = mpiMotionDelete(motion);
msgCHECK(returnValue);
for (index = 0; index < AXIS_COUNT; index++) {
returnValue = mpiAxisDelete(axis[index]);
msgCHECK(returnValue);
}
returnValue = mpiMotorDelete(motor);
msgCHECK(returnValue);
returnValue = serviceDelete(service);
msgCHECK(returnValue);
returnValue = mpiEventMgrDelete(eventMgr);
msgCHECK(returnValue);
returnValue = mpiNotifyDelete(notify);
msgCHECK(returnValue);
returnValue = mpiControlDelete(control);
msgCHECK(returnValue);
return ((int)returnValue);
}
MPISequence
monitorPosition(MPIControl control,
MPIMotor motor,
MPIAxis axisX,
MPIAxis axisY,
double *limitX,
double *limitY)
{
MEIPlatformBoardType boardType;
MPISequence sequence;
MPICommand command;
MEIMotorConfig motorConfigXmp; /* contains transceiver configuration */
MPICommandParams commandParams;
long numberX;
long numberY;
MEIXmpAxis *xmpAxisX;
MEIXmpAxis *xmpAxisY;
long *positionX;
long *positionY;
long returnValue;
boardType = meiPlatformBoardType(meiControlPlatform(control), &boardType);
returnValue =
mpiMotorConfigGet(motor,
NULL,
&motorConfigXmp);
meiAssert(returnValue == MPIMessageOK);
motorConfigXmp.Io[TRANSCEIVER_SET_ID].Type = IO_CONFIG;
returnValue =
mpiMotorConfigSet(motor,
NULL,
&motorConfigXmp);
meiAssert(returnValue == MPIMessageOK);
returnValue =
mpiAxisNumber(axisX,
&numberX);
msgCHECK(returnValue);
returnValue =
mpiAxisNumber(axisY,
&numberY);
msgCHECK(returnValue);
returnValue =
mpiAxisMemory(axisX,
(void **)&xmpAxisX);
msgCHECK(returnValue);
returnValue =
mpiAxisMemory(axisY,
(void **)&xmpAxisY);
msgCHECK(returnValue);
positionX = &xmpAxisX->ActPosition.l[0];
positionY = &xmpAxisY->ActPosition.l[0];
if (boardType == MEIPlatformBoardTypeZMP) {
positionX = &xmpAxisX->ActPosition.l[1];
positionY = &xmpAxisY->ActPosition.l[1];
}
sequence =
mpiSequenceCreate(control,
-1,
8);
msgCHECK(mpiSequenceValidate(sequence));
commandParams.branch.label = "IoBitClear";
commandParams.branch.expr.address.l = positionX;
commandParams.branch.expr.oper = MPICommandOperatorLESS;
commandParams.branch.expr.by.value.l = (long)limitX[0];
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
"First");
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.branch.label = "IoBitClear";
commandParams.branch.expr.address.l = positionX;
commandParams.branch.expr.oper = MPICommandOperatorGREATER;
commandParams.branch.expr.by.value.l = (long)limitX[1];
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.branch.label = "IoBitClear";
commandParams.branch.expr.address.l = positionY;
commandParams.branch.expr.oper = MPICommandOperatorLESS;
commandParams.branch.expr.by.value.l = (long)limitY[0];
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.branch.label = "IoBitClear";
commandParams.branch.expr.address.l = positionY;
commandParams.branch.expr.oper = MPICommandOperatorGREATER;
commandParams.branch.expr.by.value.l = (long)limitY[1];
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.computeIO.type = MPIIoTypeMOTOR_GENERAL;
commandParams.computeIO.source.motor = motor;
commandParams.computeIO.oper = MPICommandOperatorOR;
commandParams.computeIO.mask = 0x1 << TRANSCEIVER_SET_ID; /* Set bit 1 */
command =
mpiCommandCreate(MPICommandTypeCOMPUTE_IO,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.branch.label = "First";
commandParams.branch.expr.oper = MPICommandOperatorALWAYS;
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.computeIO.type = MPIIoTypeMOTOR_GENERAL;
commandParams.computeIO.source.motor = motor;
commandParams.computeIO.oper = MPICommandOperatorAND;
commandParams.computeIO.mask = ~(0x1 << TRANSCEIVER_SET_ID); /* Clear bit 1 */
command =
mpiCommandCreate(MPICommandTypeCOMPUTE_IO,
&commandParams,
"IoBitClear");
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
commandParams.branch.label = "First";
commandParams.branch.expr.oper = MPICommandOperatorALWAYS;
command =
mpiCommandCreate(MPICommandTypeBRANCH,
&commandParams,
NULL);
msgCHECK(mpiCommandValidate(command));
returnValue =
mpiSequenceCommandAppend(sequence,
command);
msgCHECK(returnValue);
returnValue =
mpiSequenceStart(sequence,
MPIHandleVOID);
msgCHECK(returnValue);
return (sequence);
}
|
