dapa.c

传感器网络中的嵌入式操作系统源代码

  case PAT_STK200:
    if (b) {
      /* Make sure outputs are enabled.  */
      ParportSetDir(0);
      SckDelay();
      par_data &= ~STK2_ENA1;
      ParportWriteData();
    } else {
      par_data |= STK2_ENA1;
      ParportWriteData();
      if (!no_ps2_hack) {
        /* Experimental: disable outputs (PS/2 parallel port), for cheap
	   STK200-like cable without the '244.  Should work with the real
           STK200 too (disabled outputs should still have pull-up resistors,
	   ENA1 and ENA2 are high, and the '244 remains disabled).
	   This way the SPI pins can be used by the application too.
	   Please report if it doesn't work on some parallel ports.  */
	SckDelay();
	ParportSetDir(1);
      }
    }
    break;

  case PAT_ABB:
    if (b) {
      ParportSetDir(0);
      par_ctrl |= ABB_EN;
      ParportWriteCtrl();
    } else {
      par_ctrl &= ~ABB_EN;
      ParportWriteCtrl();
      if (!no_ps2_hack) {
	SckDelay();
	ParportSetDir(1);
      }
    }
    break;

  case PAT_AVRISP:
    if (b) {
      ParportSetDir(0);
      SckDelay();
      par_data &= ~AISP_ENA;
      ParportWriteData();
    } else {
      par_data |= AISP_ENA;
      ParportWriteData();
      if (!no_ps2_hack) {
	SckDelay();
	ParportSetDir(1);
      }
    }
    break;

  case PAT_BSD:
    if (b) {
      ParportSetDir(0);
      SckDelay();
      par_data &= ~BSD_ENA;
      ParportWriteData();
    } else {
      par_data |= BSD_ENA;
      ParportWriteData();
      if (!no_ps2_hack) {
	SckDelay();
	ParportSetDir(1);
      }
    }
    break;

  case PAT_XIL:
    if (b) {
      ParportSetDir(0);
      par_data &= ~XIL_ENA;
      ParportWriteData();
    } else {
      par_data |= XIL_ENA;
      ParportWriteData();
      if (!no_ps2_hack) {
	SckDelay();
	ParportSetDir(1);
      }
    }
    break;

  case PAT_DASA:
  case PAT_DASA2:
    break;
  }
}

void
TDAPA::OutEnaSck(int b)
{
  switch (pa_type) {
  case PAT_STK200:
    if (b)
      par_data &= ~(STK2_ENA2 | STK2_LED);
    else
      par_data |= (STK2_ENA2 | STK2_LED);
    ParportWriteData();
    break;

  case PAT_DAPA:
  case PAT_DAPA_2:
  case PAT_ABB:
  case PAT_AVRISP:
  case PAT_BSD:
  case PAT_FBPRG:
  case PAT_DT006:
  case PAT_ETT:
  case PAT_MAXI:
  case PAT_XIL:
  case PAT_DASA:
  case PAT_DASA2:
    /* no separate enable for SCK nad MOSI */
    break;
  }
}

void
TDAPA::PulseSck()
{
  SckDelay();
  OutSck(1);
  SckDelay();
  OutSck(0);
}

void
TDAPA::PulseReset()
{
  printf("pulse\n");
  /* necessary delays already included in these methods */
  OutReset(1);
  Delay_usec(1000); 
  OutReset(0);
}

