#include <jni.h>
|
#include <string>
|
#include <termios.h>
|
#include <unistd.h>
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <fcntl.h>
|
#include <errno.h>
|
#include <android/log.h>
|
#include "include/gpiod.h"
|
|
#define TAG "SerialApp"
|
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, TAG, fmt, ##args)
|
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
|
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)
|
|
typedef struct comport_s
|
{
|
char devname[12];
|
unsigned int databit, parity, stopbit, flowctrl;
|
long baudrate;
|
|
int fd;
|
int frag_size;
|
}comport_t;
|
|
comport_t *comport;
|
|
// 将int类型的波特率转换成可以识别的波特率
|
static speed_t getBaudRate(int baudRate){
|
switch (baudRate) {
|
case 0:
|
return B0;
|
case 50:
|
return B50;
|
case 75:
|
return B75;
|
case 110:
|
return B110;
|
case 134:
|
return B134;
|
case 150:
|
return B150;
|
case 200:
|
return B200;
|
case 300:
|
return B300;
|
case 600:
|
return B600;
|
case 1200:
|
return B1200;
|
case 1800:
|
return B1800;
|
case 2400:
|
return B2400;
|
case 4800:
|
return B4800;
|
case 9600:
|
return B9600;
|
case 19200:
|
return B19200;
|
case 38400:
|
return B38400;
|
case 57600:
|
return B57600;
|
case 115200:
|
return B115200;
|
case 230400:
|
return B230400;
|
case 460800:
|
return B460800;
|
case 500000:
|
return B500000;
|
case 576000:
|
return B576000;
|
case 921600:
|
return B921600;
|
case 1000000:
|
return B1000000;
|
case 1152000:
|
return B1152000;
|
case 1500000:
|
return B1500000;
|
case 2000000:
|
return B2000000;
|
case 2500000:
|
return B2500000;
|
case 3000000:
|
return B3000000;
|
case 3500000:
|
return B3500000;
|
case 4000000:
|
return B4000000;
|
default:
|
return -1;
|
}
|
}
|
|
extern "C"
|
JNIEXPORT int JNICALL
|
Java_com_example_serial_RS485Control_openSerialPort(JNIEnv *env, jclass clazz, jstring path,
|
jlong baud_rate, jint data_bits, jint parity,
|
jint stop_bits, jint flow_control) {
|
// TODO: implement openSerialPort()
|
speed_t speed;
|
struct termios old_cfg, new_cfg;
|
int old_flags;
|
long temp;
|
|
comport = (comport_t *) malloc(sizeof(comport_t));
|
if (comport == NULL) {
|
LOGE("Failed to allocate memory for comport structure.");
|
return -1;
|
}
|
memset(comport, 0, sizeof(comport));
|
|
// mSend_len = max_len;
|
|
// 检查波特率是否合法
|
{
|
speed = getBaudRate(baud_rate);
|
if (speed == -1)
|
{
|
LOGE("Invalid buad rate");
|
return -1;
|
}
|
}
|
|
// 打开串口设备
|
{
|
jboolean iscopy;
|
// 获取String字符串path中的UTF8编码，并将其转换成C中的字符串
|
const char* devname = (*env).GetStringUTFChars(path, &iscopy);
|
LOGD("Opening serial port %s with flags 0x%x", devname, O_RDWR);
|
strncpy(comport->devname, devname, 12);
|
comport->baudrate = baud_rate;
|
comport->fd = -1;
|
comport->frag_size = 128;
|
comport->databit = data_bits;
|
comport->parity = parity;
|
comport->flowctrl = flow_control;
|
comport->stopbit = stop_bits;
|
|
if( !strstr(comport->devname, "tty") )
|
{
|
LOGE("Open Not a tty device \" %s\" \n", comport->devname);
|
return -2;
|
}
|
|
comport->fd = open(comport->devname, O_RDWR);
|
if ( comport->fd < 0 )
|
{
|
if( strstr(strerror(errno), "Permission denied") != nullptr )
|
return 1;
|
LOGE("open port failed:%s\n", strerror(errno));
|
return -3;
|
}
|
LOGD("Open device %s", comport->devname);
|
// 释放JNI字符串的UTF8编码
|
(*env).ReleaseStringUTFChars(path, devname);
|
|
if( (-1 != (old_flags = fcntl(comport->fd, F_GETFL, 0))) && (-1 != fcntl(comport->fd, F_SETFL, old_flags & ~O_NONBLOCK)))
|
{
|
if(-1 == tcflush(comport->fd, TCIOFLUSH))
|
{
|
LOGE("open port failed:%s\n", strerror(errno));
|
return -4;
|
}
|
}
|
else
|
{
|
LOGE("open port failed:%s\n", strerror(errno));
|
return -5;
|
}
|
|
if ( 0 != tcgetattr(comport->fd, &old_cfg))
|
{
|
LOGE("open port failed:%s\n", strerror(errno));
|
return -6;
|
}
|
}
|
|
{
|
LOGD("starting configuring serial port");
|
|
old_cfg.c_cflag &= ~CSIZE;
|
old_cfg.c_lflag &= ~ICANON;
|
old_cfg.c_lflag &= ~ECHO;
|
old_cfg.c_lflag &= ~ECHOE;
|
old_cfg.c_lflag &= ~ECHONL;
|
old_cfg.c_lflag &= ~ISIG;
|
old_cfg.c_iflag &= ~(IXON | IXOFF | IXANY);
|
old_cfg.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);
|
old_cfg.c_oflag &= ~OPOST;
|
old_cfg.c_oflag &= ~ONLCR;
|
old_cfg.c_cflag |= CREAD | CLOCAL;
|
|
switch (comport->databit)
|
{
|
case 7:
|
old_cfg.c_cflag |= CS7;
|
break;
|
case 6:
|
old_cfg.c_cflag |= CS6;
|
break;
|
case 5:
|
old_cfg.c_cflag |= CS5;
|
break;
|
case 8:
|
old_cfg.c_cflag |= CS8;
|
break;
|
}
|
|
switch(comport->parity)
|
{
|
case 1:
|
old_cfg.c_cflag |= (PARENB | PARODD);
|
old_cfg.c_cflag |= (INPCK | ISTRIP);
|
break;
|
case 2:
|
old_cfg.c_cflag |= PARENB;
|
old_cfg.c_cflag &= ~PARODD;
|
old_cfg.c_cflag |= (INPCK | ISTRIP);
|
break;
|
case 0:
|
old_cfg.c_cflag &= ~PARENB;
|
break;
|
}
|
|
if(1 != comport->stopbit)
|
{
|
old_cfg.c_cflag |= CSTOPB;
|
}
|
else
|
{
|
old_cfg.c_cflag &= ~CSTOPB;
|
}
|
|
// set flow control
|
// 1: software control; 2:hardware control; 0: none
|
switch(comport->flowctrl)
|
{
|
case 1:
|
old_cfg.c_cflag &= ~(CRTSCTS);
|
old_cfg.c_iflag |= (IXON | IXOFF);
|
break;
|
case 2:
|
old_cfg.c_cflag |= CRTSCTS;
|
old_cfg.c_iflag &= ~(IXON | IXOFF);
|
break;
|
case 0:
|
old_cfg.c_cflag &= ~(CRTSCTS);
|
break;
|
}
|
|
|
// set baudRate
|
cfsetispeed(&old_cfg, speed);
|
cfsetospeed(&old_cfg, speed);
|
|
new_cfg.c_cc[VMIN] = 10;
|
new_cfg.c_cc[VTIME] = 0;
|
|
|
// 将设置的串口参数应用到串口上，TCSANOW表示立即生效，（TCSADRAIN：在所有输出都被传输后生效；TCSAFLUSH：在所有输出都被传输后生效，同时丢弃所有未读取的输入）
|
if(tcsetattr(comport->fd, TCSANOW, &old_cfg))
|
{
|
LOGE("tcsetattr() failed:%s", strerror(errno));
|
close(comport->fd);
|
return -1;
|
}
|
LOGD("Connected device \" %s \" successfully\n", comport->devname);
|
LOGD("port:%s, databit:%d, stopbit:%d, parity:%d, flowctl:%d", comport->devname, comport->databit, comport->stopbit, comport->parity, comport->flowctrl);
|
}
|
return 0;
|
}
|
extern "C"
|
JNIEXPORT int JNICALL
|
Java_com_example_serial_RS485Control_closeSerialPort(JNIEnv *env, jclass clazz) {
|
// TODO: implement closeSerialPort()
|
if ( !comport )
|
{
|
LOGE("%s() get invalid input arguments.\n", __FUNCTION__ );
|
return -1;
|
}
|
|
if (comport->fd >= 0)
|
{
|
close(comport->fd);
|
LOGD("close device \" %s \" successfully\n", comport->devname);
|
}
|
comport->fd = -1;
|
free(comport);
|
comport = NULL;
|
return 0;
|
}
|
extern "C"
|
JNIEXPORT jint JNICALL
|
Java_com_example_serial_RS485Control_sendToPort(JNIEnv *env, jclass clazz, jstring msg, jint len) {
|
// TODO: implement sendToPort()
|
// msg: 表示发送的数据；len: 发送的长度
|
int rv;
|
char *ptr, left_bytes;
|
int send = 0;
|
const char *sendMsg = env->GetStringUTFChars(msg, 0);
|
if ( sendMsg == nullptr )
|
{
|
return -1;
|
}
|
|
if( !comport || !msg || len <= 0 )
|
{
|
LOGE("Invalid parameter.\n");
|
return -1;
|
}
|
if (comport->fd == -1)
|
{
|
LOGE("Serail not connected.\n");
|
return -2;
|
}
|
|
left_bytes = len;
|
ptr = (char *)sendMsg;
|
|
while( left_bytes > 0 )
|
{
|
/* Large data, then slice them to frag and send */
|
send = left_bytes>comport->frag_size ? comport->frag_size : left_bytes;
|
|
rv = write(comport->fd, ptr, send);
|
if( rv<0 )
|
{
|
return -4;
|
}
|
|
left_bytes -= rv;
|
ptr += rv;
|
}
|
LOGD("send %s successfully\n", sendMsg);
|
|
env->ReleaseStringUTFChars(msg, sendMsg);
|
return rv;
|
}
|
|
|
extern "C"
|
JNIEXPORT jstring JNICALL
|
Java_com_example_serial_RS485Control_recvFromPort(JNIEnv *env, jclass clazz, jint len, jint timeout) {
|
int rv = 0;
|
int iRet;
|
fd_set rdfds, exfds;
|
struct timeval stTime;
|
|
jstring result;
|
char nativeMsg[len];
|
memset(nativeMsg, 0, len);
|
|
if( !comport || len <= 0 )
|
{
|
LOGE("Invalid parameter.\n");
|
return nullptr;
|
}
|
if (comport->fd == -1)
|
{
|
LOGE("Serail not connected.\n");
|
return nullptr;
|
}
|
|
FD_ZERO(&rdfds);
|
FD_ZERO(&exfds);
|
FD_SET(comport->fd, &rdfds);
|
FD_SET(comport->fd, &exfds);
|
|
if (0xFFFFFFFF != timeout)
|
{
|
stTime.tv_sec = (time_t) (timeout / 1000);
|
stTime.tv_usec = (long)(1000 * (timeout % 1000));
|
|
iRet = select(comport->fd + 1, &rdfds, 0, &exfds, &stTime);
|
if (0 == iRet)
|
{
|
return nullptr;
|
}
|
else if (0 < iRet)
|
{
|
if (0 != FD_ISSET(comport->fd, &exfds))
|
{
|
LOGE("Error checking recv status.\n");
|
return nullptr;
|
}
|
|
if (0 == FD_ISSET(comport->fd, &rdfds))
|
{
|
LOGE("No incoming data.\n");
|
return nullptr;
|
}
|
}
|
else
|
{
|
if (EINTR == errno)
|
{
|
LOGE("catch interrupt signal.\n");
|
// rv = 0;
|
}
|
else
|
{
|
LOGE("Check recv status failure.\n");
|
// rv = -7;
|
}
|
return nullptr;
|
}
|
}
|
|
usleep(10000); /* sleep for 10ms for data incoming */
|
|
// Get data from Com port
|
iRet = read(comport->fd, nativeMsg, len);
|
if (0 > iRet)
|
{
|
if (EINTR == errno)
|
rv = 0; // Interrupted signal catched
|
else
|
rv = -3; // Failed to read comport
|
|
return nullptr;
|
}
|
LOGD("Receive {%s} successfully\n", nativeMsg);
|
|
return env->NewStringUTF(nativeMsg);
|
}
|
|
extern "C"
|
JNIEXPORT jstring JNICALL
|
Java_com_example_serial_RS485Control_saveToFile(JNIEnv *env, jclass clazz, jstring msg, jint len,
|
jstring file_name) {
|
// TODO: implement saveToFile()
|
int mFd = -1;
|
int rv;
|
mFd = open("dev/log.txt", O_CREAT | O_RDWR | O_APPEND, 0666);
|
rv = write(mFd, msg, len);
|
if (rv < 0) {
|
LOGE("Save data to file failed:%s\n" , strerror(errno));
|
return nullptr;
|
}
|
LOGD("save received data into file successfully!\n");
|
char buf[1024];
|
rv = read(mFd, buf, len);
|
if (rv < 0) {
|
LOGE("Read data failed:%s\n" , strerror(errno));
|
return nullptr;
|
}
|
strcat(reinterpret_cast<char *>(buf), "file");
|
close(mFd);
|
return reinterpret_cast<jstring>(buf);
|
}
|
|
// RS485是半双工通信的，由GPIO的高低电平来控制其是接收状态还是发送状态
|
// 0: 接收（默认）；1：发送
|
// 切换状态成功返回0，失败返回-1
|
extern "C"
|
JNIEXPORT jint JNICALL
|
Java_com_example_serial_RS485Control_changeState(JNIEnv *env, jclass clazz, jint state) {
|
// TODO: implement changeState()
|
struct gpiod_chip *chip;
|
struct gpiod_line *line;
|
const char *chipname = "gpiochip4";
|
int rv = 0;
|
int gpio = 26;
|
|
|
chip = gpiod_chip_open_by_name(chipname);
|
if( !chip )
|
{
|
LOGE("Gpio open '%s' failed:%s\n", chipname, strerror(errno));
|
return -1;
|
}
|
|
line = gpiod_chip_get_line(chip, gpio);
|
if ( !line )
|
{
|
LOGE("Get gpio[%d] failed:%s\n", gpio, strerror(errno));
|
rv = -1;
|
goto Cleanup;
|
}
|
|
rv = gpiod_line_is_used(line);
|
if( rv )
|
{
|
LOGE("GPIO[%d] is used\n", gpio);
|
rv = -1;
|
goto Cleanup;
|
}
|
|
rv = gpiod_line_request_output(line, "rs485", 0);
|
if ( rv < 0 )
|
{
|
LOGE("Set GPIO[%d] as output failed:%s\n", gpio, strerror(errno));
|
rv = -1;
|
goto Cleanup;
|
}
|
|
rv = gpiod_line_set_value(line, state);
|
if ( rv < 0 )
|
{
|
LOGE("Set GPIO[%d]'s value failed:%s\n", gpio, strerror(errno));
|
rv = -1;
|
goto Cleanup;
|
}
|
LOGD("Set GPIO[%d]'s value as %d successfully\n", gpio, state);
|
rv = 0;
|
|
Cleanup:
|
gpiod_line_release(line);
|
gpiod_chip_close(chip);
|
return rv;
|
}
|
