emclcd.cc

CNC 的开放码,EMC2 V2.2.8版

/********************************************************************
* Description: emclcd.cc
*   EMC interface for LCD displays
*
*   Derived from a work by Fred Proctor & Will Shackleford
*
* Author: Eric H. Johnson
* License: GPL Version 2
* System: Linux
*
* Copyright (c) 2007 All rights reserved.
*
* Last change:
* $Revision: 1.2 $
* $Author: jepler $
* $Date: 2007/03/09 17:24:00 $
********************************************************************/

/*******************************************************************
*
* This program implements a limited user interface on an LCD
* display and keypad, such as the MX4 series made by Matrix Orbital.
* http://www.matrixorbital.com
*
* The layout is for a 4 line by 20 character display.
*
* Supported interfaces include Serial and USB.
*
********************************************************************/

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <dirent.h>
#include <ctype.h>
#include <math.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <time.h>

#include "rcs.hh"
#include "posemath.h"		// PM_POSE, TO_RAD
#include "emc.hh"		// EMC NML
#include "canon.hh"		// CANON_UNITS, CANON_UNITS_INCHES,MM,CM
#include "emcglb.h"		// EMC_NMLFILE, TRAJ_MAX_VELOCITY, etc.
#include "emccfg.h"		// DEFAULT_TRAJ_MAX_VELOCITY
#include "inifile.hh"		// INIFILE
#include "config.h"		// Standard path definitions
#include "rcs_print.hh"
#include "sockets.h"		// TCP/IP common socket functions
#include "shcom.hh"		// Common NML messaging routines

#define DEFAULT_SERVER		"localhost"
#define DEFAULT_PORT            13666
#define MAX_NAME_LENGTH         20
#define MAX_PRIORITY_LENGTH     12
#define MAX_STR_LENGTH          20

typedef enum { unmm, uncm, unInch, unEncoder } unitType;

typedef enum { rsIdle, rsPause, rsRun } runType;

typedef enum {
  hbIgnore = -1, hbOn, hbOff, hbOpen} heartbeatType;

typedef enum {
  blIgnore = -1, blOn, blOff, blToggle, blOpen, blBlink, blFlash} backlightType;

typedef enum {
  cuIgnore = -1, cuOn, cuOff, cuUnder, cuBlock} cursorType;

typedef enum {
  wtString, wtTitle, wtHbar, wtVbar, wtIcon, wtScroller, wtFrame, wtNum} widgetType;

typedef enum {
  kmExclusive, kmShared} keyModeType;

typedef enum {
  rmConnect, rmSuccess, rmHuh, rmListen, rmIgnore, rmKey, rmMenuEvent, rmUnknown} respMsgType;

typedef enum {
  meSelect, meUpdate, mePlus, meMinus, meEnter, meLeave, meUnknown} menuEventType;

typedef enum {
  ktLeftPress, ktLeftRelease, ktRightPress, ktRightRelease, ktUpPress, ktUpRelease,
  ktDownPress, ktDownRelease, ktMenuPress, ktMenuRelease, ktStartPress, ktStartRelease,
  ktPausePress, ktPauseRelease, ktStopPress, ktStopRelease, ktStepPress, ktStepRelease, 
  ktTestPress, ktTestRelease, ktHelpPress, ktHelpRelease,
  ktNextPress, ktNextRelease, ktPrevPress, ktPrevRelease, 
  ktEnterPress, ktEnterRelease, ktUnknown} keyType;

typedef enum {
  cpVersion, cpProtocol, cpLCD, cpWidth, cpHeight, cpCellWidth, cpCellHeight, cpUnknown
  } connectParmType;

typedef enum {
  jtCont, jtStep1, jtStep01, jtStep001, jtStep0001 } jogModeType;

typedef struct screenDef {
  char name[MAX_NAME_LENGTH];
  int wid, hgt;
  char priority[MAX_PRIORITY_LENGTH];
  heartbeatType heartbeat;
  backlightType backlight;
  int duration;
  int timeout;
  cursorType cursor;
  int cursor_x;
  int cursor_y;
} screenDef;

