Subversion Repositories or1k

/* Calibration program for the Dynapro S3 controller */
/* Written by Jordan Crouse, September 5, 2001       */
 
/* Copyright, 2001, Century Embedded Technologies    */
 
 
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
 
#include <sys/termios.h>
#include <nano-X.h>
 
struct {
  int scrX;
  int scrY;
  int rawX;
  int rawY;
} dataPoints[4];
 
/* The current and saved termios */
static struct termios ios_saved;
static struct termios ios_current;
 
#define BGCOLOR GR_RGB(0,0,0)
#define FGCOLOR GR_RGB(255,255,255)
 
char *instructions[4] = {
  "Sony CIS Calibration",
  " ",
  "Please press on each target",
  "as they appear"
};
 
int calInitSerial(char *dev) {
 
  /* Open up the serial port */
  int fd = open(dev, O_NONBLOCK);
 
  if (fd <= 0) {
    perror("open serial");
    return(-1);
  }
 
  tcgetattr(fd, &ios_saved);
  ios_current = ios_saved;
 
  cfmakeraw(&ios_current);
 
  /* Set the baud rate */
 
  cfsetispeed(&ios_current, B2400);  
  cfsetospeed(&ios_current, B2400);
 
  /* Set the data bits and remove the parity */
  ios_current.c_cflag &= ~(CSIZE | PARENB);
  ios_current.c_cflag |= CS8;
 
  ios_current.c_cc[VMIN] = 3;
  ios_current.c_cc[VTIME] = 1;
 
  tcsetattr(fd, TCSANOW, &ios_current);
  tcflush(fd, TCIOFLUSH);
 
  return(fd);
}
 
void calCloseSerial(int fd) {
  tcsetattr(fd, TCSANOW, &ios_saved);
  tcflush(fd, TCIOFLUSH);
 
  close(fd);
}
 
int calReadSerial(int fd) {
 
  unsigned char f;
  int val = read(fd, &f, sizeof(f));
 
  if (val <= 0) return(val);
 
  return((int) f);
}
 
/* Fd is the port to watch, data is the data that we are getting */
 
int calGetInput(int fd, int *data) {
 
  int count = 0;
  int state = 0;
 
  /* Read the data coming in off the line */
 
  while(1) {
 
    int c = calReadSerial(fd);
 
    if (c < 0 && errno != EAGAIN) return(-1);
 
    if (count++ > 500) return(0);
    if (c <= 0) continue;
 
    switch(state) {
 
    case 0:
      if (c & 0x80) {
	data[0] = (unsigned char) c;
	state = 1;
      }
      else 
	fprintf(stderr, "Non start byte recieved (%2.2x)\n", c);
 
      break;
 
    case 1:
      if (!(c & 0x80)) {
	data[1] = (unsigned char) c;
	state = 2;
      }
      else {
	fprintf(stderr, "Got a start byte in the middle of the packet\n");
	data[0] = (unsigned char) c;
 
	state = 0;
      }
 
      break;
 
    case 2:
 
      if (!(c & 0x80)) {
	data[2] = (unsigned char) c;
	return(1);
      }
      else {
	fprintf(stderr, "Got a start byte in the middle of the packet\n");
	data[0] = (unsigned char) c;
 
	state = 0;
      }
 
      break;
    }
  }
 
  return(1);
}
 
 
void drawText(GR_WINDOW_ID id, char **text, int count) {
 
  int tw, th, tb;
  int xpos, ypos;
  int i;
 
  GR_GC_ID gc = GrNewGC();
  GR_FONT_ID font = GrCreateFont(GR_FONT_GUI_VAR, 12, 0);
  GR_WINDOW_INFO info;
 
  GrGetWindowInfo(id, &info);
 
  GrSetGCFont(gc, font);
  GrSetGCForeground(gc, FGCOLOR);
  GrSetGCBackground(gc, BGCOLOR);
 
  /* Get the first line of text from the array, and check the size */
  GrGetGCTextSize(gc, text[0], -1, GR_TFTOP, &tw, &th, &tb);
 
  ypos = (info.height - ((count * th)+ 3)) / 2;
 
  /* Draw each line of the instructions */
 
  for(i = 0; i < count; i++) {
    GrGetGCTextSize(gc, text[i], -1, GR_TFTOP, &tw, &th, &tb);    
    xpos = (info.width - tw) / 2;
    GrText(id, gc, xpos, ypos, text[i], -1, GR_TFTOP);
 
    ypos += th + 3;
  }
 
  GrDestroyGC(gc);
  GrDestroyFont(font);
}
 