void
TDAPA::OutData(int b)
{
  if (mosi_invert)
    b = !b;
#ifdef DEBUG1
  printf("%c",(b)?'D':'d');
#endif
  switch (pa_type) {
  case PAT_DAPA:
    if (b) par_data |= DAPA_DOUT; else par_data &= ~DAPA_DOUT;
    par_data &= ~0x6; //0x6
    par_data |= 0x0; //0x6
    ParportWriteData();
    break;

  case PAT_DAPA_2:
    if (b) par_data |= DAPA_DOUT; else par_data &= ~DAPA_DOUT;
    par_data &= ~0x6; //0x6
    par_data |= 0x4; //0x6
    ParportWriteData();
    break;

  case PAT_STK200:
    if (b) par_data |= STK2_DOUT; else par_data &= ~STK2_DOUT;
    ParportWriteData();
    break;

  case PAT_ABB:
    if (b) par_data |= ABB_DOUT; else par_data &= ~ABB_DOUT;
    ParportWriteData();
    break;

  case PAT_AVRISP:
    if (b) par_data |= AISP_DOUT; else par_data &= ~AISP_DOUT;
    ParportWriteData();
    break;

  case PAT_BSD:
    if (b) par_data |= BSD_DOUT; else par_data &= ~BSD_DOUT;
    ParportWriteData();
    break;

  case PAT_FBPRG:
    if (b) par_data |= FBPRG_DOUT; else par_data &= ~FBPRG_DOUT;
    ParportWriteData();
    break;

  case PAT_DT006:
    if (b) par_data |= DT006_DOUT; else par_data &= ~DT006_DOUT;
    ParportWriteData();
    break;

  case PAT_ETT:
    if (b) par_ctrl |= ETT_DOUT; else par_ctrl &= ~ETT_DOUT;
    ParportWriteCtrl();
    break;

  case PAT_MAXI:
    if (b) par_data |= MAXI_DOUT; else par_data &= ~MAXI_DOUT;
    ParportWriteData();
    break;

  case PAT_XIL:
    if (b) par_data |= XIL_DOUT; else par_data &= ~XIL_DOUT;
    ParportWriteData();
    break;

  case PAT_DASA:
#if defined(TIOCMGET) && defined(TIOCCBRK)
    ioctl(ppdev_fd, b ? TIOCSBRK : TIOCCBRK, 0);
#endif /* TIOCMGET */
    break;

  case PAT_DASA2:
#if defined(TIOCMGET)
    if (b) ser_ctrl |= TIOCM_DTR; else ser_ctrl &= ~TIOCM_DTR;
    SerialWriteCtrl();
#endif /* TIOCMGET */
    break;
  }
}

int
TDAPA::InData()
{
  int b = 0;

  switch (pa_type) {
  case PAT_DAPA:
  case PAT_DAPA_2:
  case PAT_ABB:
  case PAT_DT006:
    ParportReadStatus();
    b = (~par_status & PARPORT_STATUS_BUSY);
    break;
  case PAT_ETT:
    ParportReadStatus();
    b = (par_status & ETT_DIN);
    break;
  case PAT_STK200:
  case PAT_AVRISP:
  case PAT_BSD:
  case PAT_FBPRG:
  case PAT_MAXI:
    ParportReadStatus();
    b = (par_status & PARPORT_STATUS_ACK);
    break;
  case PAT_XIL:
    ParportReadStatus();
    b = (par_status & PARPORT_STATUS_SELECT);
    break;
  case PAT_DASA:
  case PAT_DASA2:
#ifdef TIOCMGET
    SerialReadCtrl();
#ifdef DEBUG1
    printf("%c",(ser_ctrl & TIOCM_CTS)?'I':'i');
#endif
    b = (ser_ctrl & TIOCM_CTS);
#endif /* TIOCMGET */
    break;
  }
  if (miso_invert)
    b = !b;
  return b;
}

void
TDAPA::Init()
{
  /* data=1, reset=0, sck=0 */
  switch (pa_type) {
  case PAT_DAPA:
    par_ctrl = DAPA_SCK;
    par_data = 0xFF;
    par_data &= ~0x6; //0x6
    par_data |= 0x0; //0x6
    break;
  case PAT_DAPA_2:
    par_ctrl = DAPA_SCK;
    par_data = 0xFF;
    par_data &= ~0x6; //0x6
    par_data |= 0x4; //0x6
    break;

  case PAT_STK200:
    par_ctrl = 0;
    par_data = 0xFF & ~(STK2_ENA1 | STK2_SCK);
    break;

  case PAT_ABB:
    par_ctrl = ABB_EN;
    par_data = 0xFF & ~ABB_SCK;
    break;

  case PAT_AVRISP:
    par_ctrl = 0;
    par_data = 0xFF & ~(AISP_ENA | AISP_SCK);
    break;

  case PAT_BSD:
    par_ctrl = 0;
    par_data = BSD_POWER | BSD_RESET;
    break;

  case PAT_FBPRG:
    par_ctrl = 0;
    par_data = FBPRG_POW | FBPRG_RESET;
    break;

  case PAT_ETT:
    par_ctrl = ETT_DOUT;
    par_data = ETT_SCK | ETT_RESET;
    mosi_invert = 1;
    break;

  case PAT_DT006:
  case PAT_MAXI:
    par_ctrl = 0;
    par_data = 0xFF;
    break;

  case PAT_XIL:
    par_ctrl = 0;
    par_data = 0xFF & ~(XIL_ENA | XIL_SCK | XIL_RESET);
    break;

  case PAT_DASA:
  case PAT_DASA2:
    break;
  }

  if (!pa_type_is_serial) {
    ParportWriteCtrl();
    ParportWriteData();
    SckDelay();
    ParportReadStatus();
  }

  OutEnaReset(1);
  OutReset(0);
  OutEnaSck(1);
  OutSck(0);
  /* Wait 100 ms as recommended for ATmega163 (SCK not low on power up).  */
  Delay_usec(100000);
  PulseReset();
}

