mirror of
https://github.com/wjwwood/serial.git
synced 2026-01-22 19:54:57 +08:00
Compare commits
No commits in common. "main" and "v1.0" have entirely different histories.
7
.gitignore
vendored
7
.gitignore
vendored
@ -25,10 +25,3 @@ msg_gen
|
||||
srv_gen
|
||||
doc/html
|
||||
*sublime-workspace
|
||||
*.user
|
||||
*.suo
|
||||
*.sdf
|
||||
*.opensdf
|
||||
ipch
|
||||
Debug
|
||||
Release
|
||||
|
||||
10
.travis.yml
10
.travis.yml
@ -1,10 +0,0 @@
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
language: cpp
|
||||
install:
|
||||
- make install_deps
|
||||
- source setup.bash
|
||||
script:
|
||||
- mkdir build && cd build && cmake .. -DPYTHON_EXECUTABLE=$(which python2) && make && make tests && make run_tests
|
||||
- catkin_test_results .
|
||||
@ -1,85 +0,0 @@
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
Changelog for package serial
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
1.2.1 (2015-04-21)
|
||||
------------------
|
||||
* Removed the use of a C++11 feature for compatibility with older browsers.
|
||||
* Fixed an issue with cross compiling with mingw on Windows.
|
||||
* Restructured Visual Studio project layout.
|
||||
* Added include of ``#include <AvailabilityMacros.h>`` on OS X (listing of ports).
|
||||
* Fixed MXE for the listing of ports on Windows.
|
||||
* Now closes file device if ``reconfigureDevice`` fails (Windows).
|
||||
* Added the MARK/SPACE parity bit option, also made it optional.
|
||||
Adding the enumeration values for MARK and SPACE was the only code change to an API header.
|
||||
It should not affect ABI or API.
|
||||
* Added support for 576000 baud on Linux.
|
||||
* Now releases iterator properly in listing of ports code for OS X.
|
||||
* Fixed the ability to open COM ports over COM10 on Windows.
|
||||
* Fixed up some documentation about exceptions in ``serial.h``.
|
||||
|
||||
1.2.0 (2014-07-02)
|
||||
------------------
|
||||
* Removed vestigial ``read_cache_`` private member variable from Serial::Serial
|
||||
* Fixed usage of scoped locks
|
||||
Previously they were getting destroyed immediately because they were not stored in a temporary scope variable
|
||||
* Added check of return value from close in Serial::SerialImpl::close () in unix.cc and win.cc
|
||||
* Added ability to enumerate ports on linux and windows.
|
||||
Updated serial_example.cc to show example of port enumeration.
|
||||
* Fixed compile on VS2013
|
||||
* Added functions ``waitReadable`` and ``waitByteTimes`` with implemenations for Unix to support high performance reading
|
||||
* Contributors: Christopher Baker, Craig Lilley, Konstantina Kastanara, Mike Purvis, William Woodall
|
||||
|
||||
1.1.7 (2014-02-20)
|
||||
------------------
|
||||
* Improved support for mingw (mxe.cc)
|
||||
* Fix compilation warning
|
||||
See issue `#53 <https://github.com/wjwwood/serial/issues/53>`_
|
||||
* Improved timer handling in unix implementation
|
||||
* fix broken ifdef _WIN32
|
||||
* Fix broken ioctl calls, add exception handling.
|
||||
* Code guards for platform-specific implementations. (when not using cmake / catkin)
|
||||
* Contributors: Christopher Baker, Mike Purvis, Nicolas Bigaouette, William Woodall, dawid
|
||||
|
||||
1.1.6 (2013-10-17)
|
||||
------------------
|
||||
* Move stopbits_one_point_five to the end of the enum, so that it doesn't alias with stopbits_two.
|
||||
|
||||
1.1.5 (2013-09-23)
|
||||
------------------
|
||||
* Fix license labeling, I put BSD, but the license has always been MIT...
|
||||
* Added Microsoft Visual Studio 2010 project to make compiling on Windows easier.
|
||||
* Implemented Serial::available() for Windows
|
||||
* Update how custom baudrates are handled on OS X
|
||||
This is taken from the example serial program on Apple's developer website, see:
|
||||
http://free-pascal-general.1045716.n5.nabble.com/Non-standard-baud-rates-in-OS-X-IOSSIOSPEED-IOCTL-td4699923.html
|
||||
* Timout settings are now applied by reconfigurePort
|
||||
* Pass LPCWSTR to CreateFile in Windows impl
|
||||
* Use wstring for ``port_`` type in Windows impl
|
||||
|
||||
1.1.4 (2013-06-12 00:13:18 -0600)
|
||||
---------------------------------
|
||||
* Timing calculation fix for read and write.
|
||||
Fixes `#27 <https://github.com/wjwwood/serial/issues/27>`_
|
||||
* Update list of exceptions thrown from constructor.
|
||||
* fix, by Thomas Hoppe <thomas.hoppe@cesys.com>
|
||||
For SerialException's:
|
||||
* The name was misspelled...
|
||||
* Use std::string's for error messages to prevent corruption of messages on some platforms
|
||||
* alloca.h does not exist on OpenBSD either.
|
||||
|
||||
1.1.3 (2013-01-09 10:54:34 -0800)
|
||||
---------------------------------
|
||||
* Install headers
|
||||
|
||||
1.1.2 (2012-12-14 14:08:55 -0800)
|
||||
---------------------------------
|
||||
* Fix buildtool depends
|
||||
|
||||
1.1.1 (2012-12-03)
|
||||
------------------
|
||||
* Removed rt linking on OS X. Fixes `#24 <https://github.com/wjwwood/serial/issues/24>`_.
|
||||
|
||||
1.1.0 (2012-10-24)
|
||||
------------------
|
||||
* Previous history is unstructured and therefore has been truncated. See the commit messages for more info.
|
||||
@ -1,81 +1,21 @@
|
||||
cmake_minimum_required(VERSION 2.8.3)
|
||||
project(serial)
|
||||
cmake_minimum_required(VERSION 2.4.6)
|
||||
|
||||
# Find catkin
|
||||
find_package(catkin REQUIRED)
|
||||
set(ROS_ROOT $ENV{ROS_ROOT})
|
||||
|
||||
if(APPLE)
|
||||
find_library(IOKIT_LIBRARY IOKit)
|
||||
find_library(FOUNDATION_LIBRARY Foundation)
|
||||
endif()
|
||||
if(DEFINED ROS_ROOT)
|
||||
option(SERIAL_BUILD_WIHOUT_ROS "Build without ROS?" OFF)
|
||||
else(DEFINED ROS_ROOT)
|
||||
option(SERIAL_BUILD_WIHOUT_ROS "Build without ROS?" ON)
|
||||
endif(DEFINED ROS_ROOT)
|
||||
|
||||
if(UNIX AND NOT APPLE)
|
||||
# If Linux, add rt and pthread
|
||||
set(rt_LIBRARIES rt)
|
||||
set(pthread_LIBRARIES pthread)
|
||||
catkin_package(
|
||||
LIBRARIES ${PROJECT_NAME}
|
||||
INCLUDE_DIRS include
|
||||
DEPENDS rt pthread
|
||||
)
|
||||
else()
|
||||
# Otherwise normal call
|
||||
catkin_package(
|
||||
LIBRARIES ${PROJECT_NAME}
|
||||
INCLUDE_DIRS include
|
||||
)
|
||||
endif()
|
||||
|
||||
## Sources
|
||||
set(serial_SRCS
|
||||
src/serial.cc
|
||||
include/serial/serial.h
|
||||
include/serial/v8stdint.h
|
||||
)
|
||||
if(APPLE)
|
||||
# If OSX
|
||||
list(APPEND serial_SRCS src/impl/unix.cc)
|
||||
list(APPEND serial_SRCS src/impl/list_ports/list_ports_osx.cc)
|
||||
elseif(UNIX)
|
||||
# If unix
|
||||
list(APPEND serial_SRCS src/impl/unix.cc)
|
||||
list(APPEND serial_SRCS src/impl/list_ports/list_ports_linux.cc)
|
||||
else()
|
||||
# If windows
|
||||
list(APPEND serial_SRCS src/impl/win.cc)
|
||||
list(APPEND serial_SRCS src/impl/list_ports/list_ports_win.cc)
|
||||
endif()
|
||||
|
||||
## Add serial library
|
||||
add_library(${PROJECT_NAME} ${serial_SRCS})
|
||||
if(APPLE)
|
||||
target_link_libraries(${PROJECT_NAME} ${FOUNDATION_LIBRARY} ${IOKIT_LIBRARY})
|
||||
elseif(UNIX)
|
||||
target_link_libraries(${PROJECT_NAME} rt pthread)
|
||||
else()
|
||||
target_link_libraries(${PROJECT_NAME} setupapi)
|
||||
endif()
|
||||
|
||||
## Uncomment for example
|
||||
add_executable(serial_example examples/serial_example.cc)
|
||||
add_dependencies(serial_example ${PROJECT_NAME})
|
||||
target_link_libraries(serial_example ${PROJECT_NAME})
|
||||
|
||||
## Include headers
|
||||
include_directories(include)
|
||||
|
||||
## Install executable
|
||||
install(TARGETS ${PROJECT_NAME}
|
||||
ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
|
||||
LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
|
||||
RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
|
||||
)
|
||||
|
||||
## Install headers
|
||||
install(FILES include/serial/serial.h include/serial/v8stdint.h
|
||||
DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION}/serial)
|
||||
|
||||
## Tests
|
||||
if(CATKIN_ENABLE_TESTING)
|
||||
add_subdirectory(tests)
|
||||
endif()
|
||||
if(DEFINED ROS_ROOT AND NOT SERIAL_BUILD_WIHOUT_ROS)
|
||||
# Build with ROS
|
||||
include(serial_ros.cmake)
|
||||
message("Building with ROS")
|
||||
build_serial()
|
||||
else(DEFINED ROS_ROOT AND NOT SERIAL_BUILD_WIHOUT_ROS)
|
||||
# Build normally
|
||||
include(serial.cmake)
|
||||
message("Building stand alone")
|
||||
build_serial()
|
||||
endif(DEFINED ROS_ROOT AND NOT SERIAL_BUILD_WIHOUT_ROS)
|
||||
|
||||
15
Findserial.cmake
Normal file
15
Findserial.cmake
Normal file
@ -0,0 +1,15 @@
|
||||
find_path(serial_INCLUDE_DIRS serial/serial.h /usr/include
|
||||
/usr/local/include "$ENV{NAMER_ROOT}")
|
||||
|
||||
find_library(serial_LIBRARIES serial /usr/lib /usr/local/lib
|
||||
"$ENV{NAMER_ROOT}")
|
||||
|
||||
set(serial_FOUND TRUE)
|
||||
|
||||
if (NOT serial_INCLUDE_DIRS)
|
||||
set(serial_FOUND FALSE)
|
||||
endif (NOT serial_INCLUDE_DIRS)
|
||||
|
||||
if (NOT serial_LIBRARIES)
|
||||
set(serial_FOUND FALSE)
|
||||
endif (NOT serial_LIBRARIES)
|
||||
7
LICENSE
7
LICENSE
@ -1,7 +0,0 @@
|
||||
Copyright (c) 2012 William Woodall, John Harrison
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
63
Makefile
63
Makefile
@ -1,62 +1,5 @@
|
||||
all: serial
|
||||
|
||||
CMAKE_FLAGS := -DCMAKE_INSTALL_PREFIX=/tmp/usr/local
|
||||
UNAME := $(shell uname -s)
|
||||
|
||||
install_deps:
|
||||
ifeq ($(UNAME),Darwin)
|
||||
brew tap ros/deps
|
||||
brew update
|
||||
brew outdated boost || brew upgrade boost || brew install boost
|
||||
brew outdated python || brew upgrade python || brew install python
|
||||
sudo -H python2 -m pip install -U pip setuptools
|
||||
sudo -H python2 -m pip install --force-reinstall --no-deps -U pip
|
||||
sudo -H python2 -m pip install rosinstall_generator wstool rosdep empy catkin_pkg
|
||||
sudo -H rosdep init
|
||||
rosdep update
|
||||
mkdir catkin_ws
|
||||
cd catkin_ws && rosinstall_generator catkin --rosdistro hydro --tar > catkin.rosinstall
|
||||
cd catkin_ws && wstool init src catkin.rosinstall
|
||||
cd catkin_ws && rosdep install --from-paths src --ignore-src -y
|
||||
cd catkin_ws && python2 ./src/catkin/bin/catkin_make -DPYTHON_EXECUTABLE=`which python2` install
|
||||
echo "source catkin_ws/install/setup.bash" > setup.bash
|
||||
ifdef ROS_ROOT
|
||||
include $(shell rospack find mk)/cmake.mk
|
||||
else
|
||||
sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu precise main" > /etc/apt/sources.list.d/ros-latest.list'
|
||||
wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
|
||||
sudo apt-get update
|
||||
sudo apt-get install ros-hydro-catkin libboost-dev
|
||||
echo "source /opt/ros/hydro/setup.bash" > setup.bash
|
||||
endif
|
||||
|
||||
install:
|
||||
cd build && make install
|
||||
|
||||
serial:
|
||||
@mkdir -p build
|
||||
cd build && cmake $(CMAKE_FLAGS) ..
|
||||
ifneq ($(MAKE),)
|
||||
cd build && $(MAKE)
|
||||
else
|
||||
cd build && make
|
||||
endif
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
rm -rf build
|
||||
|
||||
.PHONY: doc
|
||||
doc:
|
||||
@doxygen doc/Doxyfile
|
||||
ifeq ($(UNAME),Darwin)
|
||||
@open doc/html/index.html
|
||||
endif
|
||||
|
||||
.PHONY: test
|
||||
test:
|
||||
@mkdir -p build
|
||||
cd build && cmake $(CMAKE_FLAGS) ..
|
||||
ifneq ($(MAKE),)
|
||||
cd build && $(MAKE) run_tests
|
||||
else
|
||||
cd build && make run_tests
|
||||
include serial.makefile
|
||||
endif
|
||||
|
||||
110
README.md
110
README.md
@ -1,63 +1,105 @@
|
||||
# Serial Communication Library
|
||||
|
||||
[](https://travis-ci.org/wjwwood/serial)*(Linux and OS X)* [](https://ci.appveyor.com/project/wjwwood/serial)*(Windows)*
|
||||
## Note about Repository Changes
|
||||
|
||||
This is a cross-platform library for interfacing with rs-232 serial like ports written in C++. It provides a modern C++ interface with a workflow designed to look and feel like PySerial, but with the speed and control provided by C++.
|
||||
If you had the serial library checked previously and now those settings seem broken, it is because I recently reorganized the serial repository. I wanted these checkouts to break so that you were forced to update.
|
||||
|
||||
This library is in use in several robotics related projects and can be built and installed to the OS like most unix libraries with make and then sudo make install, but because it is a catkin project it can also be built along side other catkin projects in a catkin workspace.
|
||||
If you previously were using the `master` branch, that version is now under the git tag `v0.1`.
|
||||
|
||||
Serial is a class that provides the basic interface common to serial libraries (open, close, read, write, etc..) and requires no extra dependencies. It also provides tight control over timeouts and control over handshaking lines.
|
||||
If you were previously using the `boostless` branch, that version is now tagged as `v0.2` or `boostless`.
|
||||
|
||||
### Documentation
|
||||
If you were previously using the `new_api` branch, that has become the new `master` branch and is also tagged `v1.0`.
|
||||
|
||||
Website: http://wjwwood.github.io/serial/
|
||||
## Documentation
|
||||
|
||||
API Documentation: http://wjwwood.github.io/serial/doc/1.1.0/index.html
|
||||
http://wjwwood.github.com/serial/docs/v1.0/index.html
|
||||
|
||||
### Dependencies
|
||||
## Dependencies
|
||||
|
||||
Required:
|
||||
* [catkin](http://www.ros.org/wiki/catkin) - cmake and Python based buildsystem
|
||||
* [cmake](http://www.cmake.org) - buildsystem
|
||||
* [Python](http://www.python.org) - scripting language
|
||||
* [empy](http://www.alcyone.com/pyos/empy/) - Python templating library
|
||||
* [catkin_pkg](http://pypi.python.org/pypi/catkin_pkg/) - Runtime Python library for catkin
|
||||
* CMake, for the build system: http://www.cmake.org/
|
||||
* (Optional) ROS: http://ros.org/wiki
|
||||
|
||||
Optional (for documentation):
|
||||
* [Doxygen](http://www.doxygen.org/) - Documentation generation tool
|
||||
* [graphviz](http://www.graphviz.org/) - Graph visualization software
|
||||
## Stand Alone Installation
|
||||
|
||||
### Install
|
||||
Get the source:
|
||||
|
||||
Get the code:
|
||||
git clone git://github.com/wjwwood/serial.git
|
||||
cd serial
|
||||
|
||||
git clone https://github.com/wjwwood/serial.git
|
||||
|
||||
Build:
|
||||
Compile the code:
|
||||
|
||||
make
|
||||
|
||||
Build and run the tests:
|
||||
Or run cmake youself:
|
||||
|
||||
make test
|
||||
mkdir build && cd build
|
||||
cmake ..
|
||||
make
|
||||
|
||||
Install the code (UNIX):
|
||||
|
||||
make
|
||||
sudo make install
|
||||
|
||||
Uninstall the code (UNIX):
|
||||
|
||||
make
|
||||
sudo make uninstall
|
||||
|
||||
Build the documentation:
|
||||
|
||||
make doc
|
||||
Comming Soon!
|
||||
|
||||
Install:
|
||||
## Using within ROS workspace
|
||||
|
||||
make install
|
||||
Setup workspace (skip if you already have one):
|
||||
|
||||
### License
|
||||
mkdir some_ros_workspace
|
||||
cd some_ros_workspace
|
||||
rosws init . /opt/ros/fuerte # Replace the path here
|
||||
source setup.bash
|
||||
|
||||
[The MIT License](LICENSE)
|
||||
Add the serial unary stack to your ROS workspace:
|
||||
|
||||
### Authors
|
||||
rosws merge https://raw.github.com/wjwwood/serial/80c0/serial.rosinstall
|
||||
|
||||
William Woodall <wjwwood@gmail.com>
|
||||
John Harrison <ash.gti@gmail.com>
|
||||
Rerun rosinstall to fetch it:
|
||||
|
||||
### Contact
|
||||
rosinstall .
|
||||
source setup.bash
|
||||
|
||||
William Woodall <william@osrfoundation.org>
|
||||
Build the unary stack:
|
||||
|
||||
rosmake serial --rosdep-install
|
||||
|
||||
Run the example:
|
||||
|
||||
rosrun serial serial_example
|
||||
|
||||
Use it in your ROS pkg by adding this line to your `manifest.xml`:
|
||||
|
||||
<depend package="serial" />
|
||||
|
||||
## License
|
||||
|
||||
The BSD License
|
||||
|
||||
Copyright (c) 2012 William Woodall
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
10
changes.txt
10
changes.txt
@ -1,10 +0,0 @@
|
||||
# 1.1.0 10-24-2012
|
||||
|
||||
* Converted the build system to catkin
|
||||
|
||||
# v1.0.1 8-27-2012
|
||||
|
||||
* Added baudrates: 1000000, 11520000, 2000000, 2500000, 3000000, 3500000, and 4000000
|
||||
* Linking related bug fixes on Linux and OS X
|
||||
* Custom baudrate bug fix. Closes issue #18.
|
||||
|
||||
2502
doc/Doxyfile
2502
doc/Doxyfile
File diff suppressed because it is too large
Load Diff
@ -55,4 +55,10 @@ To install simply:
|
||||
sudo make install
|
||||
</pre>
|
||||
|
||||
To uninstall simply:
|
||||
|
||||
<pre>
|
||||
sudo make uninstall
|
||||
</pre>
|
||||
|
||||
*/
|
||||
@ -4,11 +4,11 @@
|
||||
* Alternatively, you could use an Arduino:
|
||||
*
|
||||
* <pre>
|
||||
* void setup() {
|
||||
* setup() {
|
||||
* Serial.begin(<insert your baudrate here>);
|
||||
* }
|
||||
*
|
||||
* void loop() {
|
||||
* loop() {
|
||||
* if (Serial.available()) {
|
||||
* Serial.write(Serial.read());
|
||||
* }
|
||||
@ -34,7 +34,6 @@ using std::exception;
|
||||
using std::cout;
|
||||
using std::cerr;
|
||||
using std::endl;
|
||||
using std::vector;
|
||||
|
||||
void my_sleep(unsigned long milliseconds) {
|
||||
#ifdef _WIN32
|
||||
@ -44,53 +43,19 @@ void my_sleep(unsigned long milliseconds) {
|
||||
#endif
|
||||
}
|
||||
|
||||
void enumerate_ports()
|
||||
{
|
||||
vector<serial::PortInfo> devices_found = serial::list_ports();
|
||||
|
||||
vector<serial::PortInfo>::iterator iter = devices_found.begin();
|
||||
|
||||
while( iter != devices_found.end() )
|
||||
{
|
||||
serial::PortInfo device = *iter++;
|
||||
|
||||
printf( "(%s, %s, %s)\n", device.port.c_str(), device.description.c_str(),
|
||||
device.hardware_id.c_str() );
|
||||
}
|
||||
}
|
||||
|
||||
void print_usage()
|
||||
{
|
||||
cerr << "Usage: test_serial {-e|<serial port address>} ";
|
||||
cerr << "<baudrate> [test string]" << endl;
|
||||
}
|
||||
|
||||
int run(int argc, char **argv)
|
||||
{
|
||||
if(argc < 2) {
|
||||
print_usage();
|
||||
if(argc < 3) {
|
||||
cerr << "Usage: test_serial <serial port address> ";
|
||||
cerr << "<baudrate> [test string]" << endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Argument 1 is the serial port or enumerate flag
|
||||
// Argument 1 is the serial port
|
||||
string port(argv[1]);
|
||||
|
||||
if( port == "-e" ) {
|
||||
enumerate_ports();
|
||||
return 0;
|
||||
}
|
||||
else if( argc < 3 ) {
|
||||
print_usage();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Argument 2 is the baudrate
|
||||
unsigned long baud = 0;
|
||||
#if defined(WIN32) && !defined(__MINGW32__)
|
||||
sscanf_s(argv[2], "%lu", &baud);
|
||||
#else
|
||||
sscanf(argv[2], "%lu", &baud);
|
||||
#endif
|
||||
|
||||
// port, baudrate, timeout in milliseconds
|
||||
serial::Serial my_serial(port, baud, serial::Timeout::simpleTimeout(1000));
|
||||
|
||||
@ -35,8 +35,6 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#if !defined(_WIN32)
|
||||
|
||||
#ifndef SERIAL_IMPL_UNIX_H
|
||||
#define SERIAL_IMPL_UNIX_H
|
||||
|
||||
@ -46,23 +44,12 @@
|
||||
|
||||
namespace serial {
|
||||
|
||||
using std::size_t;
|
||||
using std::string;
|
||||
using std::invalid_argument;
|
||||
|
||||
using serial::SerialException;
|
||||
using serial::SerialExecption;
|
||||
using serial::IOException;
|
||||
|
||||
class MillisecondTimer {
|
||||
public:
|
||||
MillisecondTimer(const uint32_t millis);
|
||||
int64_t remaining();
|
||||
|
||||
private:
|
||||
static timespec timespec_now();
|
||||
timespec expiry;
|
||||
};
|
||||
|
||||
class serial::Serial::SerialImpl {
|
||||
public:
|
||||
SerialImpl (const string &port,
|
||||
@ -86,12 +73,6 @@ public:
|
||||
size_t
|
||||
available ();
|
||||
|
||||
bool
|
||||
waitReadable (uint32_t timeout);
|
||||
|
||||
void
|
||||
waitByteTimes (size_t count);
|
||||
|
||||
size_t
|
||||
read (uint8_t *buf, size_t size = 1);
|
||||
|
||||
@ -201,7 +182,6 @@ private:
|
||||
|
||||
Timeout timeout_; // Timeout for read operations
|
||||
unsigned long baudrate_; // Baudrate
|
||||
uint32_t byte_time_ns_; // Nanoseconds to transmit/receive a single byte
|
||||
|
||||
parity_t parity_; // Parity
|
||||
bytesize_t bytesize_; // Size of the bytes
|
||||
@ -217,5 +197,3 @@ private:
|
||||
}
|
||||
|
||||
#endif // SERIAL_IMPL_UNIX_H
|
||||
|
||||
#endif // !defined(_WIN32)
|
||||
|
||||
@ -34,8 +34,6 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#if defined(_WIN32)
|
||||
|
||||
#ifndef SERIAL_IMPL_WINDOWS_H
|
||||
#define SERIAL_IMPL_WINDOWS_H
|
||||
|
||||
@ -46,10 +44,9 @@
|
||||
namespace serial {
|
||||
|
||||
using std::string;
|
||||
using std::wstring;
|
||||
using std::invalid_argument;
|
||||
|
||||
using serial::SerialException;
|
||||
using serial::SerialExecption;
|
||||
using serial::IOException;
|
||||
|
||||
class serial::Serial::SerialImpl {
|
||||
@ -75,12 +72,6 @@ public:
|
||||
size_t
|
||||
available ();
|
||||
|
||||
bool
|
||||
waitReadable (uint32_t timeout);
|
||||
|
||||
void
|
||||
waitByteTimes (size_t count);
|
||||
|
||||
size_t
|
||||
read (uint8_t *buf, size_t size = 1);
|
||||
|
||||
@ -181,7 +172,7 @@ protected:
|
||||
void reconfigurePort ();
|
||||
|
||||
private:
|
||||
wstring port_; // Path to the file descriptor
|
||||
string port_; // Path to the file descriptor
|
||||
HANDLE fd_;
|
||||
|
||||
bool is_open_;
|
||||
@ -203,5 +194,3 @@ private:
|
||||
}
|
||||
|
||||
#endif // SERIAL_IMPL_WINDOWS_H
|
||||
|
||||
#endif // if defined(_WIN32)
|
||||
|
||||
@ -66,9 +66,7 @@ typedef enum {
|
||||
typedef enum {
|
||||
parity_none = 0,
|
||||
parity_odd = 1,
|
||||
parity_even = 2,
|
||||
parity_mark = 3,
|
||||
parity_space = 4
|
||||
parity_even = 2
|
||||
} parity_t;
|
||||
|
||||
/*!
|
||||
@ -76,8 +74,8 @@ typedef enum {
|
||||
*/
|
||||
typedef enum {
|
||||
stopbits_one = 1,
|
||||
stopbits_two = 2,
|
||||
stopbits_one_point_five
|
||||
stopbits_one_point_five,
|
||||
stopbits_two = 2
|
||||
} stopbits_t;
|
||||
|
||||
/*!
|
||||
@ -128,10 +126,8 @@ struct Timeout {
|
||||
*/
|
||||
uint32_t write_timeout_multiplier;
|
||||
|
||||
explicit Timeout (uint32_t inter_byte_timeout_=0,
|
||||
uint32_t read_timeout_constant_=0,
|
||||
uint32_t read_timeout_multiplier_=0,
|
||||
uint32_t write_timeout_constant_=0,
|
||||
Timeout (uint32_t inter_byte_timeout_=0, uint32_t read_timeout_constant_=0,
|
||||
uint32_t read_timeout_multiplier_=0, uint32_t write_timeout_constant_=0,
|
||||
uint32_t write_timeout_multiplier_=0)
|
||||
: inter_byte_timeout(inter_byte_timeout_),
|
||||
read_timeout_constant(read_timeout_constant_),
|
||||
@ -173,9 +169,7 @@ public:
|
||||
* flowcontrol_none, possible values are: flowcontrol_none,
|
||||
* flowcontrol_software, flowcontrol_hardware
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::IOException
|
||||
* \throw std::invalid_argument
|
||||
* \throw PortNotOpenedException
|
||||
*/
|
||||
Serial (const std::string &port = "",
|
||||
uint32_t baudrate = 9600,
|
||||
@ -198,7 +192,7 @@ public:
|
||||
* \see Serial::Serial
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw serial::SerialException
|
||||
* \throw serial::SerialExecption
|
||||
* \throw serial::IOException
|
||||
*/
|
||||
void
|
||||
@ -219,20 +213,6 @@ public:
|
||||
size_t
|
||||
available ();
|
||||
|
||||
/*! Block until there is serial data to read or read_timeout_constant
|
||||
* number of milliseconds have elapsed. The return value is true when
|
||||
* the function exits with the port in a readable state, false otherwise
|
||||
* (due to timeout or select interruption). */
|
||||
bool
|
||||
waitReadable ();
|
||||
|
||||
/*! Block for a period of time corresponding to the transmission time of
|
||||
* count characters at present serial settings. This may be used in con-
|
||||
* junction with waitReadable to read larger blocks of data from the
|
||||
* port. */
|
||||
void
|
||||
waitByteTimes (size_t count);
|
||||
|
||||
/*! Read a given amount of bytes from the serial port into a given buffer.
|
||||
*
|
||||
* The read function will return in one of three cases:
|
||||
@ -257,9 +237,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes read as a result of the
|
||||
* call to read.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
size_t
|
||||
read (uint8_t *buffer, size_t size);
|
||||
@ -271,9 +248,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes read as a result of the
|
||||
* call to read.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
size_t
|
||||
read (std::vector<uint8_t> &buffer, size_t size = 1);
|
||||
@ -285,9 +259,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes read as a result of the
|
||||
* call to read.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
size_t
|
||||
read (std::string &buffer, size_t size = 1);
|
||||
@ -298,9 +269,6 @@ public:
|
||||
* \param size A size_t defining how many bytes to be read.
|
||||
*
|
||||
* \return A std::string containing the data read from the port.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
std::string
|
||||
read (size_t size = 1);
|
||||
@ -314,9 +282,6 @@ public:
|
||||
* \param eol A string to match against for the EOL.
|
||||
*
|
||||
* \return A size_t representing the number of bytes read.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
size_t
|
||||
readline (std::string &buffer, size_t size = 65536, std::string eol = "\n");
|
||||
@ -329,9 +294,6 @@ public:
|
||||
* \param eol A string to match against for the EOL.
|
||||
*
|
||||
* \return A std::string containing the line.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
std::string
|
||||
readline (size_t size = 65536, std::string eol = "\n");
|
||||
@ -346,9 +308,6 @@ public:
|
||||
* \param eol A string to match against for the EOL.
|
||||
*
|
||||
* \return A vector<string> containing the lines.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
*/
|
||||
std::vector<std::string>
|
||||
readlines (size_t size = 65536, std::string eol = "\n");
|
||||
@ -363,10 +322,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes actually written to
|
||||
* the serial port.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
* \throw serial::IOException
|
||||
*/
|
||||
size_t
|
||||
write (const uint8_t *data, size_t size);
|
||||
@ -378,10 +333,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes actually written to
|
||||
* the serial port.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
* \throw serial::IOException
|
||||
*/
|
||||
size_t
|
||||
write (const std::vector<uint8_t> &data);
|
||||
@ -393,10 +344,6 @@ public:
|
||||
*
|
||||
* \return A size_t representing the number of bytes actually written to
|
||||
* the serial port.
|
||||
*
|
||||
* \throw serial::PortNotOpenedException
|
||||
* \throw serial::SerialException
|
||||
* \throw serial::IOException
|
||||
*/
|
||||
size_t
|
||||
write (const std::string &data);
|
||||
@ -407,7 +354,7 @@ public:
|
||||
* serial port, which would be something like 'COM1' on Windows and
|
||||
* '/dev/ttyS0' on Linux.
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setPort (const std::string &port);
|
||||
@ -416,7 +363,7 @@ public:
|
||||
*
|
||||
* \see Serial::setPort
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
std::string
|
||||
getPort () const;
|
||||
@ -430,7 +377,7 @@ public:
|
||||
* the serial port that can pass before a timeout occurs. Setting this
|
||||
* to zero will prevent inter byte timeouts from occurring.
|
||||
* * Total time timeout:
|
||||
* * The constant and multiplier component of this timeout condition,
|
||||
* * The the constant and multiplier component of this timeout condition,
|
||||
* for both read and write, are defined in serial::Timeout. This
|
||||
* timeout occurs if the total time since the read or write call was
|
||||
* made exceeds the specified time in milliseconds.
|
||||
@ -450,8 +397,6 @@ public:
|
||||
* reading or writing is complete, when a timeout occurs, or when an
|
||||
* exception occurs.
|
||||
*
|
||||
* A timeout of 0 enables non-blocking mode.
|
||||
*
|
||||
* \param timeout A serial::Timeout struct containing the inter byte
|
||||
* timeout, and the read and write timeout constants and multipliers.
|
||||
*
|
||||
@ -488,11 +433,11 @@ public:
|
||||
* 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000,
|
||||
* 57600, 115200
|
||||
* Some other baudrates that are supported by some comports:
|
||||
* 128000, 153600, 230400, 256000, 460800, 500000, 921600
|
||||
* 128000, 153600, 230400, 256000, 460800, 921600
|
||||
*
|
||||
* \param baudrate An integer that sets the baud rate for the serial port.
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setBaudrate (uint32_t baudrate);
|
||||
@ -503,7 +448,7 @@ public:
|
||||
*
|
||||
* \see Serial::setBaudrate
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
uint32_t
|
||||
getBaudrate () const;
|
||||
@ -514,7 +459,7 @@ public:
|
||||
* default is eightbits, possible values are: fivebits, sixbits, sevenbits,
|
||||
* eightbits
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setBytesize (bytesize_t bytesize);
|
||||
@ -523,7 +468,7 @@ public:
|
||||
*
|
||||
* \see Serial::setBytesize
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
bytesize_t
|
||||
getBytesize () const;
|
||||
@ -533,7 +478,7 @@ public:
|
||||
* \param parity Method of parity, default is parity_none, possible values
|
||||
* are: parity_none, parity_odd, parity_even
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setParity (parity_t parity);
|
||||
@ -542,7 +487,7 @@ public:
|
||||
*
|
||||
* \see Serial::setParity
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
parity_t
|
||||
getParity () const;
|
||||
@ -552,7 +497,7 @@ public:
|
||||
* \param stopbits Number of stop bits used, default is stopbits_one,
|
||||
* possible values are: stopbits_one, stopbits_one_point_five, stopbits_two
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setStopbits (stopbits_t stopbits);
|
||||
@ -561,7 +506,7 @@ public:
|
||||
*
|
||||
* \see Serial::setStopbits
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
stopbits_t
|
||||
getStopbits () const;
|
||||
@ -572,7 +517,7 @@ public:
|
||||
* possible values are: flowcontrol_none, flowcontrol_software,
|
||||
* flowcontrol_hardware
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
void
|
||||
setFlowcontrol (flowcontrol_t flowcontrol);
|
||||
@ -581,7 +526,7 @@ public:
|
||||
*
|
||||
* \see Serial::setFlowcontrol
|
||||
*
|
||||
* \throw std::invalid_argument
|
||||
* \throw InvalidConfigurationException
|
||||
*/
|
||||
flowcontrol_t
|
||||
getFlowcontrol () const;
|
||||
@ -650,7 +595,10 @@ public:
|
||||
private:
|
||||
// Disable copy constructors
|
||||
Serial(const Serial&);
|
||||
Serial& operator=(const Serial&);
|
||||
void operator=(const Serial&);
|
||||
const Serial& operator=(Serial);
|
||||
|
||||
std::string read_cache_; //!< Cache for doing reads in chunks.
|
||||
|
||||
// Pimpl idiom, d_pointer
|
||||
class SerialImpl;
|
||||
@ -669,107 +617,79 @@ private:
|
||||
|
||||
};
|
||||
|
||||
class SerialException : public std::exception
|
||||
class SerialExecption : public std::exception
|
||||
{
|
||||
// Disable copy constructors
|
||||
SerialException& operator=(const SerialException&);
|
||||
std::string e_what_;
|
||||
void operator=(const SerialExecption&);
|
||||
const SerialExecption& operator=(SerialExecption);
|
||||
const char* e_what_;
|
||||
public:
|
||||
SerialException (const char *description) {
|
||||
std::stringstream ss;
|
||||
ss << "SerialException " << description << " failed.";
|
||||
e_what_ = ss.str();
|
||||
SerialExecption (const char *description) : e_what_ (description) {}
|
||||
SerialExecption (const SerialExecption& other) {
|
||||
e_what_ = other.e_what_;
|
||||
}
|
||||
SerialException (const SerialException& other) : e_what_(other.e_what_) {}
|
||||
virtual ~SerialException() throw() {}
|
||||
virtual const char* what () const throw () {
|
||||
return e_what_.c_str();
|
||||
|
||||
virtual const char* what () const throw ()
|
||||
{
|
||||
std::stringstream ss;
|
||||
ss << "SerialException " << e_what_ << " failed.";
|
||||
return ss.str ().c_str ();
|
||||
}
|
||||
};
|
||||
|
||||
class IOException : public std::exception
|
||||
{
|
||||
// Disable copy constructors
|
||||
IOException& operator=(const IOException&);
|
||||
void operator=(const IOException&);
|
||||
const IOException& operator=(IOException);
|
||||
std::string file_;
|
||||
int line_;
|
||||
std::string e_what_;
|
||||
const char* e_what_;
|
||||
int errno_;
|
||||
public:
|
||||
explicit IOException (std::string file, int line, int errnum)
|
||||
: file_(file), line_(line), errno_(errnum) {
|
||||
std::stringstream ss;
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
char error_str [1024];
|
||||
strerror_s(error_str, 1024, errnum);
|
||||
#else
|
||||
char * error_str = strerror(errnum);
|
||||
#endif
|
||||
ss << "IO Exception (" << errno_ << "): " << error_str;
|
||||
ss << ", file " << file_ << ", line " << line_ << ".";
|
||||
e_what_ = ss.str();
|
||||
}
|
||||
: file_(file), line_(line), e_what_ (strerror (errnum)), errno_(errnum) {}
|
||||
explicit IOException (std::string file, int line, const char * description)
|
||||
: file_(file), line_(line), errno_(0) {
|
||||
std::stringstream ss;
|
||||
ss << "IO Exception: " << description;
|
||||
ss << ", file " << file_ << ", line " << line_ << ".";
|
||||
e_what_ = ss.str();
|
||||
}
|
||||
: file_(file), line_(line), e_what_ (description), errno_(0) {}
|
||||
virtual ~IOException() throw() {}
|
||||
IOException (const IOException& other) : line_(other.line_), e_what_(other.e_what_), errno_(other.errno_) {}
|
||||
IOException (const IOException& other) {
|
||||
e_what_ = other.e_what_;
|
||||
}
|
||||
|
||||
int getErrorNumber () const { return errno_; }
|
||||
int getErrorNumber () { return errno_; }
|
||||
|
||||
virtual const char* what () const throw () {
|
||||
return e_what_.c_str();
|
||||
virtual const char* what () const throw ()
|
||||
{
|
||||
std::stringstream ss;
|
||||
if (errno_ == 0)
|
||||
ss << "IO Exception: " << e_what_;
|
||||
else
|
||||
ss << "IO Exception (" << errno_ << "): " << e_what_;
|
||||
ss << ", file " << file_ << ", line " << line_ << ".";
|
||||
return ss.str ().c_str ();
|
||||
}
|
||||
};
|
||||
|
||||
class PortNotOpenedException : public std::exception
|
||||
{
|
||||
// Disable copy constructors
|
||||
void operator=(const PortNotOpenedException&);
|
||||
const PortNotOpenedException& operator=(PortNotOpenedException);
|
||||
std::string e_what_;
|
||||
const char * e_what_;
|
||||
public:
|
||||
PortNotOpenedException (const char * description) {
|
||||
PortNotOpenedException (const char * description) : e_what_ (description) {}
|
||||
PortNotOpenedException (const PortNotOpenedException& other) {
|
||||
e_what_ = other.e_what_;
|
||||
}
|
||||
|
||||
virtual const char* what () const throw ()
|
||||
{
|
||||
std::stringstream ss;
|
||||
ss << "PortNotOpenedException " << description << " failed.";
|
||||
e_what_ = ss.str();
|
||||
}
|
||||
PortNotOpenedException (const PortNotOpenedException& other) : e_what_(other.e_what_) {}
|
||||
virtual ~PortNotOpenedException() throw() {}
|
||||
virtual const char* what () const throw () {
|
||||
return e_what_.c_str();
|
||||
ss << e_what_ << " called before port was opened.";
|
||||
return ss.str ().c_str ();
|
||||
}
|
||||
};
|
||||
|
||||
/*!
|
||||
* Structure that describes a serial device.
|
||||
*/
|
||||
struct PortInfo {
|
||||
|
||||
/*! Address of the serial port (this can be passed to the constructor of Serial). */
|
||||
std::string port;
|
||||
|
||||
/*! Human readable description of serial device if available. */
|
||||
std::string description;
|
||||
|
||||
/*! Hardware ID (e.g. VID:PID of USB serial devices) or "n/a" if not available. */
|
||||
std::string hardware_id;
|
||||
|
||||
};
|
||||
|
||||
/* Lists the serial ports available on the system
|
||||
*
|
||||
* Returns a vector of available serial ports, each represented
|
||||
* by a serial::PortInfo data structure:
|
||||
*
|
||||
* \return vector of serial::PortInfo.
|
||||
*/
|
||||
std::vector<PortInfo>
|
||||
list_ports();
|
||||
|
||||
} // namespace serial
|
||||
|
||||
#endif
|
||||
|
||||
26
mainpage.dox
Normal file
26
mainpage.dox
Normal file
@ -0,0 +1,26 @@
|
||||
/**
|
||||
\mainpage
|
||||
\htmlinclude manifest.html
|
||||
|
||||
\b serial is ...
|
||||
|
||||
<!--
|
||||
Provide an overview of your package.
|
||||
-->
|
||||
|
||||
|
||||
\section codeapi Code API
|
||||
|
||||
<!--
|
||||
Provide links to specific auto-generated API documentation within your
|
||||
package that is of particular interest to a reader. Doxygen will
|
||||
document pretty much every part of your code, so do your best here to
|
||||
point the reader to the actual API.
|
||||
|
||||
If your codebase is fairly large or has different sets of APIs, you
|
||||
should use the doxygen 'group' tag to keep these APIs together. For
|
||||
example, the roscpp documentation has 'libros' group.
|
||||
-->
|
||||
|
||||
|
||||
*/
|
||||
19
manifest.xml
Normal file
19
manifest.xml
Normal file
@ -0,0 +1,19 @@
|
||||
<package>
|
||||
<description brief="serial">
|
||||
|
||||
serial
|
||||
|
||||
</description>
|
||||
<author>William Woodall</author>
|
||||
<license>BSD</license>
|
||||
<review status="unreviewed" notes=""/>
|
||||
<url>http://ros.org/wiki/serial</url>
|
||||
|
||||
<export>
|
||||
<cpp cflags="-I${prefix}/include" lflags="-L${prefix}/lib -Wl,-rpath,${prefix}/lib -lserial -lrt -pthread"/>
|
||||
<cpp os="osx" cflags="-I${prefix}/include" lflags="-L${prefix}/lib -Wl,-rpath,${prefix}/lib -lserial"/>
|
||||
</export>
|
||||
|
||||
</package>
|
||||
|
||||
|
||||
24
package.xml
24
package.xml
@ -1,24 +0,0 @@
|
||||
<?xml version="1.0"?>
|
||||
<package>
|
||||
<name>serial</name>
|
||||
<version>1.2.1</version>
|
||||
<description>
|
||||
Serial is a cross-platform, simple to use library for using serial ports on computers.
|
||||
This library provides a C++, object oriented interface for interacting with RS-232
|
||||
like devices on Linux and Windows.
|
||||
</description>
|
||||
|
||||
<maintainer email="william@osrfoundation.org">William Woodall</maintainer>
|
||||
|
||||
<license>MIT</license>
|
||||
|
||||
<url type="website">http://wjwwood.github.com/serial/</url>
|
||||
<url type="repository">https://github.com/wjwwood/serial</url>
|
||||
<url type="bugtracker">https://github.com/wjwwood/serial/issues</url>
|
||||
|
||||
<author email="wjwwood@gmail.com">William Woodall</author>
|
||||
<author email="ash.gti@gmail.com">John Harrison</author>
|
||||
|
||||
<buildtool_depend>catkin</buildtool_depend>
|
||||
|
||||
</package>
|
||||
151
serial.cmake
Normal file
151
serial.cmake
Normal file
@ -0,0 +1,151 @@
|
||||
macro(build_serial)
|
||||
|
||||
## Project Setup
|
||||
cmake_minimum_required(VERSION 2.4.6)
|
||||
|
||||
if(COMMAND cmake_policy)
|
||||
cmake_policy(SET CMP0003 NEW)
|
||||
endif(COMMAND cmake_policy)
|
||||
|
||||
project(Serial)
|
||||
|
||||
## Configurations
|
||||
# Enable warnings
|
||||
# Assuming unix means a gcc style compiler, eg. g++ or clang++.
|
||||
IF(UNIX)
|
||||
set(CMAKE_CXX_FLAGS "-Wall -Weffc++ -pedantic -pedantic-errors -Wextra -Wall -Waggregate-return -Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment -Wconversion -Wdisabled-optimization -Wfloat-equal -Wformat -Wformat=2 -Wformat-nonliteral -Wformat-security -Wformat-y2k -Wimplicit -Wimport -Winit-self -Winline -Winvalid-pch -Wlong-long -Wmissing-braces -Wmissing-field-initializers -Wmissing-format-attribute -Wmissing-include-dirs -Wmissing-noreturn -Wpacked -Wparentheses -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point -Wshadow -Wsign-compare -Wstack-protector -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch -Wswitch-default -Wswitch-enum -Wtrigraphs -Wuninitialized -Wunknown-pragmas -Wunreachable-code -Wunused -Wunused-function -Wunused-label -Wunused-parameter -Wunused-value -Wunused-variable -Wvariadic-macros -Wvolatile-register-var -Wwrite-strings")
|
||||
ELSEIF(WIN32)
|
||||
# Force to always compile with W4
|
||||
if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
|
||||
string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
||||
else()
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
|
||||
endif()
|
||||
endif(UNIX)
|
||||
|
||||
# Use clang if available
|
||||
IF(EXISTS /usr/bin/clang)
|
||||
set(CMAKE_CXX_COMPILER /usr/bin/clang++)
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET "")
|
||||
set(SERIAL_BUILD_WARNINGS TRUE)
|
||||
set(CMAKE_BUILD_TYPE Debug)
|
||||
ENDIF(EXISTS /usr/bin/clang)
|
||||
|
||||
option(SERIAL_BUILD_TESTS "Build all of the Serial tests." OFF)
|
||||
option(SERIAL_BUILD_EXAMPLES "Build all of the Serial examples." OFF)
|
||||
|
||||
# Allow for building shared libs override
|
||||
IF(NOT BUILD_SHARED_LIBS)
|
||||
set(BUILD_SHARED_LIBS OFF)
|
||||
ENDIF(NOT BUILD_SHARED_LIBS)
|
||||
|
||||
# Threading libraries added for mutexs
|
||||
FIND_PACKAGE (Threads)
|
||||
|
||||
# Set the default path for built executables to the "bin" directory
|
||||
IF(NOT DEFINED(EXECUTABLE_OUTPUT_PATH))
|
||||
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
|
||||
ENDIF(NOT DEFINED(EXECUTABLE_OUTPUT_PATH))
|
||||
# set the default path for built libraries to the "lib" directory
|
||||
IF(NOT DEFINED(LIBRARY_OUTPUT_PATH))
|
||||
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
|
||||
ENDIF(NOT DEFINED(LIBRARY_OUTPUT_PATH))
|
||||
|
||||
## Configure the build system
|
||||
|
||||
# Add the include folder to the include path
|
||||
include_directories(${PROJECT_SOURCE_DIR}/include)
|
||||
|
||||
# Add default source files
|
||||
set(SERIAL_SRCS src/serial.cc)
|
||||
IF(WIN32)
|
||||
list(APPEND SERIAL_SRCS src/impl/win.cc)
|
||||
ELSE(WIN32)
|
||||
list(APPEND SERIAL_SRCS src/impl/unix.cc)
|
||||
ENDIF(WIN32)
|
||||
# Add default header files
|
||||
set(SERIAL_HEADERS include/serial/serial.h)
|
||||
|
||||
|
||||
set(OTHER_LIBS "")
|
||||
if(UNIX)
|
||||
set(OTHER_LIBS util)
|
||||
endif(UNIX)
|
||||
|
||||
## Build the Serial Library
|
||||
|
||||
# Compile the Library
|
||||
add_library(serial ${SERIAL_SRCS})
|
||||
target_link_libraries(serial ${CMAKE_THREAD_LIBS_INIT} ${OTHER_LIBS})
|
||||
|
||||
## Build Examples
|
||||
|
||||
# If asked to
|
||||
IF(SERIAL_BUILD_EXAMPLES)
|
||||
# Compile the Serial Test program
|
||||
add_executable(serial_example examples/serial_example.cc)
|
||||
# Link the Test program to the Serial library
|
||||
target_link_libraries(serial_example serial)
|
||||
ENDIF(SERIAL_BUILD_EXAMPLES)
|
||||
|
||||
## Build tests
|
||||
|
||||
# If asked to
|
||||
IF(SERIAL_BUILD_TESTS)
|
||||
# Find Google Test
|
||||
enable_testing()
|
||||
find_package(GTest REQUIRED)
|
||||
include_directories(${GTEST_INCLUDE_DIRS})
|
||||
|
||||
# Compile the Serial Test program
|
||||
add_executable(serial_tests tests/serial_tests.cc)
|
||||
# Link the Test program to the serial library
|
||||
target_link_libraries(serial_tests ${GTEST_BOTH_LIBRARIES}
|
||||
serial)
|
||||
|
||||
add_test(AllTestsIntest_serial serial_tests)
|
||||
ENDIF(SERIAL_BUILD_TESTS)
|
||||
|
||||
## Setup install and uninstall
|
||||
|
||||
# Unless asked not to...
|
||||
IF(NOT SERIAL_DONT_CONFIGURE_INSTALL)
|
||||
# Configure make install
|
||||
IF(NOT CMAKE_INSTALL_PREFIX)
|
||||
SET(CMAKE_INSTALL_PREFIX /usr/local)
|
||||
ENDIF(NOT CMAKE_INSTALL_PREFIX)
|
||||
|
||||
INSTALL(TARGETS serial
|
||||
RUNTIME DESTINATION bin
|
||||
LIBRARY DESTINATION lib
|
||||
ARCHIVE DESTINATION lib
|
||||
)
|
||||
|
||||
INSTALL(FILES include/serial/serial.h
|
||||
include/serial/v8stdint.h
|
||||
DESTINATION include/serial)
|
||||
|
||||
IF(NOT CMAKE_FIND_INSTALL_PATH)
|
||||
set(CMAKE_FIND_INSTALL_PATH ${CMAKE_ROOT})
|
||||
ENDIF(NOT CMAKE_FIND_INSTALL_PATH)
|
||||
|
||||
INSTALL(FILES Findserial.cmake
|
||||
DESTINATION ${CMAKE_FIND_INSTALL_PATH}/Modules/)
|
||||
|
||||
ADD_CUSTOM_TARGET(uninstall @echo uninstall package)
|
||||
|
||||
IF (UNIX)
|
||||
ADD_CUSTOM_COMMAND(
|
||||
COMMENT "uninstall package"
|
||||
COMMAND xargs ARGS rm < install_manifest.txt
|
||||
|
||||
TARGET uninstall
|
||||
)
|
||||
ELSE(UNIX)
|
||||
ADD_CUSTOM_COMMAND(
|
||||
COMMENT "uninstall only implemented in unix"
|
||||
TARGET uninstall
|
||||
)
|
||||
ENDIF(UNIX)
|
||||
ENDIF(NOT SERIAL_DONT_CONFIGURE_INSTALL)
|
||||
endmacro(build_serial)
|
||||
40
serial.makefile
Normal file
40
serial.makefile
Normal file
@ -0,0 +1,40 @@
|
||||
all: serial
|
||||
|
||||
install:
|
||||
cd build && make install
|
||||
|
||||
uninstall:
|
||||
cd build && make uninstall
|
||||
|
||||
serial:
|
||||
@mkdir -p build
|
||||
-mkdir -p bin
|
||||
cd build && cmake $(CMAKE_FLAGS) ..
|
||||
ifneq ($(MAKE),)
|
||||
cd build && $(MAKE)
|
||||
else
|
||||
cd build && make
|
||||
endif
|
||||
|
||||
clean:
|
||||
-cd build && make clean
|
||||
rm -rf build bin lib
|
||||
|
||||
.PHONY: doc
|
||||
doc:
|
||||
@doxygen doc/Doxyfile
|
||||
ifeq ($(UNAME),Darwin)
|
||||
@open doc/html/index.html
|
||||
endif
|
||||
|
||||
.PHONY: test
|
||||
test:
|
||||
@mkdir -p build
|
||||
@mkdir -p bin
|
||||
cd build && cmake $(CMAKE_FLAGS) -DSERIAL_BUILD_TESTS=1 -DSERIAL_BUILD_EXAMPLES=1 ..
|
||||
ifneq ($(MAKE),)
|
||||
cd build && $(MAKE)
|
||||
else
|
||||
cd build && make
|
||||
endif
|
||||
cd bin && ./serial_tests
|
||||
1
serial.rosinstall
Normal file
1
serial.rosinstall
Normal file
@ -0,0 +1 @@
|
||||
- git: {local-name: serial, uri: 'https://github.com/wjwwood/serial.git', version: 'v1.0'}
|
||||
@ -11,12 +11,9 @@
|
||||
{
|
||||
"sublimeclang_options":
|
||||
[
|
||||
"-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
|
||||
"-I/usr/local/include",
|
||||
"-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/9.0.0/include",
|
||||
"-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
|
||||
"-I/usr/include",
|
||||
"-I${folder:${project_path:serial.sublime-project}}/include",
|
||||
"-I/usr/local/include",
|
||||
"-I${folder:${project_path:serial.sublime-project}}/include"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
48
serial_ros.cmake
Normal file
48
serial_ros.cmake
Normal file
@ -0,0 +1,48 @@
|
||||
macro(build_serial)
|
||||
|
||||
cmake_minimum_required(VERSION 2.4.6)
|
||||
include($ENV{ROS_ROOT}/core/rosbuild/rosbuild.cmake)
|
||||
|
||||
# Set the build type. Options are:
|
||||
# Coverage : w/ debug symbols, w/o optimization, w/ code-coverage
|
||||
# Debug : w/ debug symbols, w/o optimization
|
||||
# Release : w/o debug symbols, w/ optimization
|
||||
# RelWithDebInfo : w/ debug symbols, w/ optimization
|
||||
# MinSizeRel : w/o debug symbols, w/ optimization, stripped binaries
|
||||
set(ROS_BUILD_TYPE Debug)
|
||||
|
||||
rosbuild_init()
|
||||
|
||||
#set the default path for built executables to the "bin" directory
|
||||
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
|
||||
#set the default path for built libraries to the "lib" directory
|
||||
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
|
||||
|
||||
include_directories(include)
|
||||
include_directories(vendor)
|
||||
|
||||
set(SERIAL_SRCS src/serial.cc)
|
||||
if(UNIX)
|
||||
list(APPEND SERIAL_SRCS src/impl/unix.cc)
|
||||
else(UNIX)
|
||||
list(APPEND SERIAL_SRCS src/impl/winows.cc)
|
||||
endif(UNIX)
|
||||
|
||||
# Build the serial library
|
||||
rosbuild_add_library(${PROJECT_NAME} ${SERIAL_SRCS})
|
||||
|
||||
# Collect Link Libraries
|
||||
set(SERIAL_LINK_LIBS ${PROJECT_NAME})
|
||||
if(UNIX AND NOT APPLE)
|
||||
list(APPEND SERIAL_LINK_LIBS rt pthread)
|
||||
endif(UNIX AND NOT APPLE)
|
||||
|
||||
# Build example
|
||||
rosbuild_add_executable(serial_example examples/serial_example.cc)
|
||||
target_link_libraries(serial_example ${SERIAL_LINK_LIBS})
|
||||
|
||||
# Create unit tests
|
||||
rosbuild_add_gtest(serial_tests tests/serial_tests.cc)
|
||||
target_link_libraries(serial_tests ${PROJECT_NAME})
|
||||
|
||||
endmacro(build_serial)
|
||||
@ -1,336 +0,0 @@
|
||||
#if defined(__linux__)
|
||||
|
||||
/*
|
||||
* Copyright (c) 2014 Craig Lilley <cralilley@gmail.com>
|
||||
* This software is made available under the terms of the MIT licence.
|
||||
* A copy of the licence can be obtained from:
|
||||
* http://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <cstdio>
|
||||
#include <cstdarg>
|
||||
#include <cstdlib>
|
||||
|
||||
#include <glob.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "serial/serial.h"
|
||||
|
||||
using serial::PortInfo;
|
||||
using std::istringstream;
|
||||
using std::ifstream;
|
||||
using std::getline;
|
||||
using std::vector;
|
||||
using std::string;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
static vector<string> glob(const vector<string>& patterns);
|
||||
static string basename(const string& path);
|
||||
static string dirname(const string& path);
|
||||
static bool path_exists(const string& path);
|
||||
static string realpath(const string& path);
|
||||
static string usb_sysfs_friendly_name(const string& sys_usb_path);
|
||||
static vector<string> get_sysfs_info(const string& device_path);
|
||||
static string read_line(const string& file);
|
||||
static string usb_sysfs_hw_string(const string& sysfs_path);
|
||||
static string format(const char* format, ...);
|
||||
|
||||
vector<string>
|
||||
glob(const vector<string>& patterns)
|
||||
{
|
||||
vector<string> paths_found;
|
||||
|
||||
if(patterns.size() == 0)
|
||||
return paths_found;
|
||||
|
||||
glob_t glob_results;
|
||||
|
||||
int glob_retval = glob(patterns[0].c_str(), 0, NULL, &glob_results);
|
||||
|
||||
vector<string>::const_iterator iter = patterns.begin();
|
||||
|
||||
while(++iter != patterns.end())
|
||||
{
|
||||
glob_retval = glob(iter->c_str(), GLOB_APPEND, NULL, &glob_results);
|
||||
}
|
||||
|
||||
for(int path_index = 0; path_index < glob_results.gl_pathc; path_index++)
|
||||
{
|
||||
paths_found.push_back(glob_results.gl_pathv[path_index]);
|
||||
}
|
||||
|
||||
globfree(&glob_results);
|
||||
|
||||
return paths_found;
|
||||
}
|
||||
|
||||
string
|
||||
basename(const string& path)
|
||||
{
|
||||
size_t pos = path.rfind("/");
|
||||
|
||||
if(pos == std::string::npos)
|
||||
return path;
|
||||
|
||||
return string(path, pos+1, string::npos);
|
||||
}
|
||||
|
||||
string
|
||||
dirname(const string& path)
|
||||
{
|
||||
size_t pos = path.rfind("/");
|
||||
|
||||
if(pos == std::string::npos)
|
||||
return path;
|
||||
else if(pos == 0)
|
||||
return "/";
|
||||
|
||||
return string(path, 0, pos);
|
||||
}
|
||||
|
||||
bool
|
||||
path_exists(const string& path)
|
||||
{
|
||||
struct stat sb;
|
||||
|
||||
if( stat(path.c_str(), &sb ) == 0 )
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
string
|
||||
realpath(const string& path)
|
||||
{
|
||||
char* real_path = realpath(path.c_str(), NULL);
|
||||
|
||||
string result;
|
||||
|
||||
if(real_path != NULL)
|
||||
{
|
||||
result = real_path;
|
||||
|
||||
free(real_path);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string
|
||||
usb_sysfs_friendly_name(const string& sys_usb_path)
|
||||
{
|
||||
unsigned int device_number = 0;
|
||||
|
||||
istringstream( read_line(sys_usb_path + "/devnum") ) >> device_number;
|
||||
|
||||
string manufacturer = read_line( sys_usb_path + "/manufacturer" );
|
||||
|
||||
string product = read_line( sys_usb_path + "/product" );
|
||||
|
||||
string serial = read_line( sys_usb_path + "/serial" );
|
||||
|
||||
if( manufacturer.empty() && product.empty() && serial.empty() )
|
||||
return "";
|
||||
|
||||
return format("%s %s %s", manufacturer.c_str(), product.c_str(), serial.c_str() );
|
||||
}
|
||||
|
||||
vector<string>
|
||||
get_sysfs_info(const string& device_path)
|
||||
{
|
||||
string device_name = basename( device_path );
|
||||
|
||||
string friendly_name;
|
||||
|
||||
string hardware_id;
|
||||
|
||||
string sys_device_path = format( "/sys/class/tty/%s/device", device_name.c_str() );
|
||||
|
||||
if( device_name.compare(0,6,"ttyUSB") == 0 )
|
||||
{
|
||||
sys_device_path = dirname( dirname( realpath( sys_device_path ) ) );
|
||||
|
||||
if( path_exists( sys_device_path ) )
|
||||
{
|
||||
friendly_name = usb_sysfs_friendly_name( sys_device_path );
|
||||
|
||||
hardware_id = usb_sysfs_hw_string( sys_device_path );
|
||||
}
|
||||
}
|
||||
else if( device_name.compare(0,6,"ttyACM") == 0 )
|
||||
{
|
||||
sys_device_path = dirname( realpath( sys_device_path ) );
|
||||
|
||||
if( path_exists( sys_device_path ) )
|
||||
{
|
||||
friendly_name = usb_sysfs_friendly_name( sys_device_path );
|
||||
|
||||
hardware_id = usb_sysfs_hw_string( sys_device_path );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Try to read ID string of PCI device
|
||||
|
||||
string sys_id_path = sys_device_path + "/id";
|
||||
|
||||
if( path_exists( sys_id_path ) )
|
||||
hardware_id = read_line( sys_id_path );
|
||||
}
|
||||
|
||||
if( friendly_name.empty() )
|
||||
friendly_name = device_name;
|
||||
|
||||
if( hardware_id.empty() )
|
||||
hardware_id = "n/a";
|
||||
|
||||
vector<string> result;
|
||||
result.push_back(friendly_name);
|
||||
result.push_back(hardware_id);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string
|
||||
read_line(const string& file)
|
||||
{
|
||||
ifstream ifs(file.c_str(), ifstream::in);
|
||||
|
||||
string line;
|
||||
|
||||
if(ifs)
|
||||
{
|
||||
getline(ifs, line);
|
||||
}
|
||||
|
||||
return line;
|
||||
}
|
||||
|
||||
string
|
||||
format(const char* format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
size_t buffer_size_bytes = 256;
|
||||
|
||||
string result;
|
||||
|
||||
char* buffer = (char*)malloc(buffer_size_bytes);
|
||||
|
||||
if( buffer == NULL )
|
||||
return result;
|
||||
|
||||
bool done = false;
|
||||
|
||||
unsigned int loop_count = 0;
|
||||
|
||||
while(!done)
|
||||
{
|
||||
va_start(ap, format);
|
||||
|
||||
int return_value = vsnprintf(buffer, buffer_size_bytes, format, ap);
|
||||
|
||||
if( return_value < 0 )
|
||||
{
|
||||
done = true;
|
||||
}
|
||||
else if( return_value >= buffer_size_bytes )
|
||||
{
|
||||
// Realloc and try again.
|
||||
|
||||
buffer_size_bytes = return_value + 1;
|
||||
|
||||
char* new_buffer_ptr = (char*)realloc(buffer, buffer_size_bytes);
|
||||
|
||||
if( new_buffer_ptr == NULL )
|
||||
{
|
||||
done = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
buffer = new_buffer_ptr;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = buffer;
|
||||
done = true;
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
|
||||
if( ++loop_count > 5 )
|
||||
done = true;
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string
|
||||
usb_sysfs_hw_string(const string& sysfs_path)
|
||||
{
|
||||
string serial_number = read_line( sysfs_path + "/serial" );
|
||||
|
||||
if( serial_number.length() > 0 )
|
||||
{
|
||||
serial_number = format( "SNR=%s", serial_number.c_str() );
|
||||
}
|
||||
|
||||
string vid = read_line( sysfs_path + "/idVendor" );
|
||||
|
||||
string pid = read_line( sysfs_path + "/idProduct" );
|
||||
|
||||
return format("USB VID:PID=%s:%s %s", vid.c_str(), pid.c_str(), serial_number.c_str() );
|
||||
}
|
||||
|
||||
vector<PortInfo>
|
||||
serial::list_ports()
|
||||
{
|
||||
vector<PortInfo> results;
|
||||
|
||||
vector<string> search_globs;
|
||||
search_globs.push_back("/dev/ttyACM*");
|
||||
search_globs.push_back("/dev/ttyS*");
|
||||
search_globs.push_back("/dev/ttyUSB*");
|
||||
search_globs.push_back("/dev/tty.*");
|
||||
search_globs.push_back("/dev/cu.*");
|
||||
search_globs.push_back("/dev/rfcomm*");
|
||||
|
||||
vector<string> devices_found = glob( search_globs );
|
||||
|
||||
vector<string>::iterator iter = devices_found.begin();
|
||||
|
||||
while( iter != devices_found.end() )
|
||||
{
|
||||
string device = *iter++;
|
||||
|
||||
vector<string> sysfs_info = get_sysfs_info( device );
|
||||
|
||||
string friendly_name = sysfs_info[0];
|
||||
|
||||
string hardware_id = sysfs_info[1];
|
||||
|
||||
PortInfo device_entry;
|
||||
device_entry.port = device;
|
||||
device_entry.description = friendly_name;
|
||||
device_entry.hardware_id = hardware_id;
|
||||
|
||||
results.push_back( device_entry );
|
||||
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
#endif // defined(__linux__)
|
||||
@ -1,286 +0,0 @@
|
||||
#if defined(__APPLE__)
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
#include <IOKit/IOKitLib.h>
|
||||
#include <IOKit/serial/IOSerialKeys.h>
|
||||
#include <IOKit/IOBSD.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "serial/serial.h"
|
||||
|
||||
using serial::PortInfo;
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
#define HARDWARE_ID_STRING_LENGTH 128
|
||||
|
||||
string cfstring_to_string( CFStringRef cfstring );
|
||||
string get_device_path( io_object_t& serial_port );
|
||||
string get_class_name( io_object_t& obj );
|
||||
io_registry_entry_t get_parent_iousb_device( io_object_t& serial_port );
|
||||
string get_string_property( io_object_t& device, const char* property );
|
||||
uint16_t get_int_property( io_object_t& device, const char* property );
|
||||
string rtrim(const string& str);
|
||||
|
||||
string
|
||||
cfstring_to_string( CFStringRef cfstring )
|
||||
{
|
||||
char cstring[MAXPATHLEN];
|
||||
string result;
|
||||
|
||||
if( cfstring )
|
||||
{
|
||||
Boolean success = CFStringGetCString( cfstring,
|
||||
cstring,
|
||||
sizeof(cstring),
|
||||
kCFStringEncodingASCII );
|
||||
|
||||
if( success )
|
||||
result = cstring;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string
|
||||
get_device_path( io_object_t& serial_port )
|
||||
{
|
||||
CFTypeRef callout_path;
|
||||
string device_path;
|
||||
|
||||
callout_path = IORegistryEntryCreateCFProperty( serial_port,
|
||||
CFSTR(kIOCalloutDeviceKey),
|
||||
kCFAllocatorDefault,
|
||||
0 );
|
||||
|
||||
if (callout_path)
|
||||
{
|
||||
if( CFGetTypeID(callout_path) == CFStringGetTypeID() )
|
||||
device_path = cfstring_to_string( static_cast<CFStringRef>(callout_path) );
|
||||
|
||||
CFRelease(callout_path);
|
||||
}
|
||||
|
||||
return device_path;
|
||||
}
|
||||
|
||||
string
|
||||
get_class_name( io_object_t& obj )
|
||||
{
|
||||
string result;
|
||||
io_name_t class_name;
|
||||
kern_return_t kern_result;
|
||||
|
||||
kern_result = IOObjectGetClass( obj, class_name );
|
||||
|
||||
if( kern_result == KERN_SUCCESS )
|
||||
result = class_name;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
io_registry_entry_t
|
||||
get_parent_iousb_device( io_object_t& serial_port )
|
||||
{
|
||||
io_object_t device = serial_port;
|
||||
io_registry_entry_t parent = 0;
|
||||
io_registry_entry_t result = 0;
|
||||
kern_return_t kern_result = KERN_FAILURE;
|
||||
string name = get_class_name(device);
|
||||
|
||||
// Walk the IO Registry tree looking for this devices parent IOUSBDevice.
|
||||
while( name != "IOUSBDevice" )
|
||||
{
|
||||
kern_result = IORegistryEntryGetParentEntry( device,
|
||||
kIOServicePlane,
|
||||
&parent );
|
||||
|
||||
if(kern_result != KERN_SUCCESS)
|
||||
{
|
||||
result = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
device = parent;
|
||||
|
||||
name = get_class_name(device);
|
||||
}
|
||||
|
||||
if(kern_result == KERN_SUCCESS)
|
||||
result = device;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string
|
||||
get_string_property( io_object_t& device, const char* property )
|
||||
{
|
||||
string property_name;
|
||||
|
||||
if( device )
|
||||
{
|
||||
CFStringRef property_as_cfstring = CFStringCreateWithCString (
|
||||
kCFAllocatorDefault,
|
||||
property,
|
||||
kCFStringEncodingASCII );
|
||||
|
||||
CFTypeRef name_as_cfstring = IORegistryEntryCreateCFProperty(
|
||||
device,
|
||||
property_as_cfstring,
|
||||
kCFAllocatorDefault,
|
||||
0 );
|
||||
|
||||
if( name_as_cfstring )
|
||||
{
|
||||
if( CFGetTypeID(name_as_cfstring) == CFStringGetTypeID() )
|
||||
property_name = cfstring_to_string( static_cast<CFStringRef>(name_as_cfstring) );
|
||||
|
||||
CFRelease(name_as_cfstring);
|
||||
}
|
||||
|
||||
if(property_as_cfstring)
|
||||
CFRelease(property_as_cfstring);
|
||||
}
|
||||
|
||||
return property_name;
|
||||
}
|
||||
|
||||
uint16_t
|
||||
get_int_property( io_object_t& device, const char* property )
|
||||
{
|
||||
uint16_t result = 0;
|
||||
|
||||
if( device )
|
||||
{
|
||||
CFStringRef property_as_cfstring = CFStringCreateWithCString (
|
||||
kCFAllocatorDefault,
|
||||
property,
|
||||
kCFStringEncodingASCII );
|
||||
|
||||
CFTypeRef number = IORegistryEntryCreateCFProperty( device,
|
||||
property_as_cfstring,
|
||||
kCFAllocatorDefault,
|
||||
0 );
|
||||
|
||||
if(property_as_cfstring)
|
||||
CFRelease(property_as_cfstring);
|
||||
|
||||
if( number )
|
||||
{
|
||||
if( CFGetTypeID(number) == CFNumberGetTypeID() )
|
||||
{
|
||||
bool success = CFNumberGetValue( static_cast<CFNumberRef>(number),
|
||||
kCFNumberSInt16Type,
|
||||
&result );
|
||||
|
||||
if( !success )
|
||||
result = 0;
|
||||
}
|
||||
|
||||
CFRelease(number);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string rtrim(const string& str)
|
||||
{
|
||||
string result = str;
|
||||
|
||||
string whitespace = " \t\f\v\n\r";
|
||||
|
||||
std::size_t found = result.find_last_not_of(whitespace);
|
||||
|
||||
if (found != std::string::npos)
|
||||
result.erase(found+1);
|
||||
else
|
||||
result.clear();
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
vector<PortInfo>
|
||||
serial::list_ports(void)
|
||||
{
|
||||
vector<PortInfo> devices_found;
|
||||
CFMutableDictionaryRef classes_to_match;
|
||||
io_iterator_t serial_port_iterator;
|
||||
io_object_t serial_port;
|
||||
mach_port_t master_port;
|
||||
kern_return_t kern_result;
|
||||
|
||||
kern_result = IOMasterPort(MACH_PORT_NULL, &master_port);
|
||||
|
||||
if(kern_result != KERN_SUCCESS)
|
||||
return devices_found;
|
||||
|
||||
classes_to_match = IOServiceMatching(kIOSerialBSDServiceValue);
|
||||
|
||||
if (classes_to_match == NULL)
|
||||
return devices_found;
|
||||
|
||||
CFDictionarySetValue( classes_to_match,
|
||||
CFSTR(kIOSerialBSDTypeKey),
|
||||
CFSTR(kIOSerialBSDAllTypes) );
|
||||
|
||||
kern_result = IOServiceGetMatchingServices(master_port, classes_to_match, &serial_port_iterator);
|
||||
|
||||
if (KERN_SUCCESS != kern_result)
|
||||
return devices_found;
|
||||
|
||||
while ( (serial_port = IOIteratorNext(serial_port_iterator)) )
|
||||
{
|
||||
string device_path = get_device_path( serial_port );
|
||||
io_registry_entry_t parent = get_parent_iousb_device( serial_port );
|
||||
IOObjectRelease(serial_port);
|
||||
|
||||
if( device_path.empty() )
|
||||
continue;
|
||||
|
||||
PortInfo port_info;
|
||||
port_info.port = device_path;
|
||||
port_info.description = "n/a";
|
||||
port_info.hardware_id = "n/a";
|
||||
|
||||
string device_name = rtrim( get_string_property( parent, "USB Product Name" ) );
|
||||
string vendor_name = rtrim( get_string_property( parent, "USB Vendor Name") );
|
||||
string description = rtrim( vendor_name + " " + device_name );
|
||||
if( !description.empty() )
|
||||
port_info.description = description;
|
||||
|
||||
string serial_number = rtrim(get_string_property( parent, "USB Serial Number" ) );
|
||||
uint16_t vendor_id = get_int_property( parent, "idVendor" );
|
||||
uint16_t product_id = get_int_property( parent, "idProduct" );
|
||||
|
||||
if( vendor_id && product_id )
|
||||
{
|
||||
char cstring[HARDWARE_ID_STRING_LENGTH];
|
||||
|
||||
if(serial_number.empty())
|
||||
serial_number = "None";
|
||||
|
||||
int ret = snprintf( cstring, HARDWARE_ID_STRING_LENGTH, "USB VID:PID=%04x:%04x SNR=%s",
|
||||
vendor_id,
|
||||
product_id,
|
||||
serial_number.c_str() );
|
||||
|
||||
if( (ret >= 0) && (ret < HARDWARE_ID_STRING_LENGTH) )
|
||||
port_info.hardware_id = cstring;
|
||||
}
|
||||
|
||||
devices_found.push_back(port_info);
|
||||
}
|
||||
|
||||
IOObjectRelease(serial_port_iterator);
|
||||
return devices_found;
|
||||
}
|
||||
|
||||
#endif // defined(__APPLE__)
|
||||
@ -1,152 +0,0 @@
|
||||
#if defined(_WIN32)
|
||||
|
||||
/*
|
||||
* Copyright (c) 2014 Craig Lilley <cralilley@gmail.com>
|
||||
* This software is made available under the terms of the MIT licence.
|
||||
* A copy of the licence can be obtained from:
|
||||
* http://opensource.org/licenses/MIT
|
||||
*/
|
||||
|
||||
#include "serial/serial.h"
|
||||
#include <tchar.h>
|
||||
#include <windows.h>
|
||||
#include <setupapi.h>
|
||||
#include <initguid.h>
|
||||
#include <devguid.h>
|
||||
#include <cstring>
|
||||
|
||||
using serial::PortInfo;
|
||||
using std::vector;
|
||||
using std::string;
|
||||
|
||||
static const DWORD port_name_max_length = 256;
|
||||
static const DWORD friendly_name_max_length = 256;
|
||||
static const DWORD hardware_id_max_length = 256;
|
||||
|
||||
// Convert a wide Unicode string to an UTF8 string
|
||||
std::string utf8_encode(const std::wstring &wstr)
|
||||
{
|
||||
int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
|
||||
std::string strTo( size_needed, 0 );
|
||||
WideCharToMultiByte (CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
|
||||
return strTo;
|
||||
}
|
||||
|
||||
vector<PortInfo>
|
||||
serial::list_ports()
|
||||
{
|
||||
vector<PortInfo> devices_found;
|
||||
|
||||
HDEVINFO device_info_set = SetupDiGetClassDevs(
|
||||
(const GUID *) &GUID_DEVCLASS_PORTS,
|
||||
NULL,
|
||||
NULL,
|
||||
DIGCF_PRESENT);
|
||||
|
||||
unsigned int device_info_set_index = 0;
|
||||
SP_DEVINFO_DATA device_info_data;
|
||||
|
||||
device_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
|
||||
|
||||
while(SetupDiEnumDeviceInfo(device_info_set, device_info_set_index, &device_info_data))
|
||||
{
|
||||
device_info_set_index++;
|
||||
|
||||
// Get port name
|
||||
|
||||
HKEY hkey = SetupDiOpenDevRegKey(
|
||||
device_info_set,
|
||||
&device_info_data,
|
||||
DICS_FLAG_GLOBAL,
|
||||
0,
|
||||
DIREG_DEV,
|
||||
KEY_READ);
|
||||
|
||||
TCHAR port_name[port_name_max_length];
|
||||
DWORD port_name_length = port_name_max_length;
|
||||
|
||||
LONG return_code = RegQueryValueEx(
|
||||
hkey,
|
||||
_T("PortName"),
|
||||
NULL,
|
||||
NULL,
|
||||
(LPBYTE)port_name,
|
||||
&port_name_length);
|
||||
|
||||
RegCloseKey(hkey);
|
||||
|
||||
if(return_code != EXIT_SUCCESS)
|
||||
continue;
|
||||
|
||||
if(port_name_length > 0 && port_name_length <= port_name_max_length)
|
||||
port_name[port_name_length-1] = '\0';
|
||||
else
|
||||
port_name[0] = '\0';
|
||||
|
||||
// Ignore parallel ports
|
||||
|
||||
if(_tcsstr(port_name, _T("LPT")) != NULL)
|
||||
continue;
|
||||
|
||||
// Get port friendly name
|
||||
|
||||
TCHAR friendly_name[friendly_name_max_length];
|
||||
DWORD friendly_name_actual_length = 0;
|
||||
|
||||
BOOL got_friendly_name = SetupDiGetDeviceRegistryProperty(
|
||||
device_info_set,
|
||||
&device_info_data,
|
||||
SPDRP_FRIENDLYNAME,
|
||||
NULL,
|
||||
(PBYTE)friendly_name,
|
||||
friendly_name_max_length,
|
||||
&friendly_name_actual_length);
|
||||
|
||||
if(got_friendly_name == TRUE && friendly_name_actual_length > 0)
|
||||
friendly_name[friendly_name_actual_length-1] = '\0';
|
||||
else
|
||||
friendly_name[0] = '\0';
|
||||
|
||||
// Get hardware ID
|
||||
|
||||
TCHAR hardware_id[hardware_id_max_length];
|
||||
DWORD hardware_id_actual_length = 0;
|
||||
|
||||
BOOL got_hardware_id = SetupDiGetDeviceRegistryProperty(
|
||||
device_info_set,
|
||||
&device_info_data,
|
||||
SPDRP_HARDWAREID,
|
||||
NULL,
|
||||
(PBYTE)hardware_id,
|
||||
hardware_id_max_length,
|
||||
&hardware_id_actual_length);
|
||||
|
||||
if(got_hardware_id == TRUE && hardware_id_actual_length > 0)
|
||||
hardware_id[hardware_id_actual_length-1] = '\0';
|
||||
else
|
||||
hardware_id[0] = '\0';
|
||||
|
||||
#ifdef UNICODE
|
||||
std::string portName = utf8_encode(port_name);
|
||||
std::string friendlyName = utf8_encode(friendly_name);
|
||||
std::string hardwareId = utf8_encode(hardware_id);
|
||||
#else
|
||||
std::string portName = port_name;
|
||||
std::string friendlyName = friendly_name;
|
||||
std::string hardwareId = hardware_id;
|
||||
#endif
|
||||
|
||||
PortInfo port_entry;
|
||||
port_entry.port = portName;
|
||||
port_entry.description = friendlyName;
|
||||
port_entry.hardware_id = hardwareId;
|
||||
|
||||
devices_found.push_back(port_entry);
|
||||
}
|
||||
|
||||
SetupDiDestroyDeviceInfoList(device_info_set);
|
||||
|
||||
return devices_found;
|
||||
}
|
||||
|
||||
#endif // #if defined(_WIN32)
|
||||
563
src/impl/unix.cc
563
src/impl/unix.cc
@ -1,9 +1,4 @@
|
||||
/* Copyright 2012 William Woodall and John Harrison
|
||||
*
|
||||
* Additional Contributors: Christopher Baker @bakercp
|
||||
*/
|
||||
|
||||
#if !defined(_WIN32)
|
||||
/* Copyright 2012 William Woodall and John Harrison */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
@ -27,7 +22,6 @@
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#ifdef __MACH__
|
||||
#include <AvailabilityMacros.h>
|
||||
#include <mach/clock.h>
|
||||
#include <mach/mach.h>
|
||||
#endif
|
||||
@ -42,69 +36,15 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(MAC_OS_X_VERSION_10_3) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3)
|
||||
#include <IOKit/serial/ioss.h>
|
||||
#endif
|
||||
|
||||
using std::string;
|
||||
using std::stringstream;
|
||||
using std::invalid_argument;
|
||||
using serial::MillisecondTimer;
|
||||
using serial::Serial;
|
||||
using serial::SerialException;
|
||||
using serial::SerialExecption;
|
||||
using serial::PortNotOpenedException;
|
||||
using serial::IOException;
|
||||
|
||||
|
||||
MillisecondTimer::MillisecondTimer (const uint32_t millis)
|
||||
: expiry(timespec_now())
|
||||
{
|
||||
int64_t tv_nsec = expiry.tv_nsec + (millis * 1e6);
|
||||
if (tv_nsec >= 1e9) {
|
||||
int64_t sec_diff = tv_nsec / static_cast<int> (1e9);
|
||||
expiry.tv_nsec = tv_nsec % static_cast<int>(1e9);
|
||||
expiry.tv_sec += sec_diff;
|
||||
} else {
|
||||
expiry.tv_nsec = tv_nsec;
|
||||
}
|
||||
}
|
||||
|
||||
int64_t
|
||||
MillisecondTimer::remaining ()
|
||||
{
|
||||
timespec now(timespec_now());
|
||||
int64_t millis = (expiry.tv_sec - now.tv_sec) * 1e3;
|
||||
millis += (expiry.tv_nsec - now.tv_nsec) / 1e6;
|
||||
return millis;
|
||||
}
|
||||
|
||||
timespec
|
||||
MillisecondTimer::timespec_now ()
|
||||
{
|
||||
timespec time;
|
||||
# ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
|
||||
clock_serv_t cclock;
|
||||
mach_timespec_t mts;
|
||||
host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
|
||||
clock_get_time(cclock, &mts);
|
||||
mach_port_deallocate(mach_task_self(), cclock);
|
||||
time.tv_sec = mts.tv_sec;
|
||||
time.tv_nsec = mts.tv_nsec;
|
||||
# else
|
||||
clock_gettime(CLOCK_MONOTONIC, &time);
|
||||
# endif
|
||||
return time;
|
||||
}
|
||||
|
||||
timespec
|
||||
timespec_from_ms (const uint32_t millis)
|
||||
{
|
||||
timespec time;
|
||||
time.tv_sec = millis / 1e3;
|
||||
time.tv_nsec = (millis - (time.tv_sec * 1e3)) * 1e6;
|
||||
return time;
|
||||
}
|
||||
|
||||
Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
|
||||
bytesize_t bytesize,
|
||||
parity_t parity, stopbits_t stopbits,
|
||||
@ -133,7 +73,7 @@ Serial::SerialImpl::open ()
|
||||
throw invalid_argument ("Empty port is invalid.");
|
||||
}
|
||||
if (is_open_ == true) {
|
||||
throw SerialException ("Serial port already open.");
|
||||
throw SerialExecption ("Serial port already open.");
|
||||
}
|
||||
|
||||
fd_ = ::open (port_.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
|
||||
@ -269,41 +209,34 @@ Serial::SerialImpl::reconfigurePort ()
|
||||
#ifdef B460800
|
||||
case 460800: baud = B460800; break;
|
||||
#endif
|
||||
#ifdef B500000
|
||||
case 500000: baud = B500000; break;
|
||||
#endif
|
||||
#ifdef B576000
|
||||
case 576000: baud = B576000; break;
|
||||
#endif
|
||||
#ifdef B921600
|
||||
case 921600: baud = B921600; break;
|
||||
#endif
|
||||
#ifdef B1000000
|
||||
case 1000000: baud = B1000000; break;
|
||||
#endif
|
||||
#ifdef B1152000
|
||||
case 1152000: baud = B1152000; break;
|
||||
#endif
|
||||
#ifdef B1500000
|
||||
case 1500000: baud = B1500000; break;
|
||||
#endif
|
||||
#ifdef B2000000
|
||||
case 2000000: baud = B2000000; break;
|
||||
#endif
|
||||
#ifdef B2500000
|
||||
case 2500000: baud = B2500000; break;
|
||||
#endif
|
||||
#ifdef B3000000
|
||||
case 3000000: baud = B3000000; break;
|
||||
#endif
|
||||
#ifdef B3500000
|
||||
case 3500000: baud = B3500000; break;
|
||||
#endif
|
||||
#ifdef B4000000
|
||||
case 4000000: baud = B4000000; break;
|
||||
#endif
|
||||
default:
|
||||
custom_baud = true;
|
||||
// Mac OS X 10.x Support
|
||||
#if defined(__APPLE__) && defined(__MACH__)
|
||||
#define IOSSIOSPEED _IOW('T', 2, speed_t)
|
||||
int new_baud = static_cast<int> (baudrate_);
|
||||
if (ioctl (fd_, IOSSIOSPEED, &new_baud, 1) < 0) {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
// Linux Support
|
||||
#elif defined(__linux__)
|
||||
struct serial_struct ser;
|
||||
ioctl (fd_, TIOCGSERIAL, &ser);
|
||||
// set custom divisor
|
||||
ser.custom_divisor = ser.baud_base / (int) baudrate_;
|
||||
// update flags
|
||||
ser.flags &= ~ASYNC_SPD_MASK;
|
||||
ser.flags |= ASYNC_SPD_CUST;
|
||||
|
||||
if (ioctl (fd_, TIOCSSERIAL, ser) < 0) {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
#else
|
||||
throw invalid_argument ("OS does not currently support custom bauds");
|
||||
#endif
|
||||
}
|
||||
if (custom_baud == false) {
|
||||
#ifdef _BSD_SOURCE
|
||||
@ -345,22 +278,7 @@ Serial::SerialImpl::reconfigurePort ()
|
||||
options.c_cflag |= (PARENB);
|
||||
} else if (parity_ == parity_odd) {
|
||||
options.c_cflag |= (PARENB | PARODD);
|
||||
}
|
||||
#ifdef CMSPAR
|
||||
else if (parity_ == parity_mark) {
|
||||
options.c_cflag |= (PARENB | CMSPAR | PARODD);
|
||||
}
|
||||
else if (parity_ == parity_space) {
|
||||
options.c_cflag |= (PARENB | CMSPAR);
|
||||
options.c_cflag &= (tcflag_t) ~(PARODD);
|
||||
}
|
||||
#else
|
||||
// CMSPAR is not defined on OSX. So do not support mark or space parity.
|
||||
else if (parity_ == parity_mark || parity_ == parity_space) {
|
||||
throw invalid_argument ("OS does not support mark or space parity");
|
||||
}
|
||||
#endif // ifdef CMSPAR
|
||||
else {
|
||||
} else {
|
||||
throw invalid_argument ("invalid parity");
|
||||
}
|
||||
// setup flow control
|
||||
@ -412,51 +330,6 @@ Serial::SerialImpl::reconfigurePort ()
|
||||
|
||||
// activate settings
|
||||
::tcsetattr (fd_, TCSANOW, &options);
|
||||
|
||||
// apply custom baud rate, if any
|
||||
if (custom_baud == true) {
|
||||
// OS X support
|
||||
#if defined(MAC_OS_X_VERSION_10_4) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4)
|
||||
// Starting with Tiger, the IOSSIOSPEED ioctl can be used to set arbitrary baud rates
|
||||
// other than those specified by POSIX. The driver for the underlying serial hardware
|
||||
// ultimately determines which baud rates can be used. This ioctl sets both the input
|
||||
// and output speed.
|
||||
speed_t new_baud = static_cast<speed_t> (baudrate_);
|
||||
// PySerial uses IOSSIOSPEED=0x80045402
|
||||
if (-1 == ioctl (fd_, IOSSIOSPEED, &new_baud, 1)) {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
// Linux Support
|
||||
#elif defined(__linux__) && defined (TIOCSSERIAL)
|
||||
struct serial_struct ser;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCGSERIAL, &ser)) {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
|
||||
// set custom divisor
|
||||
ser.custom_divisor = ser.baud_base / static_cast<int> (baudrate_);
|
||||
// update flags
|
||||
ser.flags &= ~ASYNC_SPD_MASK;
|
||||
ser.flags |= ASYNC_SPD_CUST;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCSSERIAL, &ser)) {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
#else
|
||||
throw invalid_argument ("OS does not currently support custom bauds");
|
||||
#endif
|
||||
}
|
||||
|
||||
// Update byte_time_ based on the new settings.
|
||||
uint32_t bit_time_ns = 1e9 / baudrate_;
|
||||
byte_time_ns_ = bit_time_ns * (1 + bytesize_ + parity_ + stopbits_);
|
||||
|
||||
// Compensate for the stopbits_one_point_five enum being equal to int 3,
|
||||
// and not 1.5.
|
||||
if (stopbits_ == stopbits_one_point_five) {
|
||||
byte_time_ns_ += ((1.5 - stopbits_one_point_five) * bit_time_ns);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
@ -464,13 +337,8 @@ Serial::SerialImpl::close ()
|
||||
{
|
||||
if (is_open_ == true) {
|
||||
if (fd_ != -1) {
|
||||
int ret;
|
||||
ret = ::close (fd_);
|
||||
if (ret == 0) {
|
||||
::close (fd_); // Ignoring the outcome
|
||||
fd_ = -1;
|
||||
} else {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
}
|
||||
is_open_ = false;
|
||||
}
|
||||
@ -489,49 +357,27 @@ Serial::SerialImpl::available ()
|
||||
return 0;
|
||||
}
|
||||
int count = 0;
|
||||
if (-1 == ioctl (fd_, TIOCINQ, &count)) {
|
||||
THROW (IOException, errno);
|
||||
} else {
|
||||
int result = ioctl (fd_, TIOCINQ, &count);
|
||||
if (result == 0) {
|
||||
return static_cast<size_t> (count);
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
Serial::SerialImpl::waitReadable (uint32_t timeout)
|
||||
{
|
||||
// Setup a select call to block for serial data or a timeout
|
||||
fd_set readfds;
|
||||
FD_ZERO (&readfds);
|
||||
FD_SET (fd_, &readfds);
|
||||
timespec timeout_ts (timespec_from_ms (timeout));
|
||||
int r = pselect (fd_ + 1, &readfds, NULL, NULL, &timeout_ts, NULL);
|
||||
|
||||
if (r < 0) {
|
||||
// Select was interrupted
|
||||
if (errno == EINTR) {
|
||||
return false;
|
||||
}
|
||||
// Otherwise there was some error
|
||||
} else {
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
// Timeout occurred
|
||||
if (r == 0) {
|
||||
return false;
|
||||
}
|
||||
// This shouldn't happen, if r > 0 our fd has to be in the list!
|
||||
if (!FD_ISSET (fd_, &readfds)) {
|
||||
THROW (IOException, "select reports ready to read, but our fd isn't"
|
||||
" in the list, this shouldn't happen!");
|
||||
}
|
||||
// Data available to read.
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
Serial::SerialImpl::waitByteTimes (size_t count)
|
||||
inline void get_time_now(struct timespec &time)
|
||||
{
|
||||
timespec wait_time = { 0, static_cast<long>(byte_time_ns_ * count)};
|
||||
pselect (0, NULL, NULL, NULL, &wait_time, NULL);
|
||||
# ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
|
||||
clock_serv_t cclock;
|
||||
mach_timespec_t mts;
|
||||
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
|
||||
clock_get_time(cclock, &mts);
|
||||
mach_port_deallocate(mach_task_self(), cclock);
|
||||
time.tv_sec = mts.tv_sec;
|
||||
time.tv_nsec = mts.tv_nsec;
|
||||
# else
|
||||
clock_gettime(CLOCK_REALTIME, &time);
|
||||
# endif
|
||||
}
|
||||
|
||||
size_t
|
||||
@ -541,42 +387,80 @@ Serial::SerialImpl::read (uint8_t *buf, size_t size)
|
||||
if (!is_open_) {
|
||||
throw PortNotOpenedException ("Serial::read");
|
||||
}
|
||||
fd_set readfds;
|
||||
size_t bytes_read = 0;
|
||||
|
||||
// Setup the total_timeout timeval
|
||||
// This timeout is maximum time before a timeout after read is called
|
||||
struct timeval total_timeout;
|
||||
// Calculate total timeout in milliseconds t_c + (t_m * N)
|
||||
long total_timeout_ms = timeout_.read_timeout_constant;
|
||||
total_timeout_ms += timeout_.read_timeout_multiplier * static_cast<long> (size);
|
||||
MillisecondTimer total_timeout(total_timeout_ms);
|
||||
|
||||
// Pre-fill buffer with available bytes
|
||||
{
|
||||
ssize_t bytes_read_now = ::read (fd_, buf, size);
|
||||
if (bytes_read_now > 0) {
|
||||
bytes_read = bytes_read_now;
|
||||
}
|
||||
}
|
||||
|
||||
total_timeout_ms += timeout_.read_timeout_multiplier*static_cast<long>(size);
|
||||
total_timeout.tv_sec = total_timeout_ms / 1000;
|
||||
total_timeout.tv_usec = static_cast<int>(total_timeout_ms % 1000);
|
||||
total_timeout.tv_usec *= 1000; // To convert to micro seconds
|
||||
// Setup the inter byte timeout
|
||||
struct timeval inter_byte_timeout;
|
||||
inter_byte_timeout.tv_sec = timeout_.inter_byte_timeout / 1000;
|
||||
inter_byte_timeout.tv_usec =
|
||||
static_cast<int> (timeout_.inter_byte_timeout % 1000);
|
||||
inter_byte_timeout.tv_usec *= 1000; // To convert to micro seconds
|
||||
while (bytes_read < size) {
|
||||
int64_t timeout_remaining_ms = total_timeout.remaining();
|
||||
if (timeout_remaining_ms <= 0) {
|
||||
// Timed out
|
||||
// Setup the select timeout timeval
|
||||
struct timeval timeout;
|
||||
// If the total_timeout is less than the inter_byte_timeout
|
||||
if (total_timeout.tv_sec < inter_byte_timeout.tv_sec
|
||||
|| (total_timeout.tv_sec == inter_byte_timeout.tv_sec
|
||||
&& total_timeout.tv_usec < inter_byte_timeout.tv_sec))
|
||||
{
|
||||
// Then set the select timeout to use the total time
|
||||
timeout = total_timeout;
|
||||
} else {
|
||||
// Else set the select timeout to use the inter byte time
|
||||
timeout = inter_byte_timeout;
|
||||
}
|
||||
FD_ZERO (&readfds);
|
||||
FD_SET (fd_, &readfds);
|
||||
// Begin timing select
|
||||
struct timespec start, end;
|
||||
get_time_now (start);
|
||||
// Call select to block for serial data or a timeout
|
||||
int r = select (fd_ + 1, &readfds, NULL, NULL, &timeout);
|
||||
// Calculate difference and update the structure
|
||||
get_time_now (end);
|
||||
// Calculate the time select took
|
||||
struct timeval diff;
|
||||
diff.tv_sec = end.tv_sec - start.tv_sec;
|
||||
diff.tv_usec = static_cast<int> ((end.tv_nsec - start.tv_nsec) / 1000);
|
||||
// Update the timeout
|
||||
if (total_timeout.tv_sec <= diff.tv_sec) {
|
||||
total_timeout.tv_sec = 0;
|
||||
} else {
|
||||
total_timeout.tv_sec -= diff.tv_sec;
|
||||
}
|
||||
if (total_timeout.tv_usec <= diff.tv_usec) {
|
||||
total_timeout.tv_usec = 0;
|
||||
} else {
|
||||
total_timeout.tv_usec -= diff.tv_usec;
|
||||
}
|
||||
|
||||
// Figure out what happened by looking at select's response 'r'
|
||||
/** Error **/
|
||||
if (r < 0) {
|
||||
// Select was interrupted, try again
|
||||
if (errno == EINTR) {
|
||||
continue;
|
||||
}
|
||||
// Otherwise there was some error
|
||||
THROW (IOException, errno);
|
||||
}
|
||||
/** Timeout **/
|
||||
if (r == 0) {
|
||||
break;
|
||||
}
|
||||
// Timeout for the next select is whichever is less of the remaining
|
||||
// total read timeout and the inter-byte timeout.
|
||||
uint32_t timeout = std::min(static_cast<uint32_t> (timeout_remaining_ms),
|
||||
timeout_.inter_byte_timeout);
|
||||
// Wait for the device to be readable, and then attempt to read.
|
||||
if (waitReadable(timeout)) {
|
||||
// If it's a fixed-length multi-byte read, insert a wait here so that
|
||||
// we can attempt to grab the whole thing in a single IO call. Skip
|
||||
// this wait if a non-max inter_byte_timeout is specified.
|
||||
if (size > 1 && timeout_.inter_byte_timeout == Timeout::max()) {
|
||||
size_t bytes_available = available();
|
||||
if (bytes_available + bytes_read < size) {
|
||||
waitByteTimes(size - (bytes_available + bytes_read));
|
||||
}
|
||||
}
|
||||
/** Something ready to read **/
|
||||
if (r > 0) {
|
||||
// Make sure our file descriptor is in the ready to read list
|
||||
if (FD_ISSET (fd_, &readfds)) {
|
||||
// This should be non-blocking returning only what is available now
|
||||
// Then returning so that select can block again.
|
||||
ssize_t bytes_read_now =
|
||||
@ -587,7 +471,7 @@ Serial::SerialImpl::read (uint8_t *buf, size_t size)
|
||||
// Disconnected devices, at least on Linux, show the
|
||||
// behavior that they are always ready to read immediately
|
||||
// but reading returns nothing.
|
||||
throw SerialException ("device reports readiness to read but "
|
||||
throw SerialExecption ("device reports readiness to read but "
|
||||
"returned no data (device disconnected?)");
|
||||
}
|
||||
// Update bytes_read
|
||||
@ -602,11 +486,15 @@ Serial::SerialImpl::read (uint8_t *buf, size_t size)
|
||||
}
|
||||
// If bytes_read > size then we have over read, which shouldn't happen
|
||||
if (bytes_read > size) {
|
||||
throw SerialException ("read over read, too many bytes where "
|
||||
throw SerialExecption ("read over read, too many bytes where "
|
||||
"read, this shouldn't happen, might be "
|
||||
"a logical error!");
|
||||
}
|
||||
}
|
||||
// This shouldn't happen, if r > 0 our fd has to be in the list!
|
||||
THROW (IOException, "select reports ready to read, but our fd isn't"
|
||||
" in the list, this shouldn't happen!");
|
||||
}
|
||||
}
|
||||
return bytes_read;
|
||||
}
|
||||
@ -619,30 +507,42 @@ Serial::SerialImpl::write (const uint8_t *data, size_t length)
|
||||
}
|
||||
fd_set writefds;
|
||||
size_t bytes_written = 0;
|
||||
|
||||
// Calculate total timeout in milliseconds t_c + (t_m * N)
|
||||
long total_timeout_ms = timeout_.write_timeout_constant;
|
||||
total_timeout_ms += timeout_.write_timeout_multiplier * static_cast<long> (length);
|
||||
MillisecondTimer total_timeout(total_timeout_ms);
|
||||
|
||||
bool first_iteration = true;
|
||||
struct timeval timeout;
|
||||
timeout.tv_sec = timeout_.write_timeout_constant / 1000;
|
||||
timeout.tv_usec = static_cast<int> (timeout_.write_timeout_multiplier % 1000);
|
||||
timeout.tv_usec *= 1000; // To convert to micro seconds
|
||||
while (bytes_written < length) {
|
||||
int64_t timeout_remaining_ms = total_timeout.remaining();
|
||||
// Only consider the timeout if it's not the first iteration of the loop
|
||||
// otherwise a timeout of 0 won't be allowed through
|
||||
if (!first_iteration && (timeout_remaining_ms <= 0)) {
|
||||
// Timed out
|
||||
break;
|
||||
}
|
||||
first_iteration = false;
|
||||
|
||||
timespec timeout(timespec_from_ms(timeout_remaining_ms));
|
||||
|
||||
FD_ZERO (&writefds);
|
||||
FD_SET (fd_, &writefds);
|
||||
|
||||
// On Linux the timeout struct is updated by select to contain the time
|
||||
// left on the timeout to make looping easier, but on other platforms this
|
||||
// does not occur.
|
||||
#if !defined(__linux__)
|
||||
// Begin timing select
|
||||
struct timespec start, end;
|
||||
get_time_now(start);
|
||||
#endif
|
||||
// Do the select
|
||||
int r = pselect (fd_ + 1, NULL, &writefds, NULL, &timeout, NULL);
|
||||
int r = select (fd_ + 1, NULL, &writefds, NULL, &timeout);
|
||||
#if !defined(__linux__)
|
||||
// Calculate difference and update the structure
|
||||
get_time_now(end);
|
||||
// Calculate the time select took
|
||||
struct timeval diff;
|
||||
diff.tv_sec = end.tv_sec - start.tv_sec;
|
||||
diff.tv_usec = static_cast<int> ((end.tv_nsec - start.tv_nsec) / 1000);
|
||||
// Update the timeout
|
||||
if (timeout.tv_sec <= diff.tv_sec) {
|
||||
timeout.tv_sec = 0;
|
||||
} else {
|
||||
timeout.tv_sec -= diff.tv_sec;
|
||||
}
|
||||
if (timeout.tv_usec <= diff.tv_usec) {
|
||||
timeout.tv_usec = 0;
|
||||
} else {
|
||||
timeout.tv_usec -= diff.tv_usec;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Figure out what happened by looking at select's response 'r'
|
||||
/** Error **/
|
||||
@ -665,27 +565,14 @@ Serial::SerialImpl::write (const uint8_t *data, size_t length)
|
||||
// This will write some
|
||||
ssize_t bytes_written_now =
|
||||
::write (fd_, data + bytes_written, length - bytes_written);
|
||||
|
||||
// even though pselect returned readiness the call might still be
|
||||
// interrupted. In that case simply retry.
|
||||
if (bytes_written_now == -1 && errno == EINTR) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// write should always return some data as select reported it was
|
||||
// ready to write when we get to this point.
|
||||
if (bytes_written_now < 1) {
|
||||
// Disconnected devices, at least on Linux, show the
|
||||
// behavior that they are always ready to write immediately
|
||||
// but writing returns nothing.
|
||||
std::stringstream strs;
|
||||
strs << "device reports readiness to write but "
|
||||
"returned no data (device disconnected?)";
|
||||
strs << " errno=" << errno;
|
||||
strs << " bytes_written_now= " << bytes_written_now;
|
||||
strs << " bytes_written=" << bytes_written;
|
||||
strs << " length=" << length;
|
||||
throw SerialException(strs.str().c_str());
|
||||
throw SerialExecption ("device reports readiness to write but "
|
||||
"returned no data (device disconnected?)");
|
||||
}
|
||||
// Update bytes_written
|
||||
bytes_written += static_cast<size_t> (bytes_written_now);
|
||||
@ -699,7 +586,7 @@ Serial::SerialImpl::write (const uint8_t *data, size_t length)
|
||||
}
|
||||
// If bytes_written > size then we have over written, which shouldn't happen
|
||||
if (bytes_written > length) {
|
||||
throw SerialException ("write over wrote, too many bytes where "
|
||||
throw SerialExecption ("write over wrote, too many bytes where "
|
||||
"written, this shouldn't happen, might be "
|
||||
"a logical error!");
|
||||
}
|
||||
@ -848,21 +735,10 @@ Serial::SerialImpl::setBreak (bool level)
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::setBreak");
|
||||
}
|
||||
|
||||
if (level) {
|
||||
if (-1 == ioctl (fd_, TIOCSBRK))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setBreak failed on a call to ioctl(TIOCSBRK): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCSBRK);
|
||||
} else {
|
||||
if (-1 == ioctl (fd_, TIOCCBRK))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setBreak failed on a call to ioctl(TIOCCBRK): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCCBRK);
|
||||
}
|
||||
}
|
||||
|
||||
@ -872,23 +748,10 @@ Serial::SerialImpl::setRTS (bool level)
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::setRTS");
|
||||
}
|
||||
|
||||
int command = TIOCM_RTS;
|
||||
|
||||
if (level) {
|
||||
if (-1 == ioctl (fd_, TIOCMBIS, &command))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setRTS failed on a call to ioctl(TIOCMBIS): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCMBIS, TIOCM_RTS);
|
||||
} else {
|
||||
if (-1 == ioctl (fd_, TIOCMBIC, &command))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setRTS failed on a call to ioctl(TIOCMBIC): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCMBIC, TIOCM_RTS);
|
||||
}
|
||||
}
|
||||
|
||||
@ -898,23 +761,10 @@ Serial::SerialImpl::setDTR (bool level)
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::setDTR");
|
||||
}
|
||||
|
||||
int command = TIOCM_DTR;
|
||||
|
||||
if (level) {
|
||||
if (-1 == ioctl (fd_, TIOCMBIS, &command))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setDTR failed on a call to ioctl(TIOCMBIS): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCMBIS, TIOCM_DTR);
|
||||
} else {
|
||||
if (-1 == ioctl (fd_, TIOCMBIC, &command))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "setDTR failed on a call to ioctl(TIOCMBIC): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
ioctl (fd_, TIOCMBIC, TIOCM_DTR);
|
||||
}
|
||||
}
|
||||
|
||||
@ -922,40 +772,21 @@ bool
|
||||
Serial::SerialImpl::waitForChange ()
|
||||
{
|
||||
#ifndef TIOCMIWAIT
|
||||
|
||||
while (is_open_ == true) {
|
||||
|
||||
int status;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMGET, &status))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "waitForChange failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
else
|
||||
{
|
||||
if (0 != (status & TIOCM_CTS)
|
||||
|| 0 != (status & TIOCM_DSR)
|
||||
|| 0 != (status & TIOCM_RI)
|
||||
|| 0 != (status & TIOCM_CD))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
while (is_open_ == true) {
|
||||
int s = ioctl (fd_, TIOCMGET, 0);
|
||||
if ((s & TIOCM_CTS) != 0) return true;
|
||||
if ((s & TIOCM_DSR) != 0) return true;
|
||||
if ((s & TIOCM_RI) != 0) return true;
|
||||
if ((s & TIOCM_CD) != 0) return true;
|
||||
usleep(1000);
|
||||
}
|
||||
|
||||
return false;
|
||||
#else
|
||||
int command = (TIOCM_CD|TIOCM_DSR|TIOCM_RI|TIOCM_CTS);
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMIWAIT, &command)) {
|
||||
if (ioctl(fd_, TIOCMIWAIT, (TIOCM_CD|TIOCM_DSR|TIOCM_RI|TIOCM_CTS)) != 0) {
|
||||
stringstream ss;
|
||||
ss << "waitForDSR failed on a call to ioctl(TIOCMIWAIT): "
|
||||
<< errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
throw(SerialExecption(ss.str().c_str()));
|
||||
}
|
||||
return true;
|
||||
#endif
|
||||
@ -967,19 +798,8 @@ Serial::SerialImpl::getCTS ()
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::getCTS");
|
||||
}
|
||||
|
||||
int status;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMGET, &status))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "getCTS failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0 != (status & TIOCM_CTS);
|
||||
}
|
||||
int s = ioctl (fd_, TIOCMGET, 0);
|
||||
return (s & TIOCM_CTS) != 0;
|
||||
}
|
||||
|
||||
bool
|
||||
@ -988,19 +808,8 @@ Serial::SerialImpl::getDSR ()
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::getDSR");
|
||||
}
|
||||
|
||||
int status;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMGET, &status))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "getDSR failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0 != (status & TIOCM_DSR);
|
||||
}
|
||||
int s = ioctl (fd_, TIOCMGET, 0);
|
||||
return (s & TIOCM_DSR) != 0;
|
||||
}
|
||||
|
||||
bool
|
||||
@ -1009,19 +818,8 @@ Serial::SerialImpl::getRI ()
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::getRI");
|
||||
}
|
||||
|
||||
int status;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMGET, &status))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "getRI failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0 != (status & TIOCM_RI);
|
||||
}
|
||||
int s = ioctl (fd_, TIOCMGET, 0);
|
||||
return (s & TIOCM_RI) != 0;
|
||||
}
|
||||
|
||||
bool
|
||||
@ -1030,19 +828,8 @@ Serial::SerialImpl::getCD ()
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException ("Serial::getCD");
|
||||
}
|
||||
|
||||
int status;
|
||||
|
||||
if (-1 == ioctl (fd_, TIOCMGET, &status))
|
||||
{
|
||||
stringstream ss;
|
||||
ss << "getCD failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno);
|
||||
throw(SerialException(ss.str().c_str()));
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0 != (status & TIOCM_CD);
|
||||
}
|
||||
int s = ioctl (fd_, TIOCMGET, 0);
|
||||
return (s & TIOCM_CD) != 0;
|
||||
}
|
||||
|
||||
void
|
||||
@ -1080,5 +867,3 @@ Serial::SerialImpl::writeUnlock ()
|
||||
THROW (IOException, result);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // !defined(_WIN32)
|
||||
|
||||
171
src/impl/win.cc
171
src/impl/win.cc
@ -1,13 +1,8 @@
|
||||
#if defined(_WIN32)
|
||||
|
||||
/* Copyright 2012 William Woodall and John Harrison */
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include "serial/impl/win.h"
|
||||
|
||||
using std::string;
|
||||
using std::wstring;
|
||||
using std::stringstream;
|
||||
using std::invalid_argument;
|
||||
using serial::Serial;
|
||||
@ -16,33 +11,23 @@ using serial::bytesize_t;
|
||||
using serial::parity_t;
|
||||
using serial::stopbits_t;
|
||||
using serial::flowcontrol_t;
|
||||
using serial::SerialException;
|
||||
using serial::SerialExecption;
|
||||
using serial::PortNotOpenedException;
|
||||
using serial::IOException;
|
||||
|
||||
inline wstring
|
||||
_prefix_port_if_needed(const wstring &input)
|
||||
{
|
||||
static wstring windows_com_port_prefix = L"\\\\.\\";
|
||||
if (input.compare(0, windows_com_port_prefix.size(), windows_com_port_prefix) != 0)
|
||||
{
|
||||
return windows_com_port_prefix + input;
|
||||
}
|
||||
return input;
|
||||
}
|
||||
|
||||
Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
|
||||
bytesize_t bytesize,
|
||||
parity_t parity, stopbits_t stopbits,
|
||||
flowcontrol_t flowcontrol)
|
||||
: port_ (port.begin(), port.end()), fd_ (INVALID_HANDLE_VALUE), is_open_ (false),
|
||||
: port_ (port), fd_ (INVALID_HANDLE_VALUE), is_open_ (false),
|
||||
baudrate_ (baudrate), parity_ (parity),
|
||||
bytesize_ (bytesize), stopbits_ (stopbits), flowcontrol_ (flowcontrol)
|
||||
{
|
||||
if (port_.empty () == false)
|
||||
open ();
|
||||
read_mutex = CreateMutex(NULL, false, NULL);
|
||||
write_mutex = CreateMutex(NULL, false, NULL);
|
||||
if (port_.empty () == false)
|
||||
open ();
|
||||
}
|
||||
|
||||
Serial::SerialImpl::~SerialImpl ()
|
||||
@ -59,13 +44,10 @@ Serial::SerialImpl::open ()
|
||||
throw invalid_argument ("Empty port is invalid.");
|
||||
}
|
||||
if (is_open_ == true) {
|
||||
throw SerialException ("Serial port already open.");
|
||||
throw SerialExecption ("Serial port already open.");
|
||||
}
|
||||
|
||||
// See: https://github.com/wjwwood/serial/issues/84
|
||||
wstring port_with_prefix = _prefix_port_if_needed(port_);
|
||||
LPCWSTR lp_port = port_with_prefix.c_str();
|
||||
fd_ = CreateFileW(lp_port,
|
||||
fd_ = CreateFile(port_.c_str(),
|
||||
GENERIC_READ | GENERIC_WRITE,
|
||||
0,
|
||||
0,
|
||||
@ -74,15 +56,14 @@ Serial::SerialImpl::open ()
|
||||
0);
|
||||
|
||||
if (fd_ == INVALID_HANDLE_VALUE) {
|
||||
DWORD create_file_err = GetLastError();
|
||||
DWORD errno_ = GetLastError();
|
||||
stringstream ss;
|
||||
switch (create_file_err) {
|
||||
switch (errno_) {
|
||||
case ERROR_FILE_NOT_FOUND:
|
||||
// Use this->getPort to convert to a std::string
|
||||
ss << "Specified port, " << this->getPort() << ", does not exist.";
|
||||
ss << "Specified port, " << port_ << ", does not exist.";
|
||||
THROW (IOException, ss.str().c_str());
|
||||
default:
|
||||
ss << "Unknown error opening the serial port: " << create_file_err;
|
||||
ss << "Unknown error opening the serial port: " << errno;
|
||||
THROW (IOException, ss.str().c_str());
|
||||
}
|
||||
}
|
||||
@ -228,10 +209,6 @@ Serial::SerialImpl::reconfigurePort ()
|
||||
dcbSerialParams.Parity = EVENPARITY;
|
||||
} else if (parity_ == parity_odd) {
|
||||
dcbSerialParams.Parity = ODDPARITY;
|
||||
} else if (parity_ == parity_mark) {
|
||||
dcbSerialParams.Parity = MARKPARITY;
|
||||
} else if (parity_ == parity_space) {
|
||||
dcbSerialParams.Parity = SPACEPARITY;
|
||||
} else {
|
||||
throw invalid_argument ("invalid parity");
|
||||
}
|
||||
@ -239,39 +216,27 @@ Serial::SerialImpl::reconfigurePort ()
|
||||
// setup flowcontrol
|
||||
if (flowcontrol_ == flowcontrol_none) {
|
||||
dcbSerialParams.fOutxCtsFlow = false;
|
||||
dcbSerialParams.fRtsControl = RTS_CONTROL_DISABLE;
|
||||
dcbSerialParams.fRtsControl = 0x00;
|
||||
dcbSerialParams.fOutX = false;
|
||||
dcbSerialParams.fInX = false;
|
||||
}
|
||||
if (flowcontrol_ == flowcontrol_software) {
|
||||
dcbSerialParams.fOutxCtsFlow = false;
|
||||
dcbSerialParams.fRtsControl = RTS_CONTROL_DISABLE;
|
||||
dcbSerialParams.fRtsControl = 0x00;
|
||||
dcbSerialParams.fOutX = true;
|
||||
dcbSerialParams.fInX = true;
|
||||
}
|
||||
if (flowcontrol_ == flowcontrol_hardware) {
|
||||
dcbSerialParams.fOutxCtsFlow = true;
|
||||
dcbSerialParams.fRtsControl = RTS_CONTROL_HANDSHAKE;
|
||||
dcbSerialParams.fRtsControl = 0x03;
|
||||
dcbSerialParams.fOutX = false;
|
||||
dcbSerialParams.fInX = false;
|
||||
}
|
||||
|
||||
// activate settings
|
||||
if (!SetCommState(fd_, &dcbSerialParams)){
|
||||
CloseHandle(fd_);
|
||||
if(!SetCommState(fd_, &dcbSerialParams)){
|
||||
THROW (IOException, "Error setting serial port settings.");
|
||||
}
|
||||
|
||||
// Setup timeouts
|
||||
COMMTIMEOUTS timeouts = {0};
|
||||
timeouts.ReadIntervalTimeout = timeout_.inter_byte_timeout;
|
||||
timeouts.ReadTotalTimeoutConstant = timeout_.read_timeout_constant;
|
||||
timeouts.ReadTotalTimeoutMultiplier = timeout_.read_timeout_multiplier;
|
||||
timeouts.WriteTotalTimeoutConstant = timeout_.write_timeout_constant;
|
||||
timeouts.WriteTotalTimeoutMultiplier = timeout_.write_timeout_multiplier;
|
||||
if (!SetCommTimeouts(fd_, &timeouts)) {
|
||||
THROW (IOException, "Error setting timeouts.");
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
@ -279,16 +244,9 @@ Serial::SerialImpl::close ()
|
||||
{
|
||||
if (is_open_ == true) {
|
||||
if (fd_ != INVALID_HANDLE_VALUE) {
|
||||
int ret;
|
||||
ret = CloseHandle(fd_);
|
||||
if (ret == 0) {
|
||||
stringstream ss;
|
||||
ss << "Error while closing serial port: " << GetLastError();
|
||||
THROW (IOException, ss.str().c_str());
|
||||
} else {
|
||||
CloseHandle(fd_);
|
||||
fd_ = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
}
|
||||
is_open_ = false;
|
||||
}
|
||||
}
|
||||
@ -302,29 +260,7 @@ Serial::SerialImpl::isOpen () const
|
||||
size_t
|
||||
Serial::SerialImpl::available ()
|
||||
{
|
||||
if (!is_open_) {
|
||||
return 0;
|
||||
}
|
||||
COMSTAT cs;
|
||||
if (!ClearCommError(fd_, NULL, &cs)) {
|
||||
stringstream ss;
|
||||
ss << "Error while checking status of the serial port: " << GetLastError();
|
||||
THROW (IOException, ss.str().c_str());
|
||||
}
|
||||
return static_cast<size_t>(cs.cbInQue);
|
||||
}
|
||||
|
||||
bool
|
||||
Serial::SerialImpl::waitReadable (uint32_t /*timeout*/)
|
||||
{
|
||||
THROW (IOException, "waitReadable is not implemented on Windows.");
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
Serial::SerialImpl::waitByteTimes (size_t /*count*/)
|
||||
{
|
||||
THROW (IOException, "waitByteTimes is not implemented on Windows.");
|
||||
THROW (IOException, "available is not implemented on Windows.");
|
||||
}
|
||||
|
||||
size_t
|
||||
@ -334,7 +270,7 @@ Serial::SerialImpl::read (uint8_t *buf, size_t size)
|
||||
throw PortNotOpenedException ("Serial::read");
|
||||
}
|
||||
DWORD bytes_read;
|
||||
if (!ReadFile(fd_, buf, static_cast<DWORD>(size), &bytes_read, NULL)) {
|
||||
if (!ReadFile(fd_, buf, size, &bytes_read, NULL)) {
|
||||
stringstream ss;
|
||||
ss << "Error while reading from the serial port: " << GetLastError();
|
||||
THROW (IOException, ss.str().c_str());
|
||||
@ -349,7 +285,7 @@ Serial::SerialImpl::write (const uint8_t *data, size_t length)
|
||||
throw PortNotOpenedException ("Serial::write");
|
||||
}
|
||||
DWORD bytes_written;
|
||||
if (!WriteFile(fd_, data, static_cast<DWORD>(length), &bytes_written, NULL)) {
|
||||
if (!WriteFile(fd_, data, length, &bytes_written, NULL)) {
|
||||
stringstream ss;
|
||||
ss << "Error while writing to the serial port: " << GetLastError();
|
||||
THROW (IOException, ss.str().c_str());
|
||||
@ -360,21 +296,27 @@ Serial::SerialImpl::write (const uint8_t *data, size_t length)
|
||||
void
|
||||
Serial::SerialImpl::setPort (const string &port)
|
||||
{
|
||||
port_ = wstring(port.begin(), port.end());
|
||||
port_ = port;
|
||||
}
|
||||
|
||||
string
|
||||
Serial::SerialImpl::getPort () const
|
||||
{
|
||||
return string(port_.begin(), port_.end());
|
||||
return port_;
|
||||
}
|
||||
|
||||
void
|
||||
Serial::SerialImpl::setTimeout (serial::Timeout &timeout)
|
||||
{
|
||||
timeout_ = timeout;
|
||||
if (is_open_) {
|
||||
reconfigurePort ();
|
||||
COMMTIMEOUTS timeouts = {0};
|
||||
timeouts.ReadIntervalTimeout = timeout_.inter_byte_timeout;
|
||||
timeouts.ReadTotalTimeoutConstant = timeout_.read_timeout_constant;
|
||||
timeouts.ReadTotalTimeoutMultiplier = timeout_.read_timeout_multiplier;
|
||||
timeouts.WriteTotalTimeoutConstant = timeout_.write_timeout_constant;
|
||||
timeouts.WriteTotalTimeoutMultiplier = timeout_.write_timeout_multiplier;
|
||||
if(!SetCommTimeouts(fd_, &timeouts)){
|
||||
THROW (IOException, "Error setting timeouts.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -388,9 +330,8 @@ void
|
||||
Serial::SerialImpl::setBaudrate (unsigned long baudrate)
|
||||
{
|
||||
baudrate_ = baudrate;
|
||||
if (is_open_) {
|
||||
if (is_open_)
|
||||
reconfigurePort ();
|
||||
}
|
||||
}
|
||||
|
||||
unsigned long
|
||||
@ -403,9 +344,8 @@ void
|
||||
Serial::SerialImpl::setBytesize (serial::bytesize_t bytesize)
|
||||
{
|
||||
bytesize_ = bytesize;
|
||||
if (is_open_) {
|
||||
if (is_open_)
|
||||
reconfigurePort ();
|
||||
}
|
||||
}
|
||||
|
||||
serial::bytesize_t
|
||||
@ -418,9 +358,8 @@ void
|
||||
Serial::SerialImpl::setParity (serial::parity_t parity)
|
||||
{
|
||||
parity_ = parity;
|
||||
if (is_open_) {
|
||||
if (is_open_)
|
||||
reconfigurePort ();
|
||||
}
|
||||
}
|
||||
|
||||
serial::parity_t
|
||||
@ -433,9 +372,8 @@ void
|
||||
Serial::SerialImpl::setStopbits (serial::stopbits_t stopbits)
|
||||
{
|
||||
stopbits_ = stopbits;
|
||||
if (is_open_) {
|
||||
if (is_open_)
|
||||
reconfigurePort ();
|
||||
}
|
||||
}
|
||||
|
||||
serial::stopbits_t
|
||||
@ -448,9 +386,8 @@ void
|
||||
Serial::SerialImpl::setFlowcontrol (serial::flowcontrol_t flowcontrol)
|
||||
{
|
||||
flowcontrol_ = flowcontrol;
|
||||
if (is_open_) {
|
||||
if (is_open_)
|
||||
reconfigurePort ();
|
||||
}
|
||||
}
|
||||
|
||||
serial::flowcontrol_t
|
||||
@ -471,23 +408,17 @@ Serial::SerialImpl::flush ()
|
||||
void
|
||||
Serial::SerialImpl::flushInput ()
|
||||
{
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException("Serial::flushInput");
|
||||
}
|
||||
PurgeComm(fd_, PURGE_RXCLEAR);
|
||||
THROW (IOException, "flushInput is not supported on Windows.");
|
||||
}
|
||||
|
||||
void
|
||||
Serial::SerialImpl::flushOutput ()
|
||||
{
|
||||
if (is_open_ == false) {
|
||||
throw PortNotOpenedException("Serial::flushOutput");
|
||||
}
|
||||
PurgeComm(fd_, PURGE_TXCLEAR);
|
||||
THROW (IOException, "flushOutput is not supported on Windows.");
|
||||
}
|
||||
|
||||
void
|
||||
Serial::SerialImpl::sendBreak (int /*duration*/)
|
||||
Serial::SerialImpl::sendBreak (int duration)
|
||||
{
|
||||
THROW (IOException, "sendBreak is not supported on Windows.");
|
||||
}
|
||||
@ -560,11 +491,11 @@ Serial::SerialImpl::getCTS ()
|
||||
throw PortNotOpenedException ("Serial::getCTS");
|
||||
}
|
||||
DWORD dwModemStatus;
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus)) {
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus))
|
||||
// Error in GetCommModemStatus;
|
||||
THROW (IOException, "Error getting the status of the CTS line.");
|
||||
}
|
||||
|
||||
return (MS_CTS_ON & dwModemStatus) != 0;
|
||||
return (bool) (MS_CTS_ON & dwModemStatus);
|
||||
}
|
||||
|
||||
bool
|
||||
@ -574,11 +505,11 @@ Serial::SerialImpl::getDSR ()
|
||||
throw PortNotOpenedException ("Serial::getDSR");
|
||||
}
|
||||
DWORD dwModemStatus;
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus)) {
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus))
|
||||
// Error in GetCommModemStatus;
|
||||
THROW (IOException, "Error getting the status of the DSR line.");
|
||||
}
|
||||
|
||||
return (MS_DSR_ON & dwModemStatus) != 0;
|
||||
return (bool) (MS_DSR_ON & dwModemStatus);
|
||||
}
|
||||
|
||||
bool
|
||||
@ -588,11 +519,11 @@ Serial::SerialImpl::getRI()
|
||||
throw PortNotOpenedException ("Serial::getRI");
|
||||
}
|
||||
DWORD dwModemStatus;
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus)) {
|
||||
THROW (IOException, "Error getting the status of the RI line.");
|
||||
}
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus))
|
||||
// Error in GetCommModemStatus;
|
||||
THROW (IOException, "Error getting the status of the DSR line.");
|
||||
|
||||
return (MS_RING_ON & dwModemStatus) != 0;
|
||||
return (bool) (MS_RING_ON & dwModemStatus);
|
||||
}
|
||||
|
||||
bool
|
||||
@ -602,12 +533,11 @@ Serial::SerialImpl::getCD()
|
||||
throw PortNotOpenedException ("Serial::getCD");
|
||||
}
|
||||
DWORD dwModemStatus;
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus)) {
|
||||
if (!GetCommModemStatus(fd_, &dwModemStatus))
|
||||
// Error in GetCommModemStatus;
|
||||
THROW (IOException, "Error getting the status of the CD line.");
|
||||
}
|
||||
THROW (IOException, "Error getting the status of the DSR line.");
|
||||
|
||||
return (MS_RLSD_ON & dwModemStatus) != 0;
|
||||
return (bool) (MS_RLSD_ON & dwModemStatus);
|
||||
}
|
||||
|
||||
void
|
||||
@ -641,6 +571,3 @@ Serial::SerialImpl::writeUnlock()
|
||||
THROW (IOException, "Error releasing write mutex.");
|
||||
}
|
||||
}
|
||||
|
||||
#endif // #if defined(_WIN32)
|
||||
|
||||
|
||||
@ -1,14 +1,8 @@
|
||||
/* Copyright 2012 William Woodall and John Harrison */
|
||||
#include <algorithm>
|
||||
|
||||
#if !defined(_WIN32) && !defined(__OpenBSD__) && !defined(__FreeBSD__)
|
||||
#ifndef _WIN32
|
||||
# include <alloca.h>
|
||||
#endif
|
||||
|
||||
#if defined (__MINGW32__)
|
||||
# define alloca __builtin_alloca
|
||||
#endif
|
||||
|
||||
#include "serial/serial.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
@ -25,7 +19,7 @@ using std::size_t;
|
||||
using std::string;
|
||||
|
||||
using serial::Serial;
|
||||
using serial::SerialException;
|
||||
using serial::SerialExecption;
|
||||
using serial::IOException;
|
||||
using serial::bytesize_t;
|
||||
using serial::parity_t;
|
||||
@ -43,6 +37,7 @@ public:
|
||||
private:
|
||||
// Disable copy constructors
|
||||
ScopedReadLock(const ScopedReadLock&);
|
||||
void operator=(const ScopedReadLock&);
|
||||
const ScopedReadLock& operator=(ScopedReadLock);
|
||||
|
||||
SerialImpl *pimpl_;
|
||||
@ -59,6 +54,7 @@ public:
|
||||
private:
|
||||
// Disable copy constructors
|
||||
ScopedWriteLock(const ScopedWriteLock&);
|
||||
void operator=(const ScopedWriteLock&);
|
||||
const ScopedWriteLock& operator=(ScopedWriteLock);
|
||||
SerialImpl *pimpl_;
|
||||
};
|
||||
@ -66,7 +62,7 @@ private:
|
||||
Serial::Serial (const string &port, uint32_t baudrate, serial::Timeout timeout,
|
||||
bytesize_t bytesize, parity_t parity, stopbits_t stopbits,
|
||||
flowcontrol_t flowcontrol)
|
||||
: pimpl_(new SerialImpl (port, baudrate, bytesize, parity,
|
||||
: read_cache_(""), pimpl_(new SerialImpl (port, baudrate, bytesize, parity,
|
||||
stopbits, flowcontrol))
|
||||
{
|
||||
pimpl_->setTimeout(timeout);
|
||||
@ -101,19 +97,6 @@ Serial::available ()
|
||||
return pimpl_->available ();
|
||||
}
|
||||
|
||||
bool
|
||||
Serial::waitReadable ()
|
||||
{
|
||||
serial::Timeout timeout(pimpl_->getTimeout ());
|
||||
return pimpl_->waitReadable(timeout.read_timeout_constant);
|
||||
}
|
||||
|
||||
void
|
||||
Serial::waitByteTimes (size_t count)
|
||||
{
|
||||
pimpl_->waitByteTimes(count);
|
||||
}
|
||||
|
||||
size_t
|
||||
Serial::read_ (uint8_t *buffer, size_t size)
|
||||
{
|
||||
@ -123,25 +106,16 @@ Serial::read_ (uint8_t *buffer, size_t size)
|
||||
size_t
|
||||
Serial::read (uint8_t *buffer, size_t size)
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock (this->pimpl_);
|
||||
return this->pimpl_->read (buffer, size);
|
||||
}
|
||||
|
||||
size_t
|
||||
Serial::read (std::vector<uint8_t> &buffer, size_t size)
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock (this->pimpl_);
|
||||
uint8_t *buffer_ = new uint8_t[size];
|
||||
size_t bytes_read = 0;
|
||||
|
||||
try {
|
||||
bytes_read = this->pimpl_->read (buffer_, size);
|
||||
}
|
||||
catch (const std::exception &e) {
|
||||
delete[] buffer_;
|
||||
throw;
|
||||
}
|
||||
|
||||
size_t bytes_read = this->pimpl_->read (buffer_, size);
|
||||
buffer.insert (buffer.end (), buffer_, buffer_+bytes_read);
|
||||
delete[] buffer_;
|
||||
return bytes_read;
|
||||
@ -150,16 +124,9 @@ Serial::read (std::vector<uint8_t> &buffer, size_t size)
|
||||
size_t
|
||||
Serial::read (std::string &buffer, size_t size)
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock (this->pimpl_);
|
||||
uint8_t *buffer_ = new uint8_t[size];
|
||||
size_t bytes_read = 0;
|
||||
try {
|
||||
bytes_read = this->pimpl_->read (buffer_, size);
|
||||
}
|
||||
catch (const std::exception &e) {
|
||||
delete[] buffer_;
|
||||
throw;
|
||||
}
|
||||
size_t bytes_read = this->pimpl_->read (buffer_, size);
|
||||
buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
|
||||
delete[] buffer_;
|
||||
return bytes_read;
|
||||
@ -176,7 +143,7 @@ Serial::read (size_t size)
|
||||
size_t
|
||||
Serial::readline (string &buffer, size_t size, string eol)
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock (this->pimpl_);
|
||||
size_t eol_len = eol.length ();
|
||||
uint8_t *buffer_ = static_cast<uint8_t*>
|
||||
(alloca (size * sizeof (uint8_t)));
|
||||
@ -188,7 +155,6 @@ Serial::readline (string &buffer, size_t size, string eol)
|
||||
if (bytes_read == 0) {
|
||||
break; // Timeout occured on reading 1 byte
|
||||
}
|
||||
if(read_so_far < eol_len) continue;
|
||||
if (string (reinterpret_cast<const char*>
|
||||
(buffer_ + read_so_far - eol_len), eol_len) == eol) {
|
||||
break; // EOL found
|
||||
@ -212,7 +178,7 @@ Serial::readline (size_t size, string eol)
|
||||
vector<string>
|
||||
Serial::readlines (size_t size, string eol)
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock (this->pimpl_);
|
||||
std::vector<std::string> lines;
|
||||
size_t eol_len = eol.length ();
|
||||
uint8_t *buffer_ = static_cast<uint8_t*>
|
||||
@ -230,7 +196,6 @@ Serial::readlines (size_t size, string eol)
|
||||
}
|
||||
break; // Timeout occured on reading 1 byte
|
||||
}
|
||||
if(read_so_far < eol_len) continue;
|
||||
if (string (reinterpret_cast<const char*>
|
||||
(buffer_ + read_so_far - eol_len), eol_len) == eol) {
|
||||
// EOL found
|
||||
@ -254,7 +219,7 @@ Serial::readlines (size_t size, string eol)
|
||||
size_t
|
||||
Serial::write (const string &data)
|
||||
{
|
||||
ScopedWriteLock lock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
return this->write_ (reinterpret_cast<const uint8_t*>(data.c_str()),
|
||||
data.length());
|
||||
}
|
||||
@ -262,14 +227,14 @@ Serial::write (const string &data)
|
||||
size_t
|
||||
Serial::write (const std::vector<uint8_t> &data)
|
||||
{
|
||||
ScopedWriteLock lock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
return this->write_ (&data[0], data.size());
|
||||
}
|
||||
|
||||
size_t
|
||||
Serial::write (const uint8_t *data, size_t size)
|
||||
{
|
||||
ScopedWriteLock lock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
return this->write_(data, size);
|
||||
}
|
||||
|
||||
@ -282,8 +247,8 @@ Serial::write_ (const uint8_t *data, size_t length)
|
||||
void
|
||||
Serial::setPort (const string &port)
|
||||
{
|
||||
ScopedReadLock rlock(this->pimpl_);
|
||||
ScopedWriteLock wlock(this->pimpl_);
|
||||
ScopedReadLock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
bool was_open = pimpl_->isOpen ();
|
||||
if (was_open) close();
|
||||
pimpl_->setPort (port);
|
||||
@ -369,21 +334,23 @@ Serial::getFlowcontrol () const
|
||||
|
||||
void Serial::flush ()
|
||||
{
|
||||
ScopedReadLock rlock(this->pimpl_);
|
||||
ScopedWriteLock wlock(this->pimpl_);
|
||||
ScopedReadLock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
pimpl_->flush ();
|
||||
read_cache_.clear ();
|
||||
}
|
||||
|
||||
void Serial::flushInput ()
|
||||
{
|
||||
ScopedReadLock lock(this->pimpl_);
|
||||
ScopedReadLock(this->pimpl_);
|
||||
pimpl_->flushInput ();
|
||||
}
|
||||
|
||||
void Serial::flushOutput ()
|
||||
{
|
||||
ScopedWriteLock lock(this->pimpl_);
|
||||
ScopedWriteLock(this->pimpl_);
|
||||
pimpl_->flushOutput ();
|
||||
read_cache_.clear ();
|
||||
}
|
||||
|
||||
void Serial::sendBreak (int duration)
|
||||
|
||||
9
stack.xml
Normal file
9
stack.xml
Normal file
@ -0,0 +1,9 @@
|
||||
<stack>
|
||||
<description brief="serial">serial</description>
|
||||
<author>Maintained by William Woodall</author>
|
||||
<license>BSD</license>
|
||||
<review status="unreviewed" notes=""/>
|
||||
<url>http://ros.org/wiki/serial</url>
|
||||
<depend stack="ros" />
|
||||
|
||||
</stack>
|
||||
@ -1,12 +0,0 @@
|
||||
if(UNIX)
|
||||
catkin_add_gtest(${PROJECT_NAME}-test unix_serial_tests.cc)
|
||||
target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
|
||||
if(NOT APPLE)
|
||||
target_link_libraries(${PROJECT_NAME}-test util)
|
||||
endif()
|
||||
|
||||
if(NOT APPLE) # these tests are unreliable on macOS
|
||||
catkin_add_gtest(${PROJECT_NAME}-test-timer unit/unix_timer_tests.cc)
|
||||
target_link_libraries(${PROJECT_NAME}-test-timer ${PROJECT_NAME})
|
||||
endif()
|
||||
endif()
|
||||
@ -20,6 +20,8 @@ void loop()
|
||||
#include <string>
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
// Use FRIEND_TEST... its not as nasty, thats what friends are for
|
||||
// // OMG this is so nasty...
|
||||
// #define private public
|
||||
@ -27,7 +29,7 @@ void loop()
|
||||
|
||||
#include "serial/serial.h"
|
||||
|
||||
#if defined(__linux__)
|
||||
#ifdef __linux__
|
||||
#include <pty.h>
|
||||
#else
|
||||
#include <util.h>
|
||||
@ -51,7 +53,7 @@ protected:
|
||||
ASSERT_TRUE(slave_fd > 0);
|
||||
ASSERT_TRUE(string(name).length() > 0);
|
||||
|
||||
port1 = new Serial(string(name), 115200, Timeout::simpleTimeout(250));
|
||||
port1 = new Serial(string(name), 115200, 250);
|
||||
}
|
||||
|
||||
virtual void TearDown() {
|
||||
@ -1,63 +0,0 @@
|
||||
#include "gtest/gtest.h"
|
||||
#include "serial/impl/unix.h"
|
||||
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
using serial::MillisecondTimer;
|
||||
|
||||
namespace {
|
||||
|
||||
/**
|
||||
* Do 100 trials of timing gaps between 0 and 19 milliseconds.
|
||||
* Expect accuracy within one millisecond.
|
||||
*/
|
||||
TEST(timer_tests, short_intervals) {
|
||||
for (int trial = 0; trial < 100; trial++)
|
||||
{
|
||||
uint32_t ms = rand() % 20;
|
||||
MillisecondTimer mt(ms);
|
||||
usleep(1000 * ms);
|
||||
int32_t r = mt.remaining();
|
||||
|
||||
// 1ms slush, for the cost of calling usleep.
|
||||
EXPECT_NEAR(r+1, 0, 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(timer_tests, overlapping_long_intervals) {
|
||||
MillisecondTimer* timers[10];
|
||||
|
||||
// Experimentally determined. Corresponds to the extra time taken by the loops,
|
||||
// the big usleep, and the test infrastructure itself.
|
||||
const int slush_factor = 14;
|
||||
|
||||
// Set up the timers to each time one second, 1ms apart.
|
||||
for (int t = 0; t < 10; t++)
|
||||
{
|
||||
timers[t] = new MillisecondTimer(1000);
|
||||
usleep(1000);
|
||||
}
|
||||
|
||||
// Check in on them after 500ms.
|
||||
usleep(500000);
|
||||
for (int t = 0; t < 10; t++)
|
||||
{
|
||||
EXPECT_NEAR(timers[t]->remaining(), 500 - slush_factor + t, 5);
|
||||
}
|
||||
|
||||
// Check in on them again after another 500ms and free them.
|
||||
usleep(500000);
|
||||
for (int t = 0; t < 10; t++)
|
||||
{
|
||||
EXPECT_NEAR(timers[t]->remaining(), -slush_factor + t, 5);
|
||||
delete timers[t];
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@ -1,147 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}</ProjectGuid>
|
||||
<RootNamespace>serial</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '14.0'">v140_xp</PlatformToolset>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '12.0'">v120_xp</PlatformToolset>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '11.0'">v110_xp</PlatformToolset>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup />
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
<Lib>
|
||||
<AdditionalDependencies>setupapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
</Lib>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
<Lib>
|
||||
<AdditionalDependencies>setupapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
</Lib>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
<Lib>
|
||||
<AdditionalDependencies>setupapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
</Lib>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
<Lib>
|
||||
<AdditionalDependencies>setupapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
</Lib>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\src\impl\list_ports\list_ports_win.cc" />
|
||||
<ClCompile Include="..\..\src\impl\win.cc" />
|
||||
<ClCompile Include="..\..\src\serial.cc" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\include\serial\impl\win.h" />
|
||||
<ClInclude Include="..\..\include\serial\serial.h" />
|
||||
<ClInclude Include="..\..\include\serial\v8stdint.h" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@ -1,39 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<Filter Include="Source Files">
|
||||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
|
||||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Header Files">
|
||||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
|
||||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Resource Files">
|
||||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
|
||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\src\serial.cc">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\src\impl\win.cc">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\src\impl\list_ports\list_ports_win.cc">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\include\serial\serial.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\include\serial\v8stdint.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\include\serial\impl\win.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@ -1,133 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}</ProjectGuid>
|
||||
<RootNamespace>test_serial</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '14.0'">v140_xp</PlatformToolset>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '12.0'">v120_xp</PlatformToolset>
|
||||
<PlatformToolset Condition="'$(PlatformToolset)' == '' and '$(VisualStudioVersion)' == '11.0'">v110_xp</PlatformToolset>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup />
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)..\..\include</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\examples\serial_example.cc" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\serial\serial.vcxproj">
|
||||
<Project>{a8517fb2-c74e-43bd-b3c6-b05d3fc11ecd}</Project>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<Filter Include="Source Files">
|
||||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
|
||||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Header Files">
|
||||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
|
||||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Resource Files">
|
||||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
|
||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\examples\serial_example.cc">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@ -1,36 +0,0 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 11.00
|
||||
# Visual Studio 2010
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "serial", "serial\serial.vcxproj", "{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_serial", "test_serial\test_serial.vcxproj", "{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Debug|x64 = Debug|x64
|
||||
Release|Win32 = Release|Win32
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Debug|x64.Build.0 = Debug|x64
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Release|Win32.Build.0 = Release|Win32
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Release|x64.ActiveCfg = Release|x64
|
||||
{A8517FB2-C74E-43BD-B3C6-B05D3FC11ECD}.Release|x64.Build.0 = Release|x64
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Debug|x64.Build.0 = Debug|x64
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Release|Win32.Build.0 = Release|Win32
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Release|x64.ActiveCfg = Release|x64
|
||||
{92EE7E58-C737-41F9-B795-9B6ACF6AB0B8}.Release|x64.Build.0 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
Loading…
x
Reference in New Issue
Block a user