예제 #1
0
파일: port.cpp 프로젝트: xMIRUSx/magaz
//функция поиска и подключения устройства
void FindDevice(const char* devID)
{
	ID = devID;
	strcpy(bufwr, ID);

	String port = "\\\\.\\COM";

	int i = 1;
	while ((!connected) && (i < 257))

	{
		OpenPort(port + IntToStr(i));

		if(COMport != INVALID_HANDLE_VALUE)
		{
			ResumeThread(writer);
			 Sleep(1000);
		}
		i++;
	}
	if (COMport == INVALID_HANDLE_VALUE)
	{
		Form1->Info->Lines->Add("Устройство не найдено!!!");
	}
}
예제 #2
0
int CSerialPort::InitPort(CString strComName)
{
    hSerialPort = OpenPort(strComName, CBR_9600,NOPARITY,8, ONESTOPBIT);   
    if(hSerialPort==NULL)
    {
		//MessageBox(NULL, "打开指定串口失败,请重新选择串口。","失败", MB_OK|MB_ICONWARNING);
        return -1;
    }
	CString cmd = "AT+CSCA?\r";
	char ans[128] ;
	WritePort(cmd.GetBuffer(0),strlen(cmd));
	Sleep(ShortSleepTime);
	ReadPort(ans,128);
	CString ansStr = ans;
	int cou;
	if((cou=ansStr.Find("+86")) != -1)
	{
	    m_SmsCenterNum = ansStr.Mid(cou+1,13);	
	}
	else
	{
		return -2;
	}
    return 0;
}
예제 #3
0
파일: comm.cpp 프로젝트: winsel/VS
Comm::Comm(LPCWSTR Port,bool *state)
{
	this->state = state;
	open = OpenPort(Port);
	if (open)
	{
		std::cout << "open comport success" << std::endl;
		if (setupdcb(38420))    //38240是波特率
			printf("setupDCB success\n");
		if (setuptimeout(0, 0, 0, 0, 0))
			printf("setuptimeout success\n");
		SetCommMask(GethComm(), EV_RXCHAR); //当有字符在inbuf中时产生这个事件
		//清除串口的所有操作
		PurgeComm(GethComm(), PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
		// 在读写串口之前,还要用PurgeComm()函数清空缓冲区
		//PURGE_TXABORT	  中断所有写操作并立即返回,即使写操作还没有完成。
		//PURGE_RXABORT	  中断所有读操作并立即返回,即使读操作还没有完成。
		//PURGE_TXCLEAR	  清除输出缓冲区
		//PURGE_RXCLEAR	  清除输入缓冲区
		
	}
	else
		std::cout << "cannot open the com port" << std::endl;
	
}
예제 #4
0
int
main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD");
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  NullDataHandler handler;
  std::unique_ptr<Port> port(OpenPort(config, handler));
  if (!port) {
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  ConsoleOperationEnvironment env;

  if (!port->WaitConnected(env)) {
    fprintf(stderr, "Failed to connect the port\n");
    return EXIT_FAILURE;
  }

  RunUI(*port, env);

  DeinitialiseIOThread();

  return EXIT_SUCCESS;
}
예제 #5
0
BOOL CPort::Open(const char* pszFileName, BOOL fIsSocket)
{
    RIL_LOG_VERBOSE("CPort::Open() - Enter  fIsSocket=[%d]\r\n", fIsSocket);
    BOOL fRet = FALSE;

    if (NULL == pszFileName)
    {
        RIL_LOG_CRITICAL("CPort::Open() - pszFileName is NULL!\r\n");
        return FALSE;
    }

    if (!m_fIsPortOpen)
    {
        if (NULL == m_pFile)
        {
            m_pFile = new CFile();
        }

        if (fIsSocket)
        {
            fRet = OpenSocket(pszFileName);
        }
        else
        {
            fRet = OpenPort(pszFileName);
        }
    }
    else
    {
        RIL_LOG_CRITICAL("CPort::Open() - Port is already open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Open() - Exit\r\n");
    return fRet;
}
예제 #6
0
int main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD [NAME=VALUE] [NAME] ...");
  const DeviceConfig config = ParsePortArgs(args);

  Port *port = OpenPort(config, *(Port::Handler *)NULL);
  if (port == NULL) {
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  VegaDevice device(*port);

  ConsoleOperationEnvironment env;

  while (!args.IsEmpty()) {
    const char *p = args.GetNext();
    char *q = strdup(p);
    char *v = strchr(q, '=');
    if (v == NULL) {
      if (!device.RequestSetting(q, env))
        printf("Error\n");
    } else {
      *v++ = 0;
      if (!device.SendSetting(q, atoi(v), env))
        printf("Error\n");
    }

    free(q);
  }

  delete port;
  return EXIT_SUCCESS;
}
예제 #7
0
int main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD");
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  MyHandler handler;
  Port *port = OpenPort(config, handler);
  if (port == NULL) {
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  if (!port->StartRxThread()) {
    delete port;
    fprintf(stderr, "Failed to start the port thread\n");
    return EXIT_FAILURE;
  }

  while (true)
    Sleep(10000);

  delete port;
  DeinitialiseIOThread();
  return EXIT_SUCCESS;
}
예제 #8
0
파일: device.cpp 프로젝트: Mrdini/XCSoar
static bool
devInitOne(DeviceDescriptor &device, const DeviceConfig &config,
           DeviceDescriptor *&nmeaout)
{
  if (config.port_type == DeviceConfig::INTERNAL) {
#ifdef ANDROID
    if (is_simulator())
      return true;

    device.internal_gps = InternalGPS::create(Java::GetEnv(), native_view,
                                              device.GetIndex());
    return device.internal_gps != NULL;
#else
    return false;
#endif
  }

  const struct DeviceRegister *Driver = devGetDriver(config.driver_name);
  if (Driver == NULL)
    return false;

  Port *Com = OpenPort(config, device);
  if (Com == NULL)
    return false;

  if (!device.Open(Com, Driver)) {
    delete Com;
    return false;
  }

  if (nmeaout == NULL && (Driver->Flags & (1l << dfNmeaOut)))
    nmeaout = &device;

  return true;
}
예제 #9
0
// Haiku : 0 = /dev/ports/usb0 .. 3 = /dev/ports/usb3
CCPCBooster::CCPCBooster(std::string comNumber):
_COMPortNumber(comNumber),
_currentState(PortFailed),
_currentError(ErrOK)
{
	OpenPort();
}
예제 #10
0
int
main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD");
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  Port *port = OpenPort(config, nullptr, *(DataHandler *)nullptr);
  if (port == NULL) {
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  ConsoleOperationEnvironment env;

  if (!port->WaitConnected(env)) {
    delete port;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to connect the port\n");
    return EXIT_FAILURE;
  }

  FlarmDevice flarm(*port);
  RunUI(flarm, env);

  delete port;
  DeinitialiseIOThread();

  return EXIT_SUCCESS;
}
예제 #11
0
파일: Serial.cpp 프로젝트: PengWEI9/Vix
int SerialClass::Write(const void *WriteBuffer, unsigned short Length)
{
	if (m_commHandle == INVALID_COMMS_HANDLE)
		OpenPort();
    int ret = CommSend(m_commHandle, WriteBuffer, Length);
    CsDebug(5, (5, "SerialClass::Write(h=%d): len=%d, ret=%d", m_commHandle, Length, ret));
	return COMMSERIAL_SUCCESS;
}
예제 #12
0
파일: TA5Serial.cpp 프로젝트: Raxtion/CT74
//---------------------------------------------------------------------------
__fastcall CTA5Serial::CTA5Serial(int nPort)
{
    m_bInitOK=OpenPort(nPort);

    m_dX[0]=0.0;
    m_dX[1]=0.0;
    m_dY[0]=0.0;
    m_dY[1]=0.0;
}
예제 #13
0
int main(int argc, char **argv)
{
  Connection con;
  PortConnection port;
  const char *name = TIMING_NAME;
  const char *other, *now;

  struct sigaction sa;
  sa.sa_handler= SIG_IGN;
  sa.sa_flags=SA_NOCLDWAIT;
  /* this old code produced a warning 
    struct sigaction sa = {
    SIG_IGN, 0, 0, SA_NOCLDWAIT
    };*/

  x = time(0);

  sigaction (SIGCHLD, &sa, 0);

  {
    char buf[1024];
    FILE *x;

    x = fopen ("modulus.hex", "r");
    if (! x) { perror ("modulus.hex"); exit (2); }
    fgets (buf, 1024, x);
    fclose (x);
    LHex2Long (buf, &n);
  }

  /***************  Globales Port eröffnen  ***************/
  if (!(port=OpenPort(name))) {
    fprintf(stderr,"TIMING_DAEMON: Kann das Dämon-Port \"%s\" nicht erzeugen: %s\n",name,NET_ErrorText());
    exit(20);
  }

  /******************* Hauptschleife **********************/
  while (1) {

    /**************  Auf Verbindung auf dem Port warten  ****************/
    if (!(con=WaitAtPort(port))) {
      fprintf(stderr,"TIMING_DAEMON: WaitAtPort ging schief: %s\n",NET_ErrorText());
      exit(20);
    }
    other = PeerName(port);
    now = Now();

    fprintf (stderr, "Connect from %s: %s\n", other, now);
    fflush (stderr);

    x += time(0);
    handle_connection (con, other, now);
    DisConnect (con);
  }

  return 0;
}
예제 #14
0
/********************************************************************

  Declaration:  CommPort constructor without parameters
  Call: 
  Input:
  Returns:
  	  
*********************************************************************/ 
CommPort::CommPort()
{
  m_sComPort = new TCHAR[50];  
	SetBufferSizeVar(1200);
//printf ("CommPort constructor 0 start.\n");
	m_BitRate = br9600;
	sprintf(m_sComPort, "%s", "COM1");  
  OpenPort();
}
예제 #15
0
int
main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD");
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  MyHandler handler;
  Port *port = OpenPort(config, handler);
  if (port == NULL) {
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  ConsoleOperationEnvironment env;

  if (!port->WaitConnected(env)) {
    delete port;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to connect the port\n");
    return EXIT_FAILURE;
  }

  if (!port->StartRxThread()) {
    delete port;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to start the port thread\n");
    return EXIT_FAILURE;
  }

  char stamp[6] = "";

  char line[1024];
  while (fgets(line, sizeof(line), stdin) != NULL) {
    if (memcmp(line, "$GP", 3) == 0 &&
        (memcmp(line + 3, "GGA", 3) == 0 ||
         memcmp(line + 3, "RMC", 3) == 0) &&
        line[6] == ',' &&
        strncmp(stamp, line + 7, sizeof(stamp)) != 0) {
      /* the time stamp has changed - sleep for one second */
      Sleep(1000);
      strncpy(stamp, line + 7, sizeof(stamp));
    }

    if (!port->FullWriteString(line, env, 1000)) {
      fprintf(stderr, "Failed to write to port\n");
      delete port;
      return EXIT_FAILURE;
    }
  }

  delete port;
  DeinitialiseIOThread();
  return EXIT_SUCCESS;
}
예제 #16
0
파일: Serial.cpp 프로젝트: PengWEI9/Vix
// port      - serial device name
// speed     - eg 9600 
// data_bits - typically 8 
// parity    - 'n', 'o', 'e', 'm', 's' 
// stop_bits -  1 or 2);
int SerialClass::OpenPort(const char* port, unsigned long speed, unsigned int data_bits, char parity, unsigned int stop_bits)
{
    strncpy(m_port, port, MAX_PORTNAME_LENGTH);
    m_speed     = speed;
    m_data_bits = data_bits;
    m_parity    = parity;
    m_stop_bits = stop_bits;  
    
	// open the port
    return OpenPort();
}
예제 #17
0
/********************************************************************

  Declaration:  CommPort constructor without parameters
  Call: 
  Input:
  Returns:
  	  
*********************************************************************/ 
CommPort::CommPort()
{
  m_sComPort = new TCHAR[50];  
	SetBufferSizeVar(1200);
  printf ("CommPort constructor MAIN start.\n");
	m_BitRate = br9600;
  m_lGenRecBytes = 0;
	m_lGenSenBytes = 0;
	sprintf(m_sComPort, "%s", "COM1");  
  OpenPort();
}
예제 #18
0
파일: net.c 프로젝트: jlsalvat/test_SDL2
void net_init( char *ip, int32_t remotePort, int32_t localPort )
{
    printf("Connecting to IP : %s , remote port %d , local port :%d\n", ip, remotePort,localPort);

    // Initialize SDL_net
    InitSDL_Net();
    OpenPort( localPort  );
    SetIPAndPort( ip, remotePort );
    CreatePacket( 512 );

}
예제 #19
0
void SerialMonitor::ReOpenPort(void)
{
	bool go = true;
	if (serialPort.isOpen()) {
		go = ClosePort();
	}

	if (go) {
		 //connect (&serialPort, SIGNAL(readyRead()), this, SLOT(ReadSerialPort()));
         OpenPort();
	}
}
예제 #20
0
// --- когда нажали на кнопку открытия порта -----------------------------------
void MainWindow::on_tryToConnect_clicked()
{   
    // заставить выбрать один из портов
    if(ui->com1rbt->isChecked()==false && ui->com2rbt->isChecked()==false)
    {
        logstr = tr("] <font color=red>вы не выбрали порт</font>");
        string2log(logstr);
        return;
    }

    // заставить настроить порт
    if(ui->comboBox_2->currentIndex()==0
            || ui->comboBox_3->currentIndex()==0
            || ui->comboBox_4->currentIndex()==0
            || ui->comboBox_5->currentIndex()==0)
    {
        logstr = tr("] <font color=red>необходимо сначала настроить порт</font>");
        string2log(logstr);
        return;
    }

    // если порт уже открыт
    if(portAlreadyChoosen)
    {
        logstr = tr("] <font color=red>порт уже открыт</font>");
        string2log(logstr);
        return;
    }

    // смотря какой порт выбран
    if(ui->com1rbt->isChecked()==true) portstr = "COM1"; else portstr = "COM2";
    // попытаться открыть его
    workPort = OpenPort(portstr);
    attmpt = true;                 // попытка установления соединения состоялась
    portAlreadyChoosen = true;     // порт выбрали
    disableSettingsChange();

    if(workPort == INVALID_HANDLE_VALUE)
    {
        logstr = tr("] <font color=red>возможно, порт отключён или занят</font>");
        string2log(logstr);
        portAlreadyChoosen = false;
        return;
    }
    else
    {
        ui->label->hide();
        ui->label_2->show();
        ui->groupBox->setEnabled(true);
        ui->listenBtn->setEnabled(true);
        emit curPortHandle(workPort);
    }
}
예제 #21
0
int main(int argc, char **argv)
{
  Args args(argc, argv, "PORT BAUD");
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  Port *port = OpenPort(config, nullptr, *(DataHandler *)nullptr);
  if (port == NULL) {
    delete port;
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  ConsoleOperationEnvironment env;

  if (!port->WaitConnected(env)) {
    delete port;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to connect the port\n");
    return EXIT_FAILURE;
  }

  char buffer[4096];
  while (true) {
    switch (port->WaitRead(env, 60000)) {
    case Port::WaitResult::READY:
      break;

    case Port::WaitResult::TIMEOUT:
      continue;

    case Port::WaitResult::FAILED:
      delete port;
      return EXIT_FAILURE;

    case Port::WaitResult::CANCELLED:
      delete port;
      return EXIT_SUCCESS;
    }

    int nbytes = port->Read(buffer, sizeof(buffer));
    if (nbytes < 0)
      break;

    fwrite((const void *)buffer, 1, nbytes, stdout);
  }

  delete port;
  DeinitialiseIOThread();
  return EXIT_SUCCESS;
}
예제 #22
0
bool
DeviceDescriptor::DoOpen(OperationEnvironment &env)
{
  assert(config.IsAvailable());

  if (config.port_type == DeviceConfig::PortType::INTERNAL)
    return OpenInternalSensors();

  if (config.port_type == DeviceConfig::PortType::DROIDSOAR_V2)
    return OpenDroidSoarV2();

  if (config.port_type == DeviceConfig::PortType::I2CPRESSURESENSOR)
    return OpenI2Cbaro();

  if (config.port_type == DeviceConfig::PortType::NUNCHUCK)
    return OpenNunchuck();

  if (config.port_type == DeviceConfig::PortType::IOIOVOLTAGE)
    return OpenVoltage();

  if (config.port_type == DeviceConfig::PortType::ADCAIRSPEED)
    return OpenAdcAirspeed();

  reopen_clock.Update();

  Port *port = OpenPort(config, *this);
  if (port == NULL) {
    TCHAR name_buffer[64];
    const TCHAR *name = config.GetPortName(name_buffer, 64);

    StaticString<256> msg;
    msg.Format(_T("%s: %s."), _("Unable to open port"), name);
    env.SetErrorMessage(msg);
    return false;
  }

  while (port->GetState() == PortState::LIMBO) {
    env.Sleep(200);

    if (env.IsCancelled() || port->GetState() == PortState::FAILED) {
      delete port;
      return false;
    }
  }

  if (!Open(*port, env)) {
    delete port;
    return false;
  }

  return true;
}
예제 #23
0
int main(int argc, char* argv[])
{
	long status;
	unsigned long cardType;
	unsigned long cardSN;
	BYTE userID;

	status = OpenPort(1, 9600);
	if (!status) {
		status = LinkRW();
		if (status) {
			ClosePort();
			fprintf(stderr, "Connect Fail\n");
			return -1;
		}
		fprintf(stderr, "Connect Succeed\n");
		//beepOn();

		//card polling
		while (1) {
			status = GetCardType(&cardType);
			if (!status) {
				delayMS(5);
				if (cardType == 4) { //Mifare 1
					status = mfGetCardSnr(&cardSN);
					if (status) { 
						status = mfTransKey();
						if (status) {
							status = SelectCard(cardSN);
							if (!status) {
								fprintf(stderr, "Activate Succeed\n");
								userID = getUserID(cardSN);
								fprintf(stdout, "%x", userID);
								HaltCard();
								//delayMS(3000);
								break;
							}
						}
					}
				}
			}
		}		
	}
	else {
		fprintf(stderr, "Connect Fail\n");
		return -1;
	}

	ClosePort();
	return 0;
}
예제 #24
0
bool NcrComPort::SendData(const char *data)
{

	if (hPort == 0) {
		if (OpenPort() == -1)
			return false;
	}

    DWORD byteswritten;

    bool retVal = WriteFile(hPort, data, 1, &byteswritten, NULL);

    return retVal;
}
예제 #25
0
파일: mon_qp.cpp 프로젝트: mingpen/OpenNT
PORTHANDLE BeginJob(HPERIPHERAL hPeripheral,LPTSTR lpszPortName,
                    LPTSTR lpszJobName)
{
  int   hPort;
  PSPCB pSPCB;

  TRACE0(TEXT("--BeginJob\r\n"));

  hPort = FindHandle(lpszPortName);
  if (!hPort)
  {
    TRACE0(TEXT("--BeginJob: Bad parameter\r\n"));
    return(QP_BEGIN_JOB_FAIL);
  }

  pSPCB = &SPCBTable[hPort];

  if (pSPCB->DeviceState.bJobPresent)
  {
    TRACE1(TEXT("--BeginJob: Prior job (%s)\r\n"),pSPCB->DeviceState.szJobName);
    return(QP_BEGIN_JOB_FAIL);
  }

  if (!EnterCritSem0(BEGIN_JOB_TIMEOUT))
  {
    return(QP_BEGIN_JOB_FAIL);
  }

  // open the port
  if (OpenPort(hPeripheral,PORT_OWN_QP,pSPCB))
  {
    TRACE0(TEXT("--BeginJob: OpenPort failed\r\n"));
    return(QP_BEGIN_JOB_FAIL);
  }

  LeaveCritSem0();

  if ( lpszJobName )
  {
	  _tcsncpy(pSPCB->DeviceState.szJobName,lpszJobName,sizeof(pSPCB->DeviceState.szJobName));
	  pSPCB->DeviceState.szJobName[sizeof(pSPCB->DeviceState.szJobName) - 1] = '\0';
  }
  else
	  pSPCB->DeviceState.szJobName[0] = '\0';
  pSPCB->DeviceState.bJobPresent = TRUE;
  pSPCB->DeviceState.nJobPage = 0;

  return(hPort);
}
예제 #26
0
bool
DeviceDescriptor::DoOpen(OperationEnvironment &env)
{
  assert(config.IsAvailable());

  if (config.port_type == DeviceConfig::PortType::INTERNAL)
    return OpenInternalSensors();

  if (config.port_type == DeviceConfig::PortType::DROIDSOAR_V2)
    return OpenDroidSoarV2();

  if (config.port_type == DeviceConfig::PortType::I2CPRESSURESENSOR)
    return OpenI2Cbaro();

  if (config.port_type == DeviceConfig::PortType::NUNCHUCK)
    return OpenNunchuck();

  if (config.port_type == DeviceConfig::PortType::IOIOVOLTAGE)
    return OpenVoltage();

  reopen_clock.Update();

  Port *port = OpenPort(config, port_listener, *this);
  if (port == nullptr) {
    TCHAR name_buffer[64];
    const TCHAR *name = config.GetPortName(name_buffer, 64);

    StaticString<256> msg;
    msg.Format(_T("%s: %s."), _("Unable to open port"), name);
    env.SetErrorMessage(msg);
    return false;
  }

  DumpPort *dump_port = new DumpPort(port);
  dump_port->Disable();

  if (!port->WaitConnected(env) || !OpenOnPort(dump_port, env)) {
    if (!env.IsCancelled())
      ++n_failures;

    delete dump_port;
    return false;
  }

  ResetFailureCounter();
  return true;
}
예제 #27
0
/********************************************************************

  Declaration:  CommPort constructor with 2 parameters
  Call: 
  Input:
  Returns:
  	  
*********************************************************************/ 
CommPort::CommPort(const int ComPortNumber, BitRate brBitRate)
{
  SetBufferSizeVar(1200);
	m_BitRate = brBitRate;
//printf ("CommPort constructor X X start.\n");
	if (ComPortNumber <= 0)
	{
	  CommPort(); // if error - call default.
	}
	else 
	{
	 m_sComPort = new TCHAR[50];
     sprintf(m_sComPort, "COM%d:", ComPortNumber);
     OpenPort();
	}
	
}
예제 #28
0
STDMETHODIMP CMicroFlash::Print(int iCopies)
{
	HRESULT r;
	char endLine [] = "\r\n";
	DWORD dwBytesWritten;
	char *pcPrintBuf;
	int iLineCount, n;

	// Assume failure
	r = S_FALSE;

	pcPrintBuf = NULL;
	iLineCount = 0;

	if(!OpenPort()) goto Exit;

	// Add formfeed to data
	m_strData.Append (TEXT("\x0C"));

	// Convert to char data
	n = m_strData.Length ();
	pcPrintBuf = new char [n + 1];
	wcstombs (pcPrintBuf, m_strData, n);
	pcPrintBuf [n] = 0;

	// Wakeup the printer
	for(iLineCount = 0; iLineCount < 10; iLineCount++)
		WriteFile(m_hComPort, endLine, strlen(endLine), &dwBytesWritten, NULL);

	Sleep(500);

	// Print the buffer
	for(iLineCount = 0; iLineCount < iCopies; iLineCount++)
		if(!WriteFile(m_hComPort, pcPrintBuf, strlen(pcPrintBuf), 
			&dwBytesWritten, NULL)) goto Exit;

	m_strData.Empty ();

	r = S_OK;

Exit:
	ClosePort ();
	delete [] pcPrintBuf;

	return r;
}
예제 #29
0
STDMETHODIMP CComBus::Start(void)
{
	// TODO: Add your implementation code here
	m_ErrCode = 0;
	if( !OpenPort( (LPTSTR)(m_port->m_str), m_baudrate ) )
	{
		m_ErrCode = GetErrCode();
		return E_FAIL;
	}
	if( !CreateThread() )
	{
		m_ErrCode = GetErrCode();
		return E_FAIL;
	}
	::Sleep(1000);
	return S_OK;
}
예제 #30
0
int
main(int argc, char **argv)
{
  Args args(argc, argv, "DRIVER PORT BAUD");
  Emulator *emulator = LoadEmulator(args);
  const DeviceConfig config = ParsePortArgs(args);
  args.ExpectEnd();

  InitialiseIOThread();

  Port *port = OpenPort(config, *emulator->handler);
  if (port == NULL) {
    delete emulator;
    fprintf(stderr, "Failed to open COM port\n");
    return EXIT_FAILURE;
  }

  emulator->port = port;

  ConsoleOperationEnvironment env;
  emulator->env = &env;

  if (!port->WaitConnected(env)) {
    delete port;
    delete emulator;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to connect the port\n");
    return EXIT_FAILURE;
  }

  if (!port->StartRxThread()) {
    delete port;
    delete emulator;
    DeinitialiseIOThread();
    fprintf(stderr, "Failed to start the port thread\n");
    return EXIT_FAILURE;
  }

  while (port->GetState() != PortState::FAILED)
    Sleep(1000);

  delete port;
  delete emulator;
  DeinitialiseIOThread();
  return EXIT_SUCCESS;
}