About

This is a fork of the RXTX library with a focus on ease of use and embeddability in other libraries.

Some of the features we have added

A simplified serial port object called NRSerialPort. See below for an example.
Self-deployment of native libraries (all native code is stored inside the JAR and deployed at runtime). No more manual installation of native code.
Arm Cortex support (Gumstix).
Android (3.x or lower, requires a rooted phone to access the serial hardware).

This feature is depricated by changes in Android permissions moving forward with 4.x
Single Makefile compile which simplifies the compilation of project binaries.
Gradle support for JAR creation.
Removal of partially-implemented RXTX code to streamline the library for just serial port access.
Full Eclipse integration for testing application code against sources.
RFC 2217 support provided by incorporating the jvser library.
RS485 support for Linux

And a bunch of bug fixes

Fixed the memory access error that causes OS X to crash the JVM when serial.close() is called.
Fixed the Windows serial port zombie bind that prevents re-accessing serial ports when exiting on an exception.
Fixed erroneous printouts of native library mis-match.

Dependency Management

Maven Java 8 and Java 11+

    <dependency>
      <groupId>com.neuronrobotics</groupId>
      <artifactId>nrjavaserial</artifactId>
      <version>5.1.1</version>
    </dependency>

Building the JAR

Checkout the repository.

$ git clone https://github.com/NeuronRobotics/nrjavaserial.git

Build with Gradle.
```
$ cd nrjavaserial
$ ./gradlew build
```

The resulting JAR will be found in the build/libs/ directory.

Building the native libraries

The native libraries are written in C, and are built with Make. The source, including the master makefile, lives in src/main/c. The makefile in the project root will delegate to this makefile, and rebuild the JAR afterwards.

You'll also need a copy of the JNI development headers for your system. The easiest way to get these is to install a copy of the JDK. The headers are located in JAVA_HOME/include. The build process will attempt to automatically determine the location of your Java installation; however, to ensure a predictable build process, you should set the JAVA_HOME environment variable to the path of your Java installation directory.

# Install cross-compilation toolchains for all of the supported Linux
# architectures and Windows onto an amd64 Linux build host running
# Debian 10 or a modern derivative.
$ sudo make -C src/main/c crosstools

# Build both the 32- and 64-bit Windows binaries.
$ make windows

# Build Linux binaries for 32- and 64-bit x86, 32-bit ARMv5/v6/v7/v8,
# 64-bit ARMv8, and 32-bit PPC.
$ make linux

# Build only 32- or 64-bit x86 Linux binaries, respectively.
$ make linux32
$ make linux64

# Build binaries for all the supported ARM flavors.
$ make arm

# Build the PPC binaries.
$ make ppc

# Build 64-bit x86 macOS binaries. This requires a macOS build host.
$ make osx

# Build 32- and 64-bit x86 FreeBSD binaries, or just for 32/64-bit,
# respectively. This requires a FreeBSD build host.
$ make freebsd
$ make freebsd32
$ make freebsd64

Building on Windows

You'll need some installation of GCC. We recommend the TDM-GCC distribution of Mingw64-w64. Following its default installation process should result in its bin/ directory being added to your path; if you can pop open a command prompt and run x86_64-w64-mingw32-gcc, you're good to go.

Building on OS X

We're pretty big on maintaining backwards compatibility as far as reasonable. Our OS X natives target OS X 10.5, so to build them, you'll need an appropriate SDK installed. This StackOverflow answer provides pointers for getting the appropriate SDK installed.

How to use NRSerialPort objects

import gnu.io.NRSerialPort;
String port = "";
for(String s:NRSerialPort.getAvailableSerialPorts()){
    System.out.println("Availible port: "+s);
    port=s;
}

int baudRate = 115200;
NRSerialPort serial = new NRSerialPort(port, baudRate);
serial.connect();

DataInputStream ins = new DataInputStream(serial.getInputStream());
DataOutputStream outs = new DataOutputStream(serial.getOutputStream());
try{
    //while(ins.available()==0 && !Thread.interrupted());// wait for a byte
    while(!Thread.interrupted()) {// read all bytes
        if(ins.available()>0) {
            char b = ins.read();
            //outs.write((byte)b);
            System.out.print(b);
        }
            Thread.sleep(5);
    }
}catch(Exception ex){
    ex.printStackTrace();
}
serial.disconnect();

Contributors

Code Contributors

This project exists thanks to all the people who contribute. [Contribute].

Financial Contributors

Become a financial contributor and help us sustain our community. [Contribute]

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [Contribute]

NeuronRobotics / nrjavaserial

readme