dapa.c

无线传感器网络操作系统源代码

      ParportSetDir(1);
    }
    break;

  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_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_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)
{
  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;

#ifdef TIOCMGET
  case PAT_DASA:
    ioctl(ppdev_fd, b ? TIOCSBRK : TIOCCBRK, 0);
    break;

  case PAT_DASA2:
    SerialReadCtrl();
    if (b) ser_ctrl |= TIOCM_DTR; else ser_ctrl &= ~TIOCM_DTR;
    SerialWriteCtrl();
    break;
#else
  case PAT_DASA:
  case PAT_DASA2:
    break;

#endif /* TIOCMGET */
  }
}

int
TDAPA::InData()
{
#ifdef TIOCMGET
  switch (pa_type) {
  case PAT_DASA:
  case PAT_DASA2:
    SerialReadCtrl();
    return (ser_ctrl & TIOCM_CTS);
  default:
    break;
  }
#endif /* TIOCMGET */
  ParportReadStatus();
  switch (pa_type) {
  case PAT_DAPA:
  case PAT_DAPA_2:
    return (~par_status & DAPA_DIN);
  case PAT_STK200:
    return (par_status & STK2_DIN);
  case PAT_ABB:
    return (~par_status & ABB_DIN);
  case PAT_AVRISP:
    return (par_status & AISP_DIN);
  case PAT_BSD:
    return (par_status & BSD_DIN);
  case PAT_FBPRG:
    return (par_status & FBPRG_DIN);
  case PAT_DT006:
    return (~par_status & DT006_DIN);
  case PAT_DASA:
  case PAT_DASA2:
    break;
  }
  return 0;
}

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 = 0xFF & ~(BSD_ENA | BSD_SCK);
    break;

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

  case PAT_DT006:
    par_ctrl = 0;
    par_data = 0xFF;
    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();
     if (InData())
       received |= mask;
     OutSck(1);
     SckDelay();
     OutSck(0);
  }
  return received;
}

int
TDAPA::Send (unsigned char* queue, int queueSize, int rec_queueSize=-1){
  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;
  const char *ppdev_name = NULL;

  /* 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, "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;}
    else if (!strcmp(val, "2")){parport_base = 0x278;}
    else if (!strcmp(val, "3")){parport_base = 0x3bc;}    
    else if (*val != '/') { parport_base = strtol(val, NULL, 0); }
    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;
  } else {
    ppdev_name = "/dev/parport0";
  }
#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(); }
	flags &= ~O_NONBLOCK;
	if (fcntl(ppdev_fd, F_SETFL, flags) == -1) { throw Error_C(); }
      }
    } 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);
  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 */