int doPoints(GR_WINDOW_ID id, int fd) {
 
  int data[4];
  int err = 0, i;
  fd_set fdset;
 
  GR_GC_ID gc = GrNewGC();
 
  for(i = 0; i < 4; i++) {
 
    int totalx = 0, totaly = 0;
    int p;
 
    /* Clear the previous point */
 
    if (i - 1 >= 0) {
      GrSetGCForeground(gc, BGCOLOR);
      GrFillRect(id, gc, dataPoints[i - 1].scrX - 10, 
		 dataPoints[i - 1].scrY - 10, 20, 20);
    }
 
    /* Now draw the new point */
    GrSetGCForeground(gc, GR_RGB(255,0,0));
 
    GrFillRect(id, gc, dataPoints[i].scrX - 10, dataPoints[i].scrY - 1, 
	       20, 2);
 
    GrFillRect(id, gc, dataPoints[i].scrX - 1, dataPoints[i].scrY - 10, 
	       2, 20);
 
    GrFlush();
 
    /* Wait until we get a button click */
 
    FD_SET(fd, &fdset);
 
    if (select(fd + 1, &fdset, 0, 0, 0) != -1) {
      int val;
      int index = 0;
 
      while(1) {
	val = calGetInput(fd, data);
	if (val < 0) break;
	if (val == 0) continue;
 
	totaly += (data[2] | ((data[0] & 0x07) << 7));
	totalx += (data[1] | ((data[0] & 0x38) << 4));
 
	index++;
	if (!(data[0] & 0x40)) break;
      }
 
      if (index > 0) {
	dataPoints[i].rawX = totalx / index;
	dataPoints[i].rawY = totaly / index;
      }
    }
  }
 
  GrDestroyGC(gc);
  return(err);
}
 
 
int main(int argc, char **argv) {
 
  int serialFd;
  int outFd;
 
  GR_SCREEN_INFO info;
  GR_WINDOW_ID calWindow;
  GR_EVENT event;
 
  /* Open up the graphics */
 
  if (GrOpen() == -1) {
    fprintf(stderr, "Error!  Unable to open the graphics engine\n");
    return(-1);
  }
 
  /* Now open the serial port */
 
  serialFd = calInitSerial("/dev/ttyS1");
  if (serialFd == -1) {
    fprintf(stderr, "Error!  Unable to open the touchscreen device\n");
    return(-1);
  }
 
  GrGetScreenInfo(&info);
 
  /* Decide which points we are going to touch */
 
  dataPoints[0].scrX = 10; 
  dataPoints[0].scrY = 10;
 
  dataPoints[1].scrX = 10; 
  dataPoints[1].scrY = info.rows - 10;
 
  dataPoints[2].scrX = info.cols - 10; 
  dataPoints[2].scrY = info.rows - 10;
 
  dataPoints[3].scrX = info.cols - 10; 
  dataPoints[3].scrY = 10;
 
  /* Now, create a window that spans the entire size of the screen */
  calWindow = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, info.cols, info.rows, 0, BGCOLOR, FGCOLOR);
  GrSelectEvents(calWindow, GR_EVENT_MASK_EXPOSURE);
  GrMapWindow(calWindow);
  /* Wait for exposure */
  while(GrPeekEvent(&event) != GR_EVENT_TYPE_EXPOSURE);
 
  /* Ok, now that we have been exposed, draw the instructions */
  drawText(calWindow, instructions, 4);
 
  if (!doPoints(calWindow, serialFd)) {
 
    double scrXDelta, rawXDelta;
    double scrYDelta, rawYDelta;
 
    double deltaX, deltaY;
 
    scrXDelta = (double) dataPoints[2].scrX - dataPoints[0].scrX;
    rawXDelta = (double) dataPoints[2].rawX - dataPoints[0].rawX;
 
    scrYDelta = (double) dataPoints[1].scrY - dataPoints[0].scrY;
    rawYDelta = (double) dataPoints[1].rawY - dataPoints[0].rawY;
 
    /* We can now extrapolate and discover the extreme edges of the screen */
 
    /* First, the low values */
 
    deltaX = abs( (rawXDelta / scrXDelta) * ((double) dataPoints[0].scrX));
    deltaY = abs( (rawYDelta / scrYDelta) * ((double) dataPoints[0].scrY));
 
    /*
    deltaX = abs((double) dataPoints[0].scrX * rawXDelta) / scrXDelta);
    deltaY = abs((double) (dataPoints[0].scrY * rawYDelta) / scrYDelta);
    */
 
    /* Print out the raw values, accounting for possible inversion */
 
    if (dataPoints[0].rawX > dataPoints[2].rawX) {
      printf("%d ", (int) (dataPoints[0].rawX + deltaX));
      printf("%d ", (int) (dataPoints[2].rawX - deltaX));
    }
    else {
      printf("%d ", (int) (dataPoints[0].rawX - deltaX));
      printf("%d ", (int) (dataPoints[2].rawX + deltaX));
    }
 
    if (dataPoints[0].rawY >dataPoints[1].rawY) {
      printf("%d ", (int) (dataPoints[0].rawY + deltaY));
      printf("%d\n", (int) (dataPoints[1].rawY - deltaY));
    }
    else {
      printf("%d ", (int) (dataPoints[0].rawY - deltaY));
      printf("%d\n", (int) (dataPoints[1].rawY + deltaY));
    }
  }
  else {
    fprintf(stderr, "Error - Unable to read the touchscreen\n");
  }
 
  /* Close everything down */
  calCloseSerial(serialFd);
  GrClose();
 
  /* Byebye! */
  return(0);
}