introduction Recently, I have been working on controlling motors on an Android development board, and all of them are connected and communicated through the serial port. After getting to know the serial port, I found that it can really do a lot of interesting things. Many hardware devices can communicate through the serial port, such as printers, ATM card dispensers, IC/ID card readers, etc., as well as IoT-related devices; 1. Introduction to Serial Port Serial interface is referred to as serial port, also known as serial communication interface or serial communication interface (usually refers to COM interface), which is an expansion interface using serial communication mode; Serial interface refers to the sequential transmission of data one bit at a time. Its characteristics are simple communication lines, and two-way communication can be achieved with only one pair of transmission lines (telephone lines can be directly used as transmission lines), which greatly reduces the cost and is particularly suitable for long-distance communication, but the transmission speed is slow; 1. Serial port-baud rate The serial port transmission rate is used to measure the speed of data transmission, that is, the number of times the carrier parameters change per unit time. For example, 240 characters are transmitted per second, and each character format contains 10 bits (1 start bit, 1 stop bit, 8 data bits). At this time, the baud rate is 240Bd, and the bit rate is 10 bits * 240 per second = 2400bps. The baud rate is inversely proportional to the distance. The higher the baud rate, the shorter the transmission distance. 2.Serial port-data bit This is a parameter that measures the actual data bits in the communication. When a computer sends a packet of information, the actual data is often not 8 bits, and the standard values are 6, 7, and 8 bits. How to set it depends on the information you want to transmit; 3.Serial port-stop bit Used to indicate the last bit of a single packet. Typical values are 1, 1.5, and 2 bits. Since data is timed on the transmission line, and each device has its own clock, it is possible that a small amount of desynchronization occurs between the two devices during communication. Therefore, the stop bit not only indicates the end of the transmission, but also provides an opportunity for the computer to correct the clock synchronization. The more bits applied to the stop bit, the greater the tolerance for different clock synchronization, but the data transmission rate is also slower; 4.Serial port-check digit A simple error detection method in serial communication. There are four error detection methods: even, odd, high and low. Of course, no check bit is also possible. For even and odd check, the serial port will set the check bit (the bit after the data bit) with a value to ensure that the transmitted data has an even or odd number of logical high bits; 5. Serial port address The serial port addresses of different operating systems. Android is based on Linux, so the serial port address of devices using the Android system is generally /dev/ttyS0; - What are the serial ports in the /dev directory?
- /dev serial ports include: virtual serial port, real serial port, USB to serial port
- Real serial port: /dev/tty0..tty1 This is usually the machine's built-in COM port
- Virtual serial port: /dev/ttyS1...ttyS2...ttyS3...are all virtual consoles, which can also be used as input and output ports
- USB to serial port: /dev/tty/USB0
2. Android serial port implementation The serial communication is the same as the communication between the server and the server, which is to pass some parameters and then return some data. However, the serial port communication pipes these parameters as instructions, and these instructions are determined by the hardware communication protocol. Different communication protocols naturally have different instructions. The device documentation describes the corresponding protocol parameters, such as motor angle, motor speed, motor reset, current motor angle, etc. A quick way to use the serial port on Android is to directly apply Google's official serial port demo code (android-serialport-api), which can basically handle many scenarios of using serial ports on Android devices; This time, I will introduce the open source library com.github.licheedev:Android-SerialPort-API:2.0.0 used in the project 1. Add the following dependencies to dependencies in build.gradle: dependencies {
// Serial port
implementation 'com.github.licheedev:Android-SerialPort-API:2.0.0'
}
Add the following Maven repository to allprojects in build.gradle in Project
allprojects {
repositories {
maven { url "https://jitpack.io" } // maven repository
}
} 2.Serial port processing encapsulation import android .serialport .SerialPort ;
import android .util .Log ;
import java .io .BufferedInputStream ;
import java .io .File ;
import java .io .IOException ;
import java .io .InputStream ;
import java .io .OutputStream ;
import java .util .concurrent .ScheduledFuture ;
import java .util .concurrent .TimeUnit ;
public class SerialHandleUtils implements Runnable {
private static final String TAG = "Serial port processing class" ;
private String path = "" ; // Serial port address
private SerialPort mSerialPort ; // Serial port object
private InputStream mInputStream ; // Serial port input stream object
private BufferedInputStream mBuffInputStream ; // Used to monitor the information returned by the hardware
private OutputStream mOutputStream ; // Serial port output stream object is used to send instructions
private SerialMonitor serialInter ; // Serial port callback interface
private ScheduledFuture readTask ; // Serial port reading task
public void addSerialInter ( SerialMonitor serialInter ) {
this .serialInter = serialInter ;
}
public boolean open ( String devicePath , int baudrate , boolean isRead ) {
return open ( devicePath , baudrate , 7 , 1 , 2 , isRead ) ;
}
public boolean open ( String devicePath , int baudrate , int dataBits , int stopBits , int parity , boolean isRead ) {
boolean isSucc = false ;
try {
if ( mSerialPort != null ) close ( ) ;
File device = new File ( devicePath ) ;
mSerialPort = SerialPort // Serial port object
.newBuilder ( device , baudrate ) // serial port address, baud rate
.dataBits ( dataBits ) // data bits , default 8; optional values are 5 ~ 8
.stopBits ( stopBits ) // Stop bit, default 1; 1 : 1 stop bit; 2 : 2 stop bits
.parity ( parity ) // check digit; 0 : no check digit ( NONE, default ) ; 1 : odd check digit ( ODD ) ; 2 : even check digit ( EVEN )
.build ( ) ; // Open the serial port and return
mInputStream = mSerialPort .getInputStream ( ) ;
mBuffInputStream = new BufferedInputStream ( mInputStream ) ;
mOutputStream = mSerialPort .getOutputStream ( ) ;
isSucc = true ;
path = devicePath ;
if ( isRead ) readData ( ) ; // Enable recognition
} catch ( Throwable tr ) {
close ( ) ;
isSucc = false ;
finally
return isSucc ;
}
}
// Read data
private void readData ( ) {
if ( readTask != null ) {
readTask .cancel ( true ) ;
try {
Thread.sleep ( 160 ) ;
} catch ( InterruptedException e ) {
e .printStackTrace ( ) ;
}
// Sleep here: When the task is canceled, the thread pool has already executed the task and cannot be canceled, so wait for the thread pool's task to be completed
readTask = null ;
}
readTask = SerialManage
.getInstance ( )
.getScheduledExecutor ( ) // Get the thread pool
.scheduleAtFixedRate ( this , 0 , 150 , TimeUnit .MILLISECONDS ) ; // Execute a cyclic task
}
@Override // A run is triggered every 150 milliseconds
public void run ( ) {
if ( Thread .currentThread ( ) .isInterrupted ( ) ) return ;
try {
int available = mBuffInputStream .available ( ) ;
if ( available == 0 ) return ;
byte [ ] received = new byte [ 1024 ] ;
int size = mBuffInputStream .read ( received ) ; // Read the following serial port to see if there is new data
if ( size > 0 && serialInter != null ) serialInter .readData ( path , received , size ) ;
} catch ( IOException e ) {
Log .e ( TAG , "Serial port data reading exception: " + e .toString ( ) ) ;
}
}
public void close ( ) {
try {
if ( mInputStream != null ) mInputStream .close ( ) ;
} catch ( Exception e ) {
Log .e ( TAG , "Serial port input stream object closed abnormally: " + e .toString ( ) ) ;
}
try {
if ( mOutputStream != null ) mOutputStream .close ( ) ;
} catch ( Exception e ) {
Log .e ( TAG , "Serial port output stream object closed abnormally: " + e .toString ( ) ) ;
}
try {
if ( mSerialPort != null ) mSerialPort .close ( ) ;
mSerialPort = null ;
} catch ( Exception e ) {
Log .e ( TAG , "Serial port object closing exception: " + e .toString ( ) ) ;
}
}
public void send ( final String msg ) {
byte [ ] bytes = hexStr2bytes ( msg ) ; // Convert characters to byte array
try {
mOutputStream .write ( bytes ) ; // Write data through the output stream
} catch ( Exception e ) {
e .printStackTrace ( ) ;
}
}
private byte [ ] hexStr2bytes ( String hex ) {
int len = ( hex .length ( ) / 2 ) ;
byte [ ] result = new byte [ len ] ;
char [ ] achar = hex .toUpperCase ( ) .toCharArray ( ) ;
for ( int i = 0 ; i < len ; i ++ ) {
int pos = i * 2 ;
result [ i ] = ( byte ) ( hexChar2byte ( achar [ pos ] ) << 4 | hexChar2byte ( achar [ pos + 1 ] ) ) ;
}
return result ;
}
private static int hexChar2byte ( char c ) {
switch ( c ) {
case '0' :
return 0 ;
case '1' :
return 1 ;
case '2' :
return 2 ;
case '3' :
return 3 ;
case '4' :
return 4 ;
case '5' :
return 5 ;
case '6' :
return 6 ;
case '7' :
return 7 ;
case '8' :
return 8 ;
case '9' :
return 9 ;
case 'a' :
case 'A' :
return 10 ;
case 'b' :
case 'B' :
return 11 ;
case 'c' :
case 'C' :
return 12 ;
case 'd' :
case 'D' :
return 13 ;
case 'e' :
case 'E' :
return 14 ;
case 'f' :
case 'F' :
return 15 ;
default :
return - 1 ;
}
}
} 3. Serial port callback SerialMonitor; To briefly summarize this class, it returns the results generated in the SerialHandle class to the business code of the upper layer.
public interface SerialMonitor {
void connectMsg ( String path , boolean isSucc ) ;
void readData ( String path , byte [ ] bytes , int size ) ;
} 4. Serial port unified management SerialManage; import androidx .appcompat .app .AppCompatActivity ;
import android .os .Bundle ;
import android .util .Log ;
import android .view .View ;
public class MainActivity extends AppCompatActivity implements SerialMonitor {
@Override
protected void onCreate ( Bundle savedInstanceState ) {
super .onCreate ( savedInstanceState ) ;
setContentView ( R .layout .activity_main ) ;
SerialManage .getInstance ( ) .init ( this ) ; // Serial port initialization
SerialManage .getInstance ( ) .open ( ) ; // Open the serial port
findViewById ( R .id .send_but ) .setOnClickListener ( new View .OnClickListener ( ) {
@Override
public void onClick ( View view ) {
SerialManage .getInstance ( ) .send ( "Z" ) ; // Send command Z
}
} ) ;
}
@Override
public void connectMsg ( String path , boolean isSucc ) {
String msg = isSucc ? "Success" : "Failure" ;
Log .e ( "serial port connection callback" , "serial port" + path + "-connection" + msg ) ;
}
@Override // If false is passed in the serial port opening method, no data will be returned here
public void readData ( String path , byte [ ] bytes , int size ) {
// Log .e ( "serial port data callback" , "serial port" + path + "-get data" + bytes ) ;
}
} 5. Use the serial port import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
public class MainActivity extends AppCompatActivity implements SerialMonitor {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
SerialManage.getInstance().init(this); //Serial port initialization
SerialManage.getInstance().open(); //Open the serial port
findViewById(R.id.send_but).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
SerialManage.getInstance().send("Z"); //Send command Z
}
});
}
@Override
public void connectMsg(String path, boolean isSucc) {
String msg = isSucc ? "Success" : "Failure";
Log.e("Serial port connection callback", "Serial port" + path + " -connection" + msg);
}
@Override // If false is passed in the serial port opening method, no data will be returned here
public void readData(String path, byte[] bytes, int size) {
// Log.e("Serial port data callback","Serial port" + path + " - get data" + bytes);
}
} 6. Common serial port bases and base tools The conversion between bases and bases, bases and bytes is common in development, such as hexadecimal to decimal, byte array to hexadecimal string, etc. public class DataConversionUtils {
public static int isOdd ( int num ) {
return num & 0x1 ;
}
public static byte intToByte ( int number ) {
return hexToByte ( intToHex ( number ) ) ;
}
public static String intToHex ( int number ) {
String st = Integer .toHexString ( number ) .toUpperCase ( ) ;
return String .format ( "%2s" , st ) .replaceAll ( " " , "0" ) ;
}
public static int byteToDec ( byte b ) {
String s = byteToHex ( b ) ;
return ( int ) hexToDec ( s ) ;
}
public static int bytesToDec ( byte [ ] bytes ) {
String s = encodeHexString ( bytes ) ;
return ( int ) hexToDec ( s ) ;
}
public static int hexToInt ( String inHex ) {
return Integer .parseInt ( inHex , 16 ) ;
}
public static String byteToHex ( byte num ) {
char [ ] hexDigits = new char [ 2 ] ;
hexDigits [ 0 ] = Character .forDigit ( ( num >> 4 ) & 0xF , 16 ) ;
hexDigits [ 1 ] = Character .forDigit ( ( num & 0xF ) , 16 ) ;
return new String ( hexDigits ) .toUpperCase ( ) ;
}
public static byte hexToByte ( String hexString ) {
int firstDigit = toDigit ( hexString .charAt ( 0 ) ) ;
int secondDigit = toDigit ( hexString .charAt ( 1 ) ) ;
return ( byte ) ( ( firstDigit << 4 ) + secondDigit ) ;
}
private static int toDigit ( char hexChar ) {
int digit = Character .digit ( hexChar , 16 ) ;
if ( digit == - 1 ) {
throw new IllegalArgumentException (
"Invalid Hexadecimal Character: " + hexChar ) ;
}
return digit ;
}
public static String encodeHexString ( byte [ ] byteArray ) {
StringBuffer hexStringBuffer = new StringBuffer ( ) ;
for ( int i = 0 ; i < byteArray .length ; i ++ ) {
hexStringBuffer .append ( byteToHex ( byteArray [ i ] ) ) ;
}
return hexStringBuffer .toString ( ) .toUpperCase ( ) ;
}
public static byte [ ] decodeHexString ( String hexString ) {
if ( hexString .length ( ) % 2 == 1 ) {
throw new IllegalArgumentException (
"Invalid hexadecimal String supplied." ) ;
}
byte [ ] bytes = new byte [ hexString .length ( ) / 2 ] ;
for ( int i = 0 ; i < hexString .length ( ) ; i += 2 ) {
bytes [ i / 2 ] = hexToByte ( hexString .substring ( i , i + 2 ) ) ;
}
return bytes ;
}
public static String decToHex ( int dec ) {
String hex = Integer .toHexString ( dec ) ;
if ( hex .length ( ) == 1 ) {
hex = '0' + hex ;
}
return hex .toLowerCase ( ) ;
}
public static long hexToDec ( String hex ) {
return Long .parseLong ( hex , 16 ) ;
}
public static String setCardNum ( String cardNun ) {
String cardNo1 = cardNun ;
String cardNo = null ;
if ( cardNo1 != null ) {
Long cardNo2 = Long .parseLong ( cardNo1 , 16 ) ;
// cardNo = String .format ( "%015d" , cardNo2 ) ;
cardNo = String .valueOf ( cardNo2 ) ;
}
return cardNo ;
}
} Summarize Serial communication uses processes, Linux instructions, JNI..., but looking beyond the phenomenon to the essence, the ultimate goal is to obtain an input and output stream for reading and writing operations; For Android developers, serial communication only requires them to focus on how to connect, operate (send commands), and read data. |
