Esempio n. 1
0
int serial_read_nonblocking(struct serial_device_t *serial,
                            void *buf,
                            size_t count)
{
  if (!serial) {
    log_error("serial_read_nonblocking: invalid serial port device.");
    return -DEVICE_CONN_ERROR;
  }
  if (!serial->data) {
    log_error("serial_read_nonblocking: cannot use unopened serial port %s.",
              serial->port);
    return -DEVICE_CONN_ERROR;
  }
  int ret = sp_nonblocking_read(serial->data, buf, count);
  char *error;
  switch (ret) {
  case SP_ERR_ARG:
    log_error("serial_read_nonblocking: invalid serial port parameters.");
    return -DEVICE_CONF_ERROR;
  case SP_ERR_FAIL:
    error = sp_last_error_message();
    log_error("serial_read_nonblocking: read error (%d): %s.",
              sp_last_error_code(), error);
    sp_free_error_message(error);
    return -DEVICE_CONN_ERROR;
  }
  return ret;
}
Esempio n. 2
0
/**
 * Read a number of bytes from the specified serial port.
 *
 * @param serial Previously initialized serial port structure.
 * @param buf Buffer where to store the bytes that are read.
 * @param count The number of bytes to read.
 *
 * @return The number of bytes read, or a negative error code upon failure.
 */