int
TDAPA::SendRecv(int b)
{
  unsigned int mask, received=0;

  for (mask = 0x80; mask; mask >>= 1) {
     OutData(b & mask);
     SckDelay();
     /* MM 20020613: we used to read the bit here, but ... */
     OutSck(1);
     SckDelay();
     /* ... here we have more room for propagation delays (almost the
	whole SCK period, instead of half of it) - good for long cables,
	slow RS232 drivers/receivers, opto-isolated interfaces, etc.  */
     if (InData())
       received |= mask;
     OutSck(0);
  }
  return received;
}

int
TDAPA::Send (unsigned char* queue, int queueSize, int rec_queueSize)
{
  unsigned char *p = queue, ch;
  int i = queueSize;
  
  if (rec_queueSize==-1){rec_queueSize = queueSize;}
#ifdef DEBUG
  printf ("send(recv): ");
#endif
  while (i--){
#ifdef DEBUG
    printf ("%02X(", (unsigned int)*p);
#endif    
    ch = SendRecv(*p);
#ifdef DEBUG    
    printf ("%02X) ", (unsigned int)ch);
#endif    
    *p++ = ch;
  }
#ifdef DEBUG  
  printf ("\n");
#endif  
  return queueSize;
}


TDAPA::TDAPA(): 
  parport_base(0x378), ppdev_fd(-1)
{
  const char *val;

  /* If the user doesn't specify -dlpt option, use /dev/parport0 as the
     default instead of defaulting to using ioperm (ick!). If the user wants
     to run uisp as root (or setuid root) they should know what they are doing
     and can suffer the consequences. Joe user should not be told about ioperm
     failure due to permission denied. */
#ifdef __CYGWIN__
  /* But on cygwin, /dev/parport0 does not exist. So... */
  const char *ppdev_name = NULL;
#else
  const char *ppdev_name = "/dev/parport0";
#endif

  /* Enable Parallel Port */
  val = GetCmdParam("-dprog");
  if (val && strcmp(val, "dapa") == 0)
    pa_type = PAT_DAPA;
  else if (val && strcmp(val, "dapa_2") == 0)
    pa_type = PAT_DAPA_2;
  else if (val && strcmp(val, "stk200") == 0)
    pa_type = PAT_STK200;
  else if (val && strcmp(val, "abb") == 0)
    pa_type = PAT_ABB;
  else if (val && strcmp(val, "avrisp") == 0)
    pa_type = PAT_AVRISP;
  else if (val && strcmp(val, "bsd") == 0)
    pa_type = PAT_BSD;
  else if (val && strcmp(val, "fbprg") == 0)
    pa_type = PAT_FBPRG;
  else if (val && strcmp(val, "dt006") == 0)
    pa_type = PAT_DT006;
  else if (val && strcmp(val, "ett") == 0)
    pa_type = PAT_ETT;
  else if (val && strcmp(val, "maxi") == 0)
    pa_type = PAT_MAXI;
  else if (val && strcmp(val, "xil") == 0)
    pa_type = PAT_XIL;
  else if (val && strcmp(val, "dasa") == 0)
    pa_type = PAT_DASA;
  else if (val && strcmp(val, "dasa2") == 0)
    pa_type = PAT_DASA2;
  else {
    throw Error_Device("Direct Parallel Access not defined.");
  }
  pa_type_is_serial = (pa_type == PAT_DASA || pa_type == PAT_DASA2);
  /* Parse Command Line Switches */
#ifndef NO_DIRECT_IO
  if ((val = GetCmdParam("-dlpt")) != NULL) {
    if (!strcmp(val, "1")) {
      parport_base = 0x378;
      ppdev_name = NULL;
    }
    else if (!strcmp(val, "2")) {
      parport_base = 0x278;
      ppdev_name = NULL;
    }
    else if (!strcmp(val, "3")) {
      parport_base = 0x3bc;
      ppdev_name = NULL;
    }    
    else if (*val != '/') {
      parport_base = strtol(val, NULL, 0);
      ppdev_name = NULL;
    }
    else {
      ppdev_name = val;
    }
  }
  if (!ppdev_name && !pa_type_is_serial) {
    if (parport_base!=0x278 && parport_base!=0x378 && parport_base!=0x3bc) {
      /* TODO: option to override this if you really know
	 what you're doing (only if running as root).  */
      throw Error_Device("Bad device address.");
    }
    if (ioport_enable(IOBASE, IOSIZE) != 0) {
      perror("ioperm");
      throw Error_Device("Failed to get direct I/O port access.");
    }
  }
#endif

  /* Drop privileges (if installed setuid root - NOT RECOMMENDED).  */
  setgid(getgid());
  setuid(getuid());

#ifdef NO_DIRECT_IO
  if ((val = GetCmdParam("-dlpt")) != NULL) {
    ppdev_name = val;
  }
#endif

  if (ppdev_name) {
    if (pa_type_is_serial) {
      ppdev_fd = open(ppdev_name, O_RDWR | O_NOCTTY | O_NONBLOCK);
      if (ppdev_fd != -1) {
	struct termios pmode;

	tcgetattr(ppdev_fd, &pmode);
	saved_modes = pmode;

	cfmakeraw(&pmode);
	pmode.c_iflag &= ~(INPCK | IXOFF | IXON);
	pmode.c_cflag &= ~(HUPCL | CSTOPB | CRTSCTS);
	pmode.c_cflag |= (CLOCAL | CREAD);
	pmode.c_cc [VMIN] = 1;
	pmode.c_cc [VTIME] = 0;

	tcsetattr(ppdev_fd, TCSANOW, &pmode);

	/* Clear O_NONBLOCK flag.  */
	int flags = fcntl(ppdev_fd, F_GETFL, 0);
	if (flags == -1) { throw Error_C("Can not get flags"); }
	flags &= ~O_NONBLOCK;
	if (fcntl(ppdev_fd, F_SETFL, flags) == -1) { 
          throw Error_C("Can not clear nonblock flag");
        }
      }
    } else {
      ppdev_fd = open(ppdev_name, O_RDWR, 0);
    }
    if (ppdev_fd == -1) {
      perror(ppdev_name);
      throw Error_Device("Failed to open ppdev.");
    }
    if (!pa_type_is_serial && par_claim(ppdev_fd) != 0) {
      perror("ioctl PPCLAIM");
      close(ppdev_fd);
      ppdev_fd = -1;
      throw Error_Device("Failed to claim ppdev.");
    }
  }
  t_sck = SCK_DELAY;
  if (pa_type_is_serial)
    t_sck *= 3;  /* more delay for slow RS232 drivers */
  val = GetCmdParam("-dt_sck");
  if (val)
    t_sck = strtol(val, NULL, 0);

  sck_invert = 0;
  mosi_invert = 0;
  miso_invert = 0;
  reset_invert = 0;
  if ((val=GetCmdParam("-dinvert")))
    {
#define MAXLINESIZE    256
      char temp[MAXLINESIZE];
      char * p;
      strncpy(temp, val, MAXLINESIZE-1);
      temp[MAXLINESIZE-1] = '\0';
      for (p=temp; *p; p++)
        *p=toupper(*p);
      Info(3, "Inverting %s\n",temp);
      if (strstr(temp,"SCK"))
        sck_invert=1;

      if (strstr(temp,"MOSI"))
        mosi_invert=1;

      if (strstr(temp,"MISO"))
        miso_invert=1;

      if (strstr(temp,"RESET"))
        reset_invert=1;
    }

  reset_high_time = RESET_HIGH_TIME;
  if ((val=GetCmdParam("-dt_reset")))
    {
      reset_high_time = atoi(val);
    }
  Info(3, "Reset inactive time (t_reset) %d us\n", reset_high_time);

  Init();
}

TDAPA::~TDAPA()
{
  OutData(1); SckDelay();
  OutSck(1); SckDelay();
  OutEnaSck(0);
  OutReset(1);
  OutEnaReset(0);

  if (ppdev_fd != -1) {
    if (pa_type_is_serial)
      tcsetattr(ppdev_fd, TCSADRAIN, &saved_modes);
    else
      par_release(ppdev_fd);
    close(ppdev_fd);
    ppdev_fd = -1;
  } else
    (void) ioport_disable(IOBASE, IOSIZE);
}

#endif
/* eof */