mboard1.c -- Setup multiple controllers, clear positions and perform
a two-point motion.
/* mboard1.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
*/
:Setup multiple controllers, clear positions and perform a two-point motion.
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 "apputil.h"
#if defined(ARG_MAIN_RENAME)
#define main mboard1Main
argMainRENAME(main, mboard1)
#endif
#define BOARD_COUNT (2)
#define MOTION_COUNT (1)
#define AXIS_COUNT (1)
/* Command line arguments and defaults */
long controlNumber = 0;
long axisNumber = 0;
long motionNumber = 0;
MPIMotionType motionType = MPIMotionTypeTRAPEZOIDAL;
Arg argList[] = {
{ "-control", ArgTypeLONG, &controlNumber, },
{ "-axis", ArgTypeLONG, &axisNumber, },
{ "-motion", ArgTypeLONG, &motionNumber, },
{ "-type", ArgTypeLONG, &motionType, },
{ NULL, ArgTypeINVALID, NULL, }
};
double position[MOTION_COUNT][AXIS_COUNT] = {
{ 20000.0, },
};
MPITrajectory trajectory[MOTION_COUNT][AXIS_COUNT] = {
{ /* velocity accel decel */
{ 10000.0, 100000.0, 100000.0, },
},
};
/* motion parameters */
MPIMotionSCurve sCurve[MOTION_COUNT] = {
{ &trajectory[0][0], &position[0][0], },
};
MPIMotionTrapezoidal trapezoidal[MOTION_COUNT] = {
{ &trajectory[0][0], &position[0][0], },
};
MPIMotionVelocity velocity[MOTION_COUNT] = {
{ &trajectory[0][0], },
};
int
main(int argc,
char *argv[])
{
MPIControl controller[BOARD_COUNT]; /* Array of control handles */
MPIMotion motion[BOARD_COUNT]; /* Array of motion handles */
MPIAxis axis[BOARD_COUNT]; /* Array of axis handles */
MPIControlAddress controlAddress;
long returnValue;
long argIndex = 0;
long index;
/* 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 - 1) || /* minus application name */
(axisNumber >= MEIXmpMAX_Axes) ||
(motionNumber >= MEIXmpMAX_MSs) ||
(motionType < MPIMotionTypeFIRST) ||
(motionType >= MEIMotionTypeLAST)) {
meiPlatformConsole("usage: %s %s\n"
"\t\t[-axis # (0 .. %d)]\n"
"\t\t[-motion # (0 .. %d)]\n"
"\t\t[-type # (0 .. %d)]\n",
argv[0],
ArgUSAGE,
MEIXmpMAX_Axes - 1,
MEIXmpMAX_MSs - 1,
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;
}
}
/*
Initialize each controller with default settings,
specifying the board's controller number.
*/
for (index = 0; index < BOARD_COUNT; index++) {
controlAddress.number = controlNumber + index; /* setting controller number */
controller[index] =
mpiControlCreate(MPIControlTypeDEFAULT,
&controlAddress);
msgCHECK(mpiControlValidate(controller[index]));
}
/* Initialize the controllers */
for (index = 0; index < BOARD_COUNT; index++) {
returnValue = mpiControlInit(controller[index]);
if (returnValue != MPIMessageOK) {
fprintf(stderr,
"Controller #%d : mpiControlInit(0x%x) returns 0x%x: %s\n",
index,
controller[index],
returnValue,
mpiMessage(returnValue, NULL));
exit(1);
}
}
/* Obtain Axis and Motion handle for each board */
for (index = 0; index < BOARD_COUNT; index++) {
axis[index] =
mpiAxisCreate(controller[index],
axisNumber);
msgCHECK(mpiAxisValidate(axis[index]));
/* Create motion object, append axis */
motion[index] =
mpiMotionCreate(controller[index],
motionNumber,
axis[index]);
msgCHECK(mpiMotionValidate(motion[index]));
}
/* Clear the command and actual positions on each controller */
for (index = 0; index < BOARD_COUNT; index++) {
double command;
returnValue =
mpiAxisCommandPositionGet(axis[index],
&command);
msgCHECK(returnValue);
returnValue =
mpiAxisOriginSet(axis[index],
command);
msgCHECK(returnValue);
/* clear position error */
returnValue =
mpiAxisActualPositionSet(axis[index],
0.0);
msgCHECK(returnValue);
}
/* Sequentially Start motion */
for (index = 0; index < BOARD_COUNT; index++) {
MPIMotionParams motionParams;
switch (motionType) {
case MPIMotionTypeS_CURVE: {
motionParams.sCurve = sCurve[0];
break;
}
case MPIMotionTypeTRAPEZOIDAL: {
motionParams.trapezoidal = trapezoidal[0];
break;
}
case MPIMotionTypeVELOCITY: {
motionParams.velocity = velocity[0];
break;
}
default: {
meiAssert(FALSE);
break;
}
}
/* Start motion */
returnValue =
mpiMotionStart(motion[index],
motionType,
&motionParams);
fprintf(stderr,
"mpiMotionStart(0x%x, %d, 0x%x) returns 0x%x: %s\n",
motion[index],
motionType,
&motionParams,
returnValue,
mpiMessage(returnValue, NULL));
switch (returnValue) {
case MPIMotionMessageERROR: {
returnValue =
mpiMotionAction(motion[index],
MPIActionRESET);
fprintf(stderr,
"mpiMotionAction(0x%x, RESET) returns 0x%x\n",
motion[index],
returnValue);
msgCHECK(returnValue);
/* FALL THROUGH */
}
case MPIMotionMessageMOVING: {
returnValue = MPIMessageOK;
break;
}
case MPIMessageOK:
default: {
break;
}
}
}
/* Delete the Motion handles */
for (index = 0; index < BOARD_COUNT; index++) {
returnValue = mpiMotionDelete(motion[index]);
msgCHECK(returnValue);
}
/* Delete the Axis handles */
for (index = 0; index < BOARD_COUNT; index++) {
returnValue = mpiAxisDelete(axis[index]);
msgCHECK(returnValue);
}
/* Delete the CONTROL handles */
for (index = 0; index < BOARD_COUNT; index++) {
returnValue = mpiControlDelete(controller[index]);
msgCHECK(returnValue);
}
return ((int)returnValue);
}
|
