notify1.c -- Create notify object and wait for events.
/* notify1.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.
*/
/*
:Create notify object and wait for events.
Create a thread that uses a notify object to wait for user-defined events
passed to the notify object from the main thread.
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 <string.h>
#include "stdmpi.h"
#include "stdmei.h"
#include "apputil.h"
#if defined(ARG_MAIN_RENAME)
#define main notify1Main
argMainRENAME(main, notify1)
#endif
/* Command line arguments and defaults */
Arg argList[] = {
{ NULL, ArgTypeINVALID, NULL, }
};
Static long NotifyWaitAwake;
Static long
notifyWait(MPINotify notify);
int
main(int argc,
char *argv[])
{
MPIControl control; /* Motion controller handle */
MPINotify notify; /* Event notification object */
MPIEventMask eventMask;
long returnValue; /* Return value from library */
long eventDone;
MPIControlType controlType;
MPIControlAddress controlAddress;
long argIndex;
Thread thread;
ThreadStatus status;
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) {
meiPlatformConsole("usage: %s %s\n",
argv[0],
ArgUSAGE);
exit(MPIMessageARG_INVALID);
}
/* Create motion controller object */
control =
mpiControlCreate(controlType,
&controlAddress);
msgCHECK(mpiControlValidate(control));
/* Initialize motion controller */
returnValue = mpiControlInit(control);
msgCHECK(returnValue);
/* Request notification of ALL events */
mpiEventMaskCLEAR(eventMask);
mpiEventMaskALL(eventMask);
/* Create event notification object */
notify =
mpiNotifyCreate(eventMask,
NULL);
msgCHECK(mpiNotifyValidate(notify));
if (returnValue == MPIMessageOK) {
thread = threadCreate(NULL);
returnValue = threadValidate(thread);
}
if (returnValue == MPIMessageOK) {
returnValue =
threadStart(thread,
(THREAD_FUNCTION)notifyWait,
notify);
}
eventDone = FALSE;
while ((returnValue == MPIMessageOK) &&
(eventDone == FALSE)) {
char buffer[128];
long index;
long haveEventNumber;
/* Wait for notifyWait() to call mpiNotifyEventWait() */
while (NotifyWaitAwake != FALSE) {
meiPlatformSleep(1);
}
/* Make sure notifyWait() thread is still executing */
returnValue =
threadStatus(thread,
&status);
if (returnValue != MPIMessageOK) {
break;
}
if (status.active == FALSE) {
break;
}
meiPlatformConsole("Enter an event number, or ESC to exit ...\n");
memset(buffer, 0, sizeof(buffer));
index = 0;
haveEventNumber = FALSE;
while (haveEventNumber == FALSE) {
MPIEventStatus eventStatus;
long key;
long eventNumber = 0;
key = meiPlatformKey(MPIWaitFOREVER);
if (key <= 0) {
meiPlatformKey(MPIWaitFOREVER);
continue;
}
switch (key) {
case 0x1b: { /* ESC */
eventNumber = key;
haveEventNumber = TRUE;
eventDone = TRUE;
break;
}
case '\r':
case '\n': {
meiPlatformConsole("\n");
eventNumber = meiPlatformAtol(buffer);
haveEventNumber = TRUE;
break;
}
case '\b': {
if (index > 0) {
meiPlatformConsole("\b \b");
buffer[--index] = '\0';
}
break;
}
case '-': {
if (index == 0) {
buffer[index++] = (char)key;
meiPlatformConsole("%c", key);
}
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': {
buffer[index++] = (char)key;
meiPlatformConsole("%c", key);
break;
}
default: {
break;
}
}
if (haveEventNumber != FALSE) {
NotifyWaitAwake = TRUE;
eventStatus.type = MPIEventTypeEXTERNAL;
eventStatus.source = NULL;
eventStatus.info[0] = eventNumber;
returnValue =
mpiNotifyEventWake(notify,
&eventStatus);
}
}
}
if (thread != NULL) {
while (returnValue == MPIMessageOK) {
returnValue =
threadStatus(thread,
&status);
msgCHECK(returnValue);
if (status.active == FALSE) {
returnValue = status.returnValue;
break;
}
meiPlatformSleep(1);
}
returnValue = threadDelete(thread);
msgCHECK(returnValue);
}
fprintf(stderr,
"%s exiting: returnValue 0x%x: %s\n",
argv[0],
returnValue,
mpiMessage(returnValue, NULL));
returnValue = mpiNotifyDelete(notify);
msgCHECK(returnValue);
returnValue = mpiControlDelete(control);
msgCHECK(returnValue);
return ((int)returnValue);
}
Static long
notifyWait(MPINotify notify)
{
long returnValue;
MPIWait timeout;
long eventDone;
/* Validate the notify object and its handle */
returnValue = mpiNotifyValidate(notify);
timeout = MPIWaitFOREVER;
eventDone = FALSE;
while ((returnValue == MPIMessageOK) &&
(eventDone == FALSE)) {
MPIEventStatus eventStatus;
NotifyWaitAwake = FALSE;
/* Wait for notify event */
returnValue =
mpiNotifyEventWait(notify,
&eventStatus,
timeout);
meiPlatformConsole("mpiNotifyEventWait(0x%x, 0x%x, %d) returns 0x%x: %s\n",
notify,
&eventStatus,
timeout,
returnValue,
mpiMessage(returnValue, NULL));
switch (returnValue) {
case MPIMessageOK: {
meiPlatformConsole("\teventStatus: type %d number %d\n",
eventStatus.type,
eventStatus.info[0]);
if (eventStatus.info[0] == 0x1b) {
eventDone = TRUE;
}
break;
}
case MPIMessageTIMEOUT: {
meiPlatformConsole("\tTIMEOUT\n");
break;
}
default: {
break;
}
}
}
meiPlatformConsole("notifyWait(0x%x) returning 0x%x: %s\n",
notify,
returnValue,
mpiMessage(returnValue, NULL));
return (returnValue);
}
|