typedef struct widgetDef {
  char screenName[MAX_NAME_LENGTH];
  char widgetName[MAX_NAME_LENGTH];
  widgetType type;
  int x, y;
  char text[MAX_STR_LENGTH];
} widgetDef;

typedef struct keyDef {
  char key;
  keyModeType mode;
  keyType Action;
} keyDef;

typedef struct connectRec {
  char version[12];
  char protocol[12];
  int lcdWidth, lcdHeight;
  int cellWidth, cellHeight;
} connectRec;

char attrs[][12] = {
  "-name", "-wid", "-hgt", "-priority", "-heartbeat", "-backlight",
  "-duration", "-timeout", "-cursor", "-cursor_x", "-cursor_y"
};

char hbStrs[][6] = {
  "on", "off", "open"
};

char blStrs[][8] = {
  "on", "off", "toggle", "open", "blink", "flash"
};

char cuStrs[][6] = {
  "on", "off", "under", "block"
};

char typeStrs[][10] = {
  "string", "title", "hbar", "vbar", "icon", "scroller", "frame", "num"
};

char keyModes[][8] = {
  "shared", "excl"
};

char rspMsgs[][10] = {
  "connect", "success", "huh?", "listen", "ignore", "key", "menuevent", ""
};

char eventMsgs[][10] = {
  "select", "update", "plus", "minus", "enter", "leave", " "
};

char connectStrs[][12] = {
  "LCDproc", "protocol", "lcd", "wid", "hgt", "cellwid", "cellhgt", ""};

typedef enum {
  stStartup, stMain, stOpen, stMain2, stUnknown} screenType;

#define SCREEN_COUNT 4

screenDef screens[] = {
  { "startup",     -1, -1, "foreground", hbOff, blIgnore, -1, -1, cuIgnore, -1, -1 },
  { "main",        -1, -1, "background", hbOff, blIgnore, -1, -1, cuIgnore, -1, -1 },
  { "open",        -1, -1, "background", hbOff, blIgnore, -1, -1, cuIgnore, -1, -1 },
  { "main2",       -1, -1, "background", hbOff, blIgnore, -1, -1, cuIgnore, -1, -1 }
};

#define WIDGET_COUNT 29
widgetDef widgets[] = {
  { "startup", "su1", wtString, 1, 1, ""},                 // 0
  { "startup", "su2", wtString, 1, 2, "System Starting"},  // 1
  { "startup", "su3", wtString, 1, 3, "Please Wait"},      // 2
  { "startup", "su4", wtString, 14, 4, "V2.1.0"},          // 3

  { "main",    "m1",  wtString, 1, 2, "X "},               // 4
  { "main",    "m2",  wtString, 1, 3, "Y "},               // 5
  { "main",    "m3",  wtString, 11, 2, " Z"},              // 6
  { "main",    "m4",  wtString, 3, 2, "   0.00"},          // 7
  { "main",    "m5",  wtString, 3, 3, "   0.00"},          // 8
  { "main",    "m6",  wtString, 14, 2, "   0.00"},         // 9
  { "main",    "m7",  wtString, 15, 1, " Idle"},           // 10
  { "main",    "m8",  wtString, 1, 1, "<no program>"},     // 11
  { "main",    "m9",  wtString, 15, 3, "  100"},           // 12
  { "main",    "m10", wtString, 1, 4, "Jog "},             // 13
  { "main",    "m11", wtString, 6, 4, "Cont"},             // 14
  { "main",    "m12", wtHbar,   11, 4, "0"},               // 15

  { "open",    "o1",  wtString, 1, 1, "3D_Chips"},         // 16
  { "open",    "o2",  wtString, 1, 2, "arcspiral"},        // 17
  { "open",    "o3",  wtString, 1, 3, "cds"},              // 18
  { "open",    "o4",  wtString, 1, 4, "comp"},             // 19

  { "main2",   "ma1", wtString, 1, 1, "File: "},           // 20
  { "main2",   "ma2", wtString, 1, 2, "Speed: "},          // 21
  { "main2",   "ma3", wtString, 1, 3, "Power: "},          // 22
  { "main2",   "ma4", wtString, 1, 4, "Pieces: "},         // 23
  { "main2",   "ma5", wtString, 7, 1, "<none>"},           // 24
  { "main2",   "ma6", wtString, 8, 2, "100%"},             // 25
  { "main2",   "ma7", wtString, 8, 3, "100/100%"},         // 26
  { "main2",   "ma8", wtString, 9, 4, "  0"},              // 27
  { "main2",   "ma9", wtString, 18, 4, "Del"}              // 28
};