SR_PRIV int serial_read(struct sr_serial_dev_inst *serial, void *buf,
		size_t count)
{
	ssize_t ret;
	char *error;

	if (!serial) {
		sr_dbg("Invalid serial port.");
		return SR_ERR;
	}

	if (serial->fd == -1) {
		sr_dbg("Cannot use unopened serial port %s (fd %d).",
				serial->port, serial->fd);
		return SR_ERR;
	}

	if (serial->nonblocking)
		ret = sp_nonblocking_read(serial->data, buf, count);
	else
		ret = sp_blocking_read(serial->data, buf, count, 0);

	switch (ret) {
	case SP_ERR_ARG:
		sr_err("Attempted serial port read with invalid arguments.");
		return SR_ERR_ARG;
	case SP_ERR_FAIL:
		error = sp_last_error_message();
		sr_err("Read error: %s.", error);
		sp_free_error_message(error);
		return SR_ERR;
	}

	if (ret > 0)
		sr_spew("Read %d/%d bytes (fd %d).", ret, count, serial->fd);

	return ret;
}
Esempio n. 3
0
static int _serial_read(struct sr_serial_dev_inst *serial, void *buf,
		size_t count, int nonblocking, unsigned int timeout_ms)
{
	ssize_t ret;
	char *error;

	if (!serial) {
		sr_dbg("Invalid serial port.");
		return SR_ERR;
	}

	if (!serial->data) {
		sr_dbg("Cannot use unopened serial port %s.", serial->port);
		return SR_ERR;
	}

	if (nonblocking)
		ret = sp_nonblocking_read(serial->data, buf, count);
	else
		ret = sp_blocking_read(serial->data, buf, count, timeout_ms);

	switch (ret) {
	case SP_ERR_ARG:
		sr_err("Attempted serial port read with invalid arguments.");
		return SR_ERR_ARG;
	case SP_ERR_FAIL:
		error = sp_last_error_message();
		sr_err("Read error (%d): %s.", sp_last_error_code(), error);
		sp_free_error_message(error);
		return SR_ERR;
	}

	if (ret > 0)
		sr_spew("Read %zd/%zu bytes.", ret, count);

	return ret;
}
Esempio n. 4
0
static int _serial_read(struct serial_device_t *serial,
                 void *buf,
                 size_t count,
                 int nonblocking,
                 unsigned int timeout_ms)
{
  if (!serial) {
    log_error("serial_read_nonblocking: invalid serial port device.");
    return -DEVICE_CONN_ERROR;
  }
  if (!serial->data) {
    log_error("serial_read_nonblocking: cannot use unopened serial port %s.",
              serial->port);
    return -DEVICE_CONN_ERROR;
  }
  int ret;
  if (nonblocking) {
    ret = sp_nonblocking_read(serial->data, buf, count);
  } else {
    // TODO read or read_next? Bailing early is probably better than waiting.
    ret = sp_blocking_read_next(serial->data, buf, count, timeout_ms);
  }
  char *error;
  switch (ret) {
  case SP_ERR_ARG:
    log_error("serial_read_nonblocking: invalid serial port parameters.");
    return -DEVICE_CONF_ERROR;
  case SP_ERR_FAIL:
    error = sp_last_error_message();
    log_error("serial_read_nonblocking: read error (%d): %s.",
              sp_last_error_code(), error);
    sp_free_error_message(error);
    return -DEVICE_CONN_ERROR;
  }
  return ret;
}
Esempio n. 5
0
int serial_send(struct sp_port *my_port, const void *command, size_t write_bytes_count, void *response) {

  int ret, read_count=6; 

  if (DO_BLOCKING_READ_WRITE) {
    unsigned int timeout = READ_WRITE_TIMEOUT_SEC*1000;
    
    ret = sp_blocking_write(my_port, command, write_bytes_count, timeout);
    if (ret <= 0) {
      printf("Failed to write serial bytes.\n");
      return 0;
    }
    ret = sp_blocking_read(my_port, response, (size_t)read_count, timeout);
 
  } else {

    int fd;
    ret = sp_get_port_handle(my_port,&fd);
    if (ret != SP_OK) {
      printf("Failed to get port handle for nonblocking read/write.\n");
    }
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(fd,&fds);
    
    struct timespec ts;
    ts.tv_sec = READ_WRITE_TIMEOUT_SEC;
    
    ret = pselect(fd+1, NULL, &fds, NULL, &ts, NULL);
    if (ret < 0 && errno != EINTR) {
      printf("Error in pselect for write.\n");
      return 0;
    } else if (ret == 0) {
      printf("Timeout while waiting to write.\n");
      return 0;
    }
    ret = sp_nonblocking_write(my_port, command, write_bytes_count);

    FD_ZERO(&fds);
    FD_SET(fd,&fds);
    ts.tv_sec = READ_WRITE_TIMEOUT_SEC;
     
    ret = pselect(fd+1, &fds, NULL, NULL, &ts, NULL);
    if (ret < 0 && errno != EINTR) {
      printf("Error in pselect for write.\n");
      return 0;
    } else if (ret == 0) {
      printf("Timeout while waiting to write.\n");
      return 0;
    }
    ret = sp_nonblocking_read(my_port, response, (size_t)read_count);
  
  }

  if (ret < read_count) {
    printf("Successful write to serial, but failed on serial read.\n");
    return 0;
  } else {
    return ret;
  }

}
int Arduino_read(void *buffer, size_t bufferSize)
{
    if(!serialPort) return 0;
    return sp_nonblocking_read(serialPort, buffer, bufferSize);
}
Esempio n. 7
0
int main(int argc, char *argv[]) {
	/* select部份 */
	int opt = TRUE;
	int master_socket, addrlen, new_socket, client_socket[MAXCLIENTS],
			max_clients = MAXCLIENTS, activity, i, valread, sd;
	user_content_t *my_contents[MAXCLIENTS + 1];
	int max_sd;
	struct timeval tv; /* select超时 */
	//set of socket descriptors
	fd_set readfds;

	/* IP部份 */
	struct addrinfo hints, *res; /* 连接到target的用到的 */
	struct sockaddr_in address;
	/* 每个客户端的缓冲区和索引 */
	char buffer[MAXCLIENTS][MAXLEN];
	char *buffer_p[MAXCLIENTS];  //data buffer of 1K
	int buffer_data_size[MAXCLIENTS];
	char itoa_buffer[8]; /* ip地址从网络顺序转成char数组 */
	char *header = NULL; /* 将转换好的ip地址:封包成header */

	/* 串口部份 固定变量 */
	static char com_devicename[] = "/dev/ttyUSB0"; /* 固定的linux串口设备文件 */
	user_content_t *my_com_conf = my_malloc(sizeof(user_content_t));/* 串口配置 */

	/* 串口部份 动态变量 */
#ifdef MODULE_SERIAL
	char buffer_com[MAXLEN]; /* 串口缓冲区 */
	char *buffer_com_p=buffer_com;
	int buffer_com_data_size=0;
#endif

	/* 蓝牙部份 */
#ifdef MODULE_BLUETOOTH
	struct sockaddr_rc blue_rem_addr = {0};
	char blue_buffer[MAXLEN],blue_sender_MAC[18];
	int blue_fd,blue_fd_client,blue_bytes_read;
	socklen_t blue_opt=sizeof(blue_rem_addr);
	user_content_t *blue_user_content;
#endif

	/* args参数 */
	char *PORT;

	if (argc != 2) {
		fprintf(stderr, "usage: %s listen-port\n", argv[0]);
		return 1;
	}

	PORT = argv[1];

#ifdef MODULE_SERIAL
	/* 打开串口,须root权限 */
	if(NULL==(my_com_conf=open_com(com_devicename))) {
		printf("error open com!\n");
		return 1;
	}
#endif

#ifdef MODULE_BLUETOOTH
	/* 打开蓝牙 */
	blue_fd=create_bluetooth_socket();
	if(blue_fd<0) {
		printf("error bluetooth fd is -1\n");
		return -1;
	}
	listen(blue_fd, 1);
#endif

	//initialise all client_socket[] to 0 so not checked
	for (i = 0; i < max_clients; i++) {
		client_socket[i] = 0;
	}

	if ((master_socket = create_server_socket("0.0.0.0", PORT)) < 0) {
		printf("error create socket fd\n");
		return 1;
	}

	//set master socket to allow multiple connections , this is just a good habit, it will work without this
	if (setsockopt(master_socket, SOL_SOCKET, SO_REUSEADDR, (char *) &opt,
			sizeof(opt)) < 0) {
		perror("setsockopt");
		exit(EXIT_FAILURE);
	}

	//try to specify maximum of 3 pending connections for the master socket
	if (listen(master_socket, 3) < 0) {
		perror("listen");
		exit(EXIT_FAILURE);
	}
	printf("Listening on port %s \n", PORT);

	//accept the incoming connection
	addrlen = sizeof(address);
	puts("Waiting for connections ...");

	while (TRUE) {
		//clear the socket set
		FD_ZERO(&readfds);
		//add master socket to set
		FD_SET(master_socket, &readfds);
		max_sd = master_socket;

#ifdef MODULE_SERIAL
		FD_SET(my_com_conf->fd,&readfds);
		max_sd = max_sd>my_com_conf->fd?max_sd:my_com_conf->fd;
#endif

#ifdef MODULE_BLUETOOTH
		FD_SET(blue_fd,&readfds);
		max_sd = max_sd>blue_fd?max_sd:blue_fd;
#endif

		//add child sockets to set
		for (i = 0; i < max_clients; i++) {
			//socket descriptor
			sd = client_socket[i];

			//if valid socket descriptor then add to read list
			if (sd > 0)
				FD_SET(sd, &readfds);

			//highest file descriptor number, need it for the select function
			if (sd > max_sd)
				max_sd = sd;
		}

		//wait for an activity on one of the sockets , timeout is NULL , so wait indefinitely
		activity = select(max_sd + 1, &readfds, NULL, NULL, NULL);

		if ((activity < 0) && (errno != EINTR)) {
			printf("select error");
		}

		//If something happened on the master socket , then its an incoming connection
		if (FD_ISSET(master_socket, &readfds)) {
			if ((new_socket = accept(master_socket,
					(struct sockaddr *) &address, (socklen_t*) &addrlen)) < 0) {
				perror("accept");
				exit(EXIT_FAILURE);
			}

			//add new socket to array of sockets
			for (i = 0; i < max_clients; i++) {
				//if position is empty, create new one
				if (client_socket[i] == 0) {
					client_socket[i] = new_socket;
					// 初始化buffer
					buffer_p[i] = buffer[i];
					memset(buffer_p[i], 0, MAXLEN);
					buffer_data_size[i] = 0;

					printf("accepted #%d client\n", i);
					break;
				}
			}
		}

#ifdef MODULE_SERIAL
		// 串口读
		if (FD_ISSET(my_com_conf->fd, &readfds)) {
			/* 非阻塞读取 */
			valread=sp_nonblocking_read(my_com_conf->com_port,buffer_com_p+buffer_com_data_size,MAXLEN);
			if(valread<0) {
				printf("read data from com error: %d\n",valread);
				return 1;
				buffer_com_data_size=0;
				buffer_com_p=buffer_com;
			} else {
				buffer_com_data_size+=valread;
				/* 读完所有数据,串口数据包必须以\r\n结尾 */
				if(buffer_com[buffer_com_data_size-2]==13 && buffer_com[buffer_com_data_size-1]==10) {
					printf("- - - - - - - - - -\nread from COM ok\n");
					buffer_com_p[buffer_com_data_size]=0;

					my_contents[MAXCLIENTS]=new_user_content_from_str(buffer_com,com_devicename,get_direction(buffer_com));
					if(!my_contents[MAXCLIENTS]) {
						printf("invalid packet!\n");
					} else {
						printf("  %s",com_devicename);
						redirect_from_user_content(my_contents[MAXCLIENTS]);
					}
					my_free(my_contents[MAXCLIENTS]);
					/* reset buffer offset */
					buffer_com_data_size=0;
					buffer_com_p=buffer_com;
				}
			}
		}
#endif

#ifdef MODULE_BLUETOOTH
		// 蓝牙读
		if(FD_ISSET(blue_fd,&readfds)) {
			// accept one connection
			blue_fd_client = accept(blue_fd, (struct sockaddr *)&blue_rem_addr, &blue_opt);

			ba2str( &blue_rem_addr.rc_bdaddr, blue_sender_MAC );

			// read data from the client
			blue_bytes_read = read(blue_fd_client, blue_buffer, sizeof(blue_buffer));
			if( blue_bytes_read > 0 ) {
				printf("- - - - - - - - - -\nread from bluetooth ok\n");
				blue_buffer[blue_bytes_read]=0;

				blue_user_content=new_user_content_from_str(blue_buffer,blue_sender_MAC,get_direction(blue_buffer));
				if(!blue_user_content) {
					printf("invalid packet!\n");
				} else {
					printf("  %s",blue_sender_MAC);
					redirect_from_user_content(blue_user_content);
				}
				my_free(blue_user_content);
			} else {
				printf("bluetooth recv data error!\n");
			}

			// close connection
			close(blue_fd_client);
		}
#endif		

		// 局域网ip读
		for (i = 0; i < max_clients; i++) {
			sd = client_socket[i];

			if (FD_ISSET(sd, &readfds)) {
				//Check if it was for closing , and also read the incoming message
				if ((valread = read(sd, buffer_p[i] + buffer_data_size[i],
						MAXLEN)) == 0) {
					//Somebody disconnected , get his details and print
					buffer[i][buffer_data_size[i]] = 0;
					getpeername(sd, (struct sockaddr*) &address,
							(socklen_t*) &addrlen);
					printf(
							"- - - - - - - - - -\nread %d bytes from LAN client\n",
							buffer_data_size[i]);

					//Close the socket and mark as 0 in list for reuse
					close(sd);
					client_socket[i] = 0;

					/* convert port(interger) to char* */
					sprintf(itoa_buffer, "%d", ntohs(address.sin_port));
					header = get_header_ipv4(inet_ntoa(address.sin_addr),
							itoa_buffer);
					/* create relay struct: from LAN ip, to serial */
					my_contents[i] = new_user_content_from_str(buffer[i],
							header, get_direction(buffer[i]));

					if (!my_contents[i]) {
						printf("invalid packet!\n");
					} else {
						printf("  %s", header);
						redirect_from_user_content(my_contents[i]);
					}
					my_free(header);
					my_free(my_contents[i]);

				} else {
					/* 累加数据 */
					buffer_data_size[i] += valread;
				}
			}
		}
	}

#ifdef MODULE_SERIAL
	sp_close(my_com_conf->com_port);
	sp_free_port(my_com_conf->com_port);
	sp_free_config(my_com_conf->com_conf);
	my_free(my_com_conf);
#endif

#ifdef MODULE_BLUETOOTH
	close(blue_fd);
#endif

	close(master_socket);
	printf("exit..\n");
	return 0;
}