Example #1
0
int main(int argc, char *argv[]) {
    char uart_port[8];
    unsigned i;

    bglib_output = output;

    for (i=0; i<100; ++i){
        sprintf(uart_port, "COM%d", i);
        if (!uart_open(uart_port)) break;
    }

    // Reset dongle to get it into known state
    ble_cmd_system_reset(0);
    uart_close();
    do {
        Sleep(500); // 0.5s
    } while (uart_open(uart_port));

    // Execute action
    ble_cmd_gap_discover(gap_discover_observation);

    // Message loop
    while (state != state_finish) {
        if (read_message(UART_TIMEOUT) > 0) break;
    }

    uart_close();

    return 0;
}
bool
pn532_uart_list_devices (nfc_device_desc_t pnddDevices[], size_t szDevices, size_t * pszDeviceFound)
{
  /** @note: Due to UART bus we can't know if its really a pn532 without
  * sending some PN53x commands. But using this way to probe devices, we can
  * have serious problem with other device on this bus */
#ifndef SERIAL_AUTOPROBE_ENABLED
  (void) pnddDevices;
  (void) szDevices;
  *pszDeviceFound = 0;
  DBG ("%s", "Serial auto-probing have been disabled at compile time. Skipping autoprobe.");
  return false;
#else /* SERIAL_AUTOPROBE_ENABLED */
  *pszDeviceFound = 0;

  serial_port sp;
  const char *pcPorts[] = DEFAULT_SERIAL_PORTS;
  const char *pcPort;
  int     iDevice = 0;

  while ((pcPort = pcPorts[iDevice++])) {
    sp = uart_open (pcPort);
    DBG ("Trying to find PN532 device on serial port: %s at %d bauds.", pcPort, SERIAL_DEFAULT_PORT_SPEED);

    if ((sp != INVALID_SERIAL_PORT) && (sp != CLAIMED_SERIAL_PORT)) {
      bool    bComOk;
      // Serial port claimed but we need to check if a PN532_UART is connected.
      uart_set_speed (sp, SERIAL_DEFAULT_PORT_SPEED);
      // PN532 could be powered down, we need to wake it up before line testing.
      pn532_uart_wakeup ((nfc_device_spec_t) sp);
      // Check communication using "Diagnose" command, with "Communication test" (0x00)
      if (!pn532_uart_check_communication ((nfc_device_spec_t) sp, &bComOk))
        continue;
      if (!bComOk)
        continue;
      uart_close (sp);

      snprintf (pnddDevices[*pszDeviceFound].acDevice, DEVICE_NAME_LENGTH - 1, "%s (%s)", "PN532", pcPort);
      pnddDevices[*pszDeviceFound].acDevice[DEVICE_NAME_LENGTH - 1] = '\0';
      pnddDevices[*pszDeviceFound].pcDriver = PN532_UART_DRIVER_NAME;
      pnddDevices[*pszDeviceFound].pcPort = strdup (pcPort);
      pnddDevices[*pszDeviceFound].uiSpeed = SERIAL_DEFAULT_PORT_SPEED;
      DBG ("Device found: %s.", pnddDevices[*pszDeviceFound].acDevice);
      (*pszDeviceFound)++;

      // Test if we reach the maximum "wanted" devices
      if ((*pszDeviceFound) >= szDevices)
        break;
    }
#  ifdef DEBUG
    if (sp == INVALID_SERIAL_PORT)
      DBG ("Invalid serial port: %s", pcPort);
    if (sp == CLAIMED_SERIAL_PORT)
      DBG ("Serial port already claimed: %s", pcPort);
#  endif
       /* DEBUG */
  }
#endif /* SERIAL_AUTOPROBE_ENABLED */
  return true;
}
Example #3
0
bool initUartOutput(flowOutputState state, char* port, unsigned int baud, size_t bufferSize) {
	// Initialize UART communication
	int uartErrno = uart_open(port, baud);
	if (uartErrno) {
		caerLog(CAER_LOG_ALERT, SUBSYSTEM_UART,
				"Failed to identify serial communication, errno=%i.",uartErrno);
		return (false);
	}
	// Test message
	char* testMessage = "DVS128UART";
	if (uart_tx((int) strlen(testMessage), (unsigned char*) testMessage)) {
		caerLog(CAER_LOG_ALERT, SUBSYSTEM_UART,
				"Test transmission unsuccessful - connection closed.");
		uart_close();
		return(false);
	}

	// Start output handler thread
	state->thread = 0;
	if (thrd_create(&state->thread, &outputHandlerThread, state) != thrd_success) {
		caerLog(CAER_LOG_ALERT, SUBSYSTEM_UART,"Failed to start output handler thread");
		return (false);
	}
	state->buffer = ringBufferInit(bufferSize);
	if (state->buffer == NULL) {
		caerLog(CAER_LOG_ERROR, SUBSYSTEM_UART, "Failed to allocate transfer ring-buffer.");
		return (false);
	}
	atomic_store(&state->running, true);
	caerLog(CAER_LOG_NOTICE, SUBSYSTEM_UART, "Streaming flow events to port %s.",port);
	return (true);
}
Example #4
0
void rc522_uart_close(nfc_device * pnd) {
	rc522_powerdown(pnd);
	// Release UART port
	uart_close(DRIVER_DATA(pnd)->port);
	rc522_data_free(pnd);
	nfc_device_free(pnd);
}
Example #5
0
ER GPSRec_Close(void)
{

    if (!bGPSRecOpened)
        return E_SYS;

    #if (RECEIVE_FROM_UART2)
    if (uart2_close() == E_OK)
    #else
    if (uart_close() == E_OK)
    #endif
        debug_msg(("UART2: close success\r\n"));
    else
        debug_err(("UART2: close fail!\r\n"));

    debug_msg("Terminate GPS receive task\r\n");

    ter_tsk(GPSRECEIVE_ID);

    loc_cpu();
    bGPSRecOpened = FALSE;
    unl_cpu();

    return E_OK;
}
Example #6
0
serial_port
uart_open(const char *pcPortName)
{
  char    acPortName[255];
  struct serial_port_windows *sp = malloc(sizeof(struct serial_port_windows));

  if (sp == 0)
    return INVALID_SERIAL_PORT;

  // Copy the input "com?" to "\\.\COM?" format
  sprintf(acPortName, "\\\\.\\%s", pcPortName);
  _strupr(acPortName);

  // Try to open the serial port
  sp->hPort = CreateFileA(acPortName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  if (sp->hPort == INVALID_HANDLE_VALUE) {
    uart_close(sp);
    return INVALID_SERIAL_PORT;
  }
  // Prepare the device control
  memset(&sp->dcb, 0, sizeof(DCB));
  sp->dcb.DCBlength = sizeof(DCB);
  if (!BuildCommDCBA("baud=9600 data=8 parity=N stop=1", &sp->dcb)) {
    uart_close(sp);
    return INVALID_SERIAL_PORT;
  }
  // Update the active serial port
  if (!SetCommState(sp->hPort, &sp->dcb)) {
    uart_close(sp);
    return INVALID_SERIAL_PORT;
  }

  sp->ct.ReadIntervalTimeout = 30;
  sp->ct.ReadTotalTimeoutMultiplier = 0;
  sp->ct.ReadTotalTimeoutConstant = 30;
  sp->ct.WriteTotalTimeoutMultiplier = 30;
  sp->ct.WriteTotalTimeoutConstant = 0;

  if (!SetCommTimeouts(sp->hPort, &sp->ct)) {
    uart_close(sp);
    return INVALID_SERIAL_PORT;
  }

  PurgeComm(sp->hPort, PURGE_RXABORT | PURGE_RXCLEAR);

  return sp;
}
Example #7
0
void uart_socket_example(void *param)
{
	char tx_data[] = {0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
	uart_set_str uartset;
	struct timeval tv;
	fd_set readfds;
	int read_len = 0, count = 0;
	int ret = 0;
	char rxbuf[512];
	int uart_fd;
	uart_socket_t *uart_socket = NULL;

	uartset.BaudRate = 9600;
	uartset.number = 8;
	uartset.StopBits = 0;
	uartset.FlowControl = 0;
	uartset.parity = 0;
	strcpy(uartset.UartName, "uart0");

	uart_socket = uart_open(&uartset);
	if(uart_socket == NULL){
		uart_printf("Init uart socket failed!\n");
		goto Exit;
	}
	uart_fd = uart_socket->fd;
	uart_printf("\nOpen uart socket: %d\n", uart_fd);
	while(1)
	{
		FD_ZERO(&readfds);
		FD_SET(uart_fd, &readfds);
		tv.tv_sec = 0;
		tv.tv_usec = 20000;
		if(count++ == 50){
			uart_write(uart_socket, tx_data, sizeof(tx_data));
			//uart_print_data("TX:", tx_data, sizeof(tx_data));
			count = 0;
		}
		ret = select(uart_fd + 1, &readfds, NULL, NULL, &tv);
		//uart_printf("[%d] select ret = %x count=%d\n", xTaskGetTickCount(), ret, count);	
		if(ret > 0)
		{
			if(FD_ISSET(uart_fd, &readfds))
			{
				read_len = uart_read(uart_socket, rxbuf, sizeof(rxbuf));
				if(read_len > 0)
				{
					uart_print_data("RX:", rxbuf, read_len);
					if(rtl_strncmp(rxbuf, "close", 5) == 0)
						break;
				}
			}
			//else for other sockets
		}
	}
	uart_printf("Exit uart socket example!\n");
	uart_close(uart_socket);
Exit:
	vTaskDelete(NULL);
}
Example #8
0
void uart_start_h()
{
#define 	UART_SOCKET_STACK_SIZE		512
#define 	HAPNotifyHandle_STACK_SIZE		512*4
#define 	UART_SOCKET_PRIORITY		1
    TaskHandle_t uart_socket_handle = NULL;
    TaskHandle_t HAPNotifyHandle_handle = NULL;
    const TickType_t xDelay = 10000;
    eTaskState TaskState;
    xSemaphoreHandle uart_socket_sema = NULL;
    xSemaphoreHandle HAPNotifyHandle_sema = NULL;
    struct tm timeinfo;
    
    //printf("==============[uart_start_h]rtc_isenabled : %d============\n", rtc_isenabled());
    //vTaskDelay(xDelay*5);
    //printf("uart start\n");
    vSemaphoreCreateBinary(uart_socket_sema);
    vSemaphoreCreateBinary(HAPNotifyHandle_sema);
	if(xTaskCreate(uart_socket_example, "uart_socket", UART_SOCKET_STACK_SIZE*2, &uart_socket_sema, UART_SOCKET_PRIORITY, &uart_socket_handle) != pdPASS)
		uart_printf("%s xTaskCreate failed", __FUNCTION__);
	if(xTaskCreate(HAPNotifyHandle, "HAPNotifyHandle", HAPNotifyHandle_STACK_SIZE, &HAPNotifyHandle_sema, UART_SOCKET_PRIORITY, &HAPNotifyHandle_handle) != pdPASS)
		uart_printf("%s xTaskCreate failed", __FUNCTION__);

	while(1)
	{
	    vTaskDelay(xDelay);
	    if (xSemaphoreTake(uart_socket_sema, ( TickType_t ) 2000) == pdTRUE)
	    {
	        //uart_printf("========uart_socket_right go on=========\n");
	        #if 0
	        read_locoltime(&timeinfo);
	        printf("Time as a custom formatted string = %d-%d-%d %d:%d:%d wday:%d yday:%d\n", 
            timeinfo.tm_year, timeinfo.tm_mon, timeinfo.tm_mday, timeinfo.tm_hour,
            timeinfo.tm_min,timeinfo.tm_sec,timeinfo.tm_wday,timeinfo.tm_yday);
            printf("==============rtc_isenabled : %d============\n", rtc_isenabled());
            #endif
	    }
	    else
	    {
	        uart_printf("========uart_socket_wrong reset=========\n");
	        vTaskDelete(uart_socket_handle);
	        uart_close(uart_socket);
	        //uart_close(uart_socket_send);
	        if(xTaskCreate(uart_socket_example, "uart_socket", UART_SOCKET_STACK_SIZE, &uart_socket_sema, UART_SOCKET_PRIORITY, &uart_socket_handle) != pdPASS)
	            uart_printf("%s xTaskCreate failed", __FUNCTION__);
	    }

	    if (xSemaphoreTake(HAPNotifyHandle_sema, ( TickType_t ) 4000) != pdTRUE)
	    {
	        uart_printf("========HAPNotifyHandle reset=========\n");
	        vTaskDelete(HAPNotifyHandle_handle);
	        if(xTaskCreate(HAPNotifyHandle, "HAPNotifyHandle", HAPNotifyHandle_STACK_SIZE, &HAPNotifyHandle_sema, UART_SOCKET_PRIORITY, &HAPNotifyHandle_handle) != pdPASS)
		uart_printf("%s xTaskCreate failed", __FUNCTION__);
	    }
	}
}
Example #9
0
static void handle_close(const char *req, int *req_index)
{
    (void) req;
    (void) req_index;

    if (uart_is_open(uart))
        uart_close(uart);

    send_ok_response();
}
Example #10
0
void closeUartOutput(flowOutputState state) {
	state->running = false;
	uart_close();

	if ((errno = thrd_join(state->thread, NULL)) != thrd_success) {
		// This should never happen!
		caerLog(CAER_LOG_CRITICAL, SUBSYSTEM_UART,
				"Failed to join output handling thread. Error: %d.", errno);
	}
	ringBufferFree(state->buffer);
}
Example #11
0
File: main.c Project: bgromov/bglib
int main(int argc, char** argv)
{
  char* uart_port = NULL;

  if (argc == 2)
    uart_port = argv[1];
  else
  {
    printf("Usage: %s <serial_port>\n\n", argv[0]);
    return 1;
  }

  bglib_output = output;

  if (uart_open(uart_port))
  {
    printf("ERROR: Unable to open serial port\n");
    return 1;
  }

  // Reset dongle to get it into known state
  ble_cmd_system_reset(0);
  uart_close();
  do
  {
    usleep(500000); // 0.5s
  } while (uart_open(uart_port));

  ble_cmd_gap_end_procedure();
  ble_cmd_gap_discover(gap_discover_observation);

  while (1)
  {
    if (read_message(UART_TIMEOUT) > 0)
      break;
  }

  uart_close();

  return 0;
}
Example #12
0
void main_cdc_close(uint8_t port)
{
	switch(port){
		case 0: // COMM0		
			uart_close(&USART_COMM0); // close COMM0, this also disables interrupts
		break;
		case 1: // Switch back to XBEE forwarding/programming, open COMM1
			uart_open(&USART_COMM1); // restore communication with main processor on COMM1
			usart_set_rx_interrupt_level(&USART_COMM1, USART_INT_LVL_HI);
		break;
	}
}
static intptr_t uart_cls_por(intptr_t exinf) {
    SIOPCB *p_siopcb = (SIOPCB*)exinf;

    uart_close(&UART1);

    p_siopcb->openflag = false;

    ER ercd = dis_int(UART1_INT);
    assert(ercd == E_OK);

    return true;
}
Example #14
0
static int uart_diag_init(const struct diag *diag) {
	struct uart_diag *uart_diag = (struct uart_diag *) diag;

	uart_set_params(uart_diag->uart, uart_diag->params);

	/* XXX */
	/* set params */
	uart_open(uart_diag->uart);
	/* allow future `open' */
	uart_close(uart_diag->uart);

	return 0;
};
Example #15
0
void main_cdc_open(uint8_t port)
{
	switch(port){
		case 0: // COMM0
			lithneProgrammer.resetMain();
			uart_open(&USART_COMM0);
			usart_set_rx_interrupt_level(&USART_COMM0, USART_INT_LVL_HI); // receive interrupt
		break;
		case 1: // Switched to XBEE direct: close COMM1
			uart_close(&USART_COMM1); // close COMM1, this also disables interrupts						
			usart_set_rx_interrupt_level(&USART_XBEE, USART_INT_LVL_HI);					
		break;						
	}
}
Example #16
0
File: uart.c Project: rargo/app
void uart_test2(void)
{
	int ret;
	char buf[1024];
	int len;
	int total_len = 0;
	volatile int j;

	/* uart0 tx <---> uart 3 rx 
	 * to test baudrate is right
	 */
	dprintf("capture from uart0 start");

	for(j =0 ; j<2000; j++)
		;

	uart_close(3);
	ret = uart_open(3,115200,8,'n',1);

	/* send to uart 3 */
	dprintf("abcdefghijklmnopq1234325454545\r\n");

	for(j =0 ; j<2000; j++)
		;

	memset(buf,0,sizeof(buf));
	while((len = uart_rx(3, buf + total_len, 1024 - total_len))) {
		total_len += len;
	}

	uart_close(3);

	dprintf("%s",buf);
	dprintf("capture stop");
	for(;;)
		;
}
Example #17
0
static void
arygon_close_step2(nfc_device *pnd)
{
  // Release UART port
  uart_close(DRIVER_DATA(pnd)->port);

#ifndef WIN32
  // Release file descriptors used for abort mecanism
  close(DRIVER_DATA(pnd)->iAbortFds[0]);
  close(DRIVER_DATA(pnd)->iAbortFds[1]);
#endif

  pn53x_data_free(pnd);
  nfc_device_free(pnd);
}
Example #18
0
int main(void) {
	volatile char inputBuffer[8];

	char foo;
	uart_open(9600, inputBuffer, 8);
	sei();

	while(1) {
		if (uart_read(&foo)){
			uart_write(&foo,1);
		}
	}

	uart_close();

	return 1;
}
void uart_init(int fd)
{
        //Setting the uart device parameter
        printf("Setting the uart device parameter\n");
        struct termios serialAttr;
        memset(&serialAttr, 0, sizeof serialAttr); 
        serialAttr.c_iflag = IGNPAR;
        serialAttr.c_cflag = B9600 | HUPCL | CS8 | CREAD | CLOCAL;
        serialAttr.c_cc[VMIN] = 1;

        if (tcsetattr(fd, TCSANOW, &serialAttr)) {
                printf("tcsetattr fail !\n");
				uart_close(fd);
                exit(1);

        }
        printf("uart initial is OK\n");
}
Example #20
0
static be_jse_symbol_t * uart_module_handle_cb(be_jse_vm_ctx_t *execInfo, be_jse_symbol_t *var, const char *name){
	if(0 == strcmp(name,"open")){
		return uart_open();
	}
	if(0 == strcmp(name,"read")){
		return uart_read();
	}
	if(0 == strcmp(name,"write")){
		return uart_write();
	}
	if(0 == strcmp(name,"on")){
		return uart_watch();
	}
	if(0 == strcmp(name,"close")){
		return uart_close();
	}
	return (BE_JSE_FUNC_UNHANDLED);
}
Example #21
0
File: uart.c Project: rargo/app
void uart_test3(void)
{
	int ret;
	char buf[1024];
	int i;
	volatile int j;

	for(i = 0; i<sizeof(buf); i++)
		buf[i] = i & 0xff;

	/* uart3 tx test */
	ret = uart_open(3,115200,8,'n',1);
	dprintf("open uart 3 ret:%d\r\n", ret);

	for(;;) {
		uart_tx_str(3, "AT\r");
		while(!uart_tx_finish(3))
			;

		while(!(ret = uart_rx(3, buf, sizeof(buf))))
			;

		if(ret < 0) {
			RERR();
			continue;
		}

		j = 1000;
		while(j--)
			;
		ret += uart_rx(3, buf + ret, sizeof(buf));
		if(ret > 0) {
			buf[ret] = 0;
			dprintf("ret:%d buf:%s\r\n",ret, buf);
		} else {
			dprintf("uart rx 3 ret:%d\r\n",ret);
		}
	}

	uart_close(3);
}
Example #22
0
int main(int argc, char* argv[])
{
        
        csInit ();
	spiInit(SPI1);
        
        mySPI_SendData(Ctrl_Reg1, 0x40); //0x40 = 0100000, 0xC0 = 11000000 = 400 Hz output data rate), active
    
	uart_open(myUSART, 9600, 0);
	uint8_t ri;
	cmdi = 0;
        
        timInit();


	// Infinite loop
	while (1)
	{
        }
	uart_close(myUSART);
}
Example #23
0
/*
	Clears the read buffer.
*/
void uart_flush_read(uart_s* uart){
	uint8_t buffer[64];
	int nbytes=1;

	if (!(uart->opened)){
		//Let's do that first.
		if (!uart_open(uart)){
			return;
		}
	}


	struct timeval timeout;	
	// initialise the timeout structure
	timeout.tv_sec = 0;
	timeout.tv_usec = 1000;

	// Update File Descriptor so that it's correct as the state of the program changes.
	while(1){

		fd_set 	readfds; 	//Do i want this in a uart_object? Or just leave it?
		FD_ZERO(&readfds);			//Clear the set of file_descriptors. 
		FD_SET(uart->fd, &readfds);	//Add 'tty_fd' to 'readfds' set of file_descriptors.
		int n = select(uart->fd + 1, &readfds, NULL, NULL, &timeout);
		if(n>0){		
			nbytes = read(uart->fd,buffer,64);	//This starts writing at bufferout[0].
			uart_printf(CLR_CANCEL,0,"Number of bytes cleared: %i\n",nbytes);
			if (nbytes == 0){
				//This can happen when the port becomes unavailable.
				uart_printf(CLR_CANCEL,0,"Port disconnected\n");
				uart_close(uart);
				return;
			}			
		}else{
			//Let me know.
			//scc_printf(SRC_TCPSERV|LEVEL_WARNING,0,"No bytes where cleared.\n");
			return;
		}	
	}
}
Example #24
0
/*
 * Handle {name, kv_list}
 *
 *    name is the serial port name
 *    kv_list a list of configuration values (speed, parity, etc.)
 */
static void handle_open(const char *req, int *req_index)
{
    int term_type;
    int term_size;

    if (ei_decode_tuple_header(req, req_index, &term_size) < 0 ||
            term_size != 2)
        errx(EXIT_FAILURE, ":open requires a 2-tuple");

    char name[32];
    long binary_len;
    if (ei_get_type(req, req_index, &term_type, &term_size) < 0 ||
            term_type != ERL_BINARY_EXT ||
            term_size >= (int) sizeof(name) ||
            ei_decode_binary(req, req_index, name, &binary_len) < 0) {
        // The name is almost certainly too long, so report that it
        // doesn't exist.
        send_error_response("enoent");
        return;
    }
    name[term_size] = '\0';

    struct uart_config config = current_config;
    if (parse_option_list(req, req_index, &config) < 0) {
        send_error_response("einval");
        return;
    }

    // If the uart was already open, close and open it again
    if (uart_is_open(uart))
        uart_close(uart);

    if (uart_open(uart, name, &config) >= 0) {
        current_config = config;
        send_ok_response();
    } else {
        send_error_response(uart_last_error());
    }
}
int main(void) {
	uart_init();
    q1 = init_robocol_queue(8);
    q2 = init_robocol_queue(8);
    q3 = init_robocol_queue(8);
    enqueue(q1, 5);
    display_queue(q1);
	
	while(1){

	}
	/*
    command* c = init_command("ZAS", "PWD", "");
    display_command(c);
    destroy_command(c);
    display_command(c);
    */
    //float list[] = {1.0, 2.0, 3.0};
    int val = 0;
    //printf("%s\n", format_string("name", list, sizeof(list) / sizeof(list[0])));
    //format_string("name", list, sizeof(list) / sizeof(list[0]), &val);
    printf("%s\n", get_command_response("SEN", &val));
    uart_close();
}
/*-------------------------------------------
| Name:dev_stm32f4xx_uart_x_close
| Description:
| Parameters:
| Return Type:
| Comments:
| See:
---------------------------------------------*/
int dev_stm32f4xx_uart_x_close(desc_t desc){
  board_stm32f4xx_uart_info_t * p_uart_info = (board_stm32f4xx_uart_info_t*)ofile_lst[desc].p;
  //
  if(!p_uart_info)
   return -1;
  // 
  if(ofile_lst[desc].oflag & O_RDONLY) {
      if(!ofile_lst[desc].nb_reader) {
         p_uart_info->desc_r = -1;
      }
   }
   //
   if(ofile_lst[desc].oflag & O_WRONLY) {
      if(!ofile_lst[desc].nb_writer) {
         p_uart_info->desc_w = -1;
      }
   }
   //
   if(p_uart_info->desc_r<0 && p_uart_info->desc_w<0) {
      uart_close(&p_uart_info->uart_descriptor);
   }

   return 0;
}
Example #27
0
void main_cdc_disable(uint8_t port)
{
	main_b_cdc_enable = false;
	// Close communication
	uart_close(port);
}
Example #28
0
static int dev_uart_close(struct file_desc *desc) {
	struct uart *uart_dev = desc->file_info;

	return uart_close(uart_dev);
}
Example #29
0
void CloseProxmark() {
  // Clean up the port
  uart_close(sp);
  // Fix for linux, it seems that it is extremely slow to release the serial port file descriptor /dev/*
  unlink(serial_port_name);
}
Example #30
0
static size_t
pn532_uart_scan(const nfc_context *context, nfc_connstring connstrings[], const size_t connstrings_len)
{
  size_t device_found = 0;
  serial_port sp;
  char **acPorts = uart_list_ports();
  const char *acPort;
  int     iDevice = 0;

  while ((acPort = acPorts[iDevice++])) {
    sp = uart_open(acPort);
    log_put(LOG_GROUP, LOG_CATEGORY, NFC_LOG_PRIORITY_DEBUG, "Trying to find PN532 device on serial port: %s at %d bauds.", acPort, PN532_UART_DEFAULT_SPEED);

    if ((sp != INVALID_SERIAL_PORT) && (sp != CLAIMED_SERIAL_PORT)) {
      // We need to flush input to be sure first reply does not comes from older byte transceive
      uart_flush_input(sp);
      // Serial port claimed but we need to check if a PN532_UART is opened.
      uart_set_speed(sp, PN532_UART_DEFAULT_SPEED);

      nfc_connstring connstring;
      snprintf(connstring, sizeof(nfc_connstring), "%s:%s:%"PRIu32, PN532_UART_DRIVER_NAME, acPort, PN532_UART_DEFAULT_SPEED);
      nfc_device *pnd = nfc_device_new(context, connstring);
      pnd->driver = &pn532_uart_driver;
      pnd->driver_data = malloc(sizeof(struct pn532_uart_data));
      DRIVER_DATA(pnd)->port = sp;

      // Alloc and init chip's data
      pn53x_data_new(pnd, &pn532_uart_io);
      // SAMConfiguration command if needed to wakeup the chip and pn53x_SAMConfiguration check if the chip is a PN532
      CHIP_DATA(pnd)->type = PN532;
      // This device starts in LowVBat power mode
      CHIP_DATA(pnd)->power_mode = LOWVBAT;

#ifndef WIN32
      // pipe-based abort mecanism
      if (pipe(DRIVER_DATA(pnd)->iAbortFds) < 0) {
        return 0;
      }
#else
      DRIVER_DATA(pnd)->abort_flag = false;
#endif

      // Check communication using "Diagnose" command, with "Communication test" (0x00)
      int res = pn53x_check_communication(pnd);
      pn53x_data_free(pnd);
      nfc_device_free(pnd);
      uart_close(sp);
      if (res < 0) {
        continue;
      }

      memcpy(connstrings[device_found], connstring, sizeof(nfc_connstring));
      device_found++;

      // Test if we reach the maximum "wanted" devices
      if (device_found >= connstrings_len)
        break;
    }
  }
  iDevice = 0;
  while ((acPort = acPorts[iDevice++])) {
    free((void *)acPort);
  }
  free(acPorts);
  return device_found;
}