#define KEY_COUNT 28

keyDef keys[] = {
  { 'L', kmShared, ktLeftPress },    // Left Arrow
  { 'l', kmShared, ktLeftRelease },
  { 'R', kmShared, ktRightPress },   // Right Arrow
  { 'r', kmShared, ktRightRelease },
  { 'F', kmShared, ktUpPress },      // Up Arrow
  { 'f', kmShared, ktUpRelease },
  { 'B', kmShared, ktDownPress },    // Down Arrow
  { 'b', kmShared, ktDownRelease },
  { 'M', kmShared, ktMenuPress },    // Menu
  { 'm', kmShared, ktMenuRelease },
  { 'S', kmShared, ktStartPress },   // Start
  { 's', kmShared, ktStartRelease },
  { 'P', kmShared, ktPausePress },   // Pause / Resume
  { 'p', kmShared, ktPauseRelease },
  { 'A', kmShared, ktStopPress },    // Stop - Abort
  { 'a', kmShared, ktStopRelease },
  { 'I', kmShared, ktStepPress },    // Step - Increment
  { 'i', kmShared, ktStepRelease },
  { 'T', kmShared, ktTestPress },    // Test
  { 't', kmShared, ktTestRelease },
  { 'H', kmShared, ktHelpPress },    // Help
  { 'h', kmShared, ktHelpRelease },
  { 'U', kmShared, ktNextPress },    // Next
  { 'u', kmShared, ktNextRelease },
  { 'D', kmShared, ktPrevPress },    // Previous
  { 'd', kmShared, ktPrevRelease },
  { 'E', kmShared, ktEnterPress },   // Enter
  { 'e', kmShared, ktEnterRelease }
};

int sockfd = -1;
int err;
int len;
char *testMsg = "hello\n";
char buffer[255];
char *bufptr;
int screensInitialized = -1;
screenType curScreen = stStartup;
connectRec lcdParms;
char *delims = " \n\r";
char menu1[20] = "\0";
char menu2[20] = "\0";
char programName[25] = "<none>";
int totalSteps;
runType runStatus = rsIdle;
unitType units = unmm;
double conversion = 25.4;
float jogSpeed = 20.0;
jogModeType jogMode = jtCont;
int jogging = 0;
int feedOverride = 100;

static void thisQuit()
{
    EMC_NULL emc_null_msg;

    if (emcStatusBuffer != 0) {
	// wait until current message has been received
	emcCommandWaitReceived(emcCommandSerialNumber);
    }

    if (emcCommandBuffer != 0) {
	// send null message to reset serial number to original
	emc_null_msg.serial_number = saveEmcCommandSerialNumber;
	emcCommandBuffer->write(emc_null_msg);
    }
    // clean up NML buffers

    if (emcErrorBuffer != 0) {
	delete emcErrorBuffer;
	emcErrorBuffer = 0;
    }

    if (emcStatusBuffer != 0) {
	delete emcStatusBuffer;
	emcStatusBuffer = 0;
	emcStatus = 0;
    }

    if (emcCommandBuffer != 0) {
	delete emcCommandBuffer;
	emcCommandBuffer = 0;
    }

    exit(0);
}

static void sigQuit(int sig)
{
  sockClose(sockfd);
  thisQuit();
}

int preciseSleep(double sleepTime)
{
  struct timespec tv;
  int rval;

  tv.tv_sec = (time_t) sleepTime;
  tv.tv_nsec = (long) ((sleepTime - tv.tv_sec) * 1e+9);

  while (1) {
    rval = nanosleep(&tv, &tv);
    if (rval == 0)
      return 0;
    if (errno == EINTR)
      continue;
    else return(rval);
    }
  return(0);
}

static char *extractFileName(char *s)
{
  int i, len, start;
  static char fname[25] = "\0";

  len = strlen(s);
  start = len;
  if (start <= 0) return NULL;
  while (s[start] != '/' && (start>0)) start--;
  if (s[start] == '/') start++;
  for (i=start;i<(len-4);i++)
    fname[i-start] = s[i];
  return fname;
}

static char *widgetSetStr(int widgetNo, char *newStr, char *oldStr)
{
  if (strcmp(newStr, oldStr) == 0) return newStr;

  sockPrintf(sockfd, "widget_set %s %s %d %d {%s}\n", 
    widgets[widgetNo].screenName,
    widgets[widgetNo].widgetName,
    widgets[widgetNo].x,
    widgets[widgetNo].y,
    newStr);
  return newStr;
}

static int widgetSetHbar(int widgetNo, int newVal, int oldVal)
{
  char numBuf[12];

  if (oldVal == newVal) return newVal;

  sprintf(numBuf, "%d", newVal);
  sockPrintf(sockfd, "widget_set %s %s %d %d %s\n", 
    widgets[widgetNo].screenName,
    widgets[widgetNo].widgetName,
    widgets[widgetNo].x,
    widgets[widgetNo].y, 
    numBuf);
  return newVal;
}

static void intScreenSet(char *screen, char *attr,  int value)
{
  if (value != -1) {
    sockPrintf(sockfd, "screen_set %s %s %d\n", screen, attr, value);
    }
}

static void strScreenSet(char *screen, char *attr, char *s)
{
  if (s != "") {
    sockPrintf(sockfd, "screen_set %s %s %s\n", screen, attr, s);
    }
}

static void heartbeatScreenSet(char *screen, heartbeatType hb)
{
  if (hb != hbIgnore) {
    sockPrintf(sockfd, "screen_set %s %s %s\n", screen, attrs[4], hbStrs[hb]);
    }
}

static void backlightScreenSet(char *screen, backlightType bl)
{
  if (bl != blIgnore) {
    sockPrintf(sockfd, "screen_set %s %s %s\n", screen, attrs[5], blStrs[bl]);
    }
}

static void cursorScreenSet(char *screen, cursorType cu)
{
  if (cu != cuIgnore) {
    sockPrintf(sockfd, "screen_set %s %s %s\n", screen, attrs[8], cuStrs[cu]);
    }
}

static int createScreens()
{
  int i;

  for (i=0;i<SCREEN_COUNT;i++) {
    sockPrintf(sockfd, "screen_add %s\n", screens[i].name);
    intScreenSet(screens[i].name, attrs[1], screens[i].wid);
    intScreenSet(screens[i].name, attrs[2], screens[i].hgt);
    strScreenSet(screens[i].name, attrs[3], screens[i].priority);
    heartbeatScreenSet(screens[i].name, screens[i].heartbeat);
    backlightScreenSet(screens[i].name, screens[i].backlight);
    intScreenSet(screens[i].name, attrs[6], screens[i].duration);
    intScreenSet(screens[i].name, attrs[7], screens[i].timeout);
    cursorScreenSet(screens[i].name, screens[i].cursor);
    intScreenSet(screens[i].name, attrs[9], screens[i].cursor_x);
    intScreenSet(screens[i].name, attrs[10], screens[i].cursor_y);
    }
  return(0);
}

static int createWidgets()
{
  int i;

  for (i=0; i<WIDGET_COUNT; i++) {
    sockPrintf(sockfd, "widget_add %s %s %s\n", widgets[i].screenName,
      widgets[i].widgetName, typeStrs[widgets[i].type]);
    switch (widgets[i].type) {
      case wtString:
        widgetSetStr(i, widgets[i].text, ""); 
        break;
      case wtTitle: break;
      case wtHbar: 
        widgetSetStr(i, widgets[i].text, "");