#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 *adc_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;
|
}
|
}
|
|
unsigned short crc_modbus(unsigned char *ptr, int len)
|
{
|
unsigned int i;
|
unsigned short crc = 0xFFFF; //crc16位寄存器初始值
|
|
while(len--)
|
{
|
crc ^= *ptr++;
|
for (i = 0; i < 8; ++i)
|
{
|
if (crc & 1)
|
crc = (crc >> 1) ^ 0xA001; //多项式 POLY（0x8005)的高低位交换值，这是由于其模型的一>些参数决定的
|
else
|
crc = (crc >> 1);
|
}
|
}
|
|
return crc;
|
}
|
|
void calculate(char *result, unsigned char *data, int len)
|
{
|
int i = 0;
|
unsigned char temp[6];
|
char info[8];
|
for(i=0; i<len; i++)
|
{
|
if(data[i] == 0xAA && data[i+1] == 0x55)
|
{
|
memset(temp, 0, sizeof(temp));
|
if( (data[i+2] == 0x01 || data[i+2] == 0x02) && \
|
(data[i+3] >= 0x00 && data[i+3] <= 0x03))
|
{
|
// temp用于进行CRC校验
|
temp[0] = data[i];
|
temp[1] = data[i+1];
|
temp[2] = data[i+2];
|
temp[3] = data[i+3];
|
temp[4] = data[i+4];
|
temp[5] = data[i+5];
|
//CRC,if right continue, else break.
|
uint16_t crc = crc_modbus(temp, 6);
|
printf("received buffer crc = %04X\n", crc);
|
if(data[i+6] != (crc&0xFF) || data[i+7] != ((crc>>8)&0xFF))
|
{
|
LOGE("read failed: CRC failure. received CRC: %02X %02X, calculated CRC:%02X %02X\n", \
|
temp[4], temp[5], (crc&0xFF), ((crc>>8)&0xFF));
|
continue ;
|
}
|
|
// calculate 43 02 ==> 0243
|
memset(info, 0, sizeof(info));
|
snprintf(info, sizeof(info), "%02x%02x", data[i+5], data[i+4]);
|
int length = sizeof(info) / sizeof(info[0]);
|
long long sum = 0;
|
printf("info=%s\n", info);
|
for(int j=0; j<strlen(info); j++)
|
{
|
char a = info[j];
|
if(a >= '0' && a <= '9')
|
a = a - '0';
|
else if(a >= 'A' && a <= 'F')
|
a = a - 'A' + 10;
|
else if(a >= 'a' && a <= 'f')
|
a = a - 'a' + 10;
|
int n = a << (4*(3-j));
|
sum += n;
|
}
|
|
char temp_res[350];
|
memset(temp_res, 0, sizeof(temp_res));
|
if(data[i+2] == 0x01)
|
{
|
strcat(result, "电流-");
|
snprintf(temp_res, sizeof(temp_res), "通道%d=%.2fmA ", data[i+3], (double)sum*0.01);
|
}
|
else if(data[i+2] == 0x02)
|
{
|
strcat(result, "电压-");
|
snprintf(temp_res, sizeof(temp_res), "通道%d=%.3fV ", data[i+3], (double)sum*0.001);
|
}
|
strcat(result, temp_res);
|
}
|
}
|
}
|
}
|
|
extern "C"
|
JNIEXPORT jint JNICALL
|
Java_com_example_serial_AdcControl_openComport(JNIEnv *env, jclass clazz, jstring path,
|
jlong baud_rate, jint data_bits, jint parity,
|
jint stop_bits, jint flow_control) {
|
// TODO: implement openComport()
|
speed_t speed;
|
struct termios old_cfg, new_cfg;
|
int old_flags;
|
long temp;
|
|
adc_comport = (comport_t *) malloc(sizeof(comport_t));
|
if (adc_comport == NULL) {
|
LOGE("Failed to allocate memory for comport structure.");
|
return -1;
|
}
|
memset(adc_comport, 0, sizeof(adc_comport));
|
|
// 检查波特率是否合法
|
{
|
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(adc_comport->devname, devname, 12);
|
adc_comport->baudrate = baud_rate;
|
adc_comport->fd = -1;
|
adc_comport->frag_size = 128;
|
adc_comport->databit = data_bits;
|
adc_comport->parity = parity;
|
adc_comport->flowctrl = flow_control;
|
adc_comport->stopbit = stop_bits;
|
|
if( !strstr(adc_comport->devname, "tty") )
|
{
|
LOGE("Open Not a tty device \" %s\" \n", adc_comport->devname);
|
return -2;
|
}
|
|
adc_comport->fd = open(adc_comport->devname, O_RDWR);
|
if ( adc_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", adc_comport->devname);
|
// 释放JNI字符串的UTF8编码
|
(*env).ReleaseStringUTFChars(path, devname);
|
|
if ( 0 != tcgetattr(adc_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_cflag |= CREAD | CLOCAL;
|
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;
|
|
|
switch (adc_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(adc_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 != adc_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(adc_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);
|
|
old_cfg.c_cc[VTIME] = 10;
|
old_cfg.c_cc[VMIN] = 0;
|
|
|
// 将设置的串口参数应用到串口上，TCSANOW表示立即生效，（TCSADRAIN：在所有输出都被传输后生效；TCSAFLUSH：在所有输出都被传输后生效，同时丢弃所有未读取的输入）
|
if(tcsetattr(adc_comport->fd, TCSANOW, &old_cfg))
|
{
|
LOGE("tcsetattr() failed:%s", strerror(errno));
|
close(adc_comport->fd);
|
return -1;
|
}
|
LOGD("Connected device \" %s \" successfully\n", adc_comport->devname);
|
LOGD("port:%s, databit:%d, stopbit:%d, parity:%d, flowctl:%d", adc_comport->devname, adc_comport->databit, adc_comport->stopbit, adc_comport->parity, adc_comport->flowctrl);
|
}
|
|
return 0;
|
}
|
extern "C"
|
JNIEXPORT jint JNICALL
|
Java_com_example_serial_AdcControl_closeComport(JNIEnv *env, jclass clazz) {
|
// TODO: implement closeadc_comport()
|
if ( !adc_comport )
|
{
|
LOGE("%s() get invalid input arguments.\n", __FUNCTION__ );
|
return -1;
|
}
|
|
if (adc_comport->fd >= 0)
|
{
|
close(adc_comport->fd);
|
LOGD("close device \" %s \" successfully\n", adc_comport->devname);
|
}
|
adc_comport->fd = -1;
|
free(adc_comport);
|
adc_comport = NULL;
|
return 0;
|
}
|
extern "C"
|
JNIEXPORT jint JNICALL
|
Java_com_example_serial_AdcControl_sendToPort(JNIEnv *env, jclass clazz, jstring operate,
|
jstring channel) {
|
// TODO: implement sendToPort()
|
char *operator_native;
|
char *channel_native;
|
unsigned char data[6] = {0xAA, 0x55};
|
int len = 2; //data的长度
|
int rv = -1;
|
int i;
|
unsigned int byte;
|
|
operator_native = (char *)env->GetStringUTFChars(operate, 0);
|
channel_native = (char *)env->GetStringUTFChars(channel, 0);
|
if(!operator_native || !channel_native)
|
{
|
LOGE("Invalid parameters\n");
|
return -1;
|
}
|
|
sscanf(operator_native, "%02X", &byte);
|
data[len++] = (unsigned char)byte;
|
|
sscanf(channel_native, "%02X", &byte);
|
data[len++] = (unsigned char)byte;
|
|
// 计算CRC16-MODBUS校验码
|
uint16_t crc = crc_modbus(data, len);
|
data[len++] = crc & 0xFF;
|
data[len++] = (crc >> 8) & 0xFF;
|
|
rv = write(adc_comport->fd, data, len);
|
if(rv < 0)
|
{
|
LOGE("write can data failed:%s", strerror(errno));
|
close(adc_comport->fd);
|
return -2;
|
}
|
LOGD("write %d bytes can data success", rv);
|
for(i = 0; i < rv; i++)
|
{
|
LOGD("%02X ", data[i]);
|
}
|
|
(*env).ReleaseStringUTFChars(operate, operator_native);
|
(*env).ReleaseStringUTFChars(channel, channel_native);
|
return 0;
|
}
|
|
extern "C"
|
JNIEXPORT jstring JNICALL
|
Java_com_example_serial_AdcControl_recvFromPort(JNIEnv *env, jclass clazz, jint len, jint timeout) {
|
// TODO: implement recvFromPort()
|
int rv = 0;
|
int iRet;
|
fd_set rdfds, exfds;
|
struct timeval stTime;
|
unsigned char nativeMsg[len];
|
|
memset(nativeMsg, 0, len);
|
|
if( !adc_comport || len <= 0 )
|
{
|
LOGE("Invalid parameter.\n");
|
return nullptr;
|
}
|
if (adc_comport->fd == -1)
|
{
|
LOGE("Serail not connected.\n");
|
return nullptr;
|
}
|
|
FD_ZERO(&rdfds);
|
FD_ZERO(&exfds);
|
FD_SET(adc_comport->fd, &rdfds);
|
FD_SET(adc_comport->fd, &exfds);
|
|
if (0xFFFFFFFF != timeout)
|
{
|
stTime.tv_sec = (time_t) (timeout / 1000);
|
stTime.tv_usec = (long)(1000 * (timeout % 1000));
|
|
iRet = select(adc_comport->fd + 1, &rdfds, 0, &exfds, &stTime);
|
if (0 == iRet)
|
{
|
return nullptr;
|
}
|
else if (0 < iRet)
|
{
|
if (0 != FD_ISSET(adc_comport->fd, &exfds))
|
{
|
LOGE("Error checking recv status.\n");
|
return nullptr;
|
}
|
|
if (0 == FD_ISSET(adc_comport->fd, &rdfds))
|
{
|
LOGE("No incoming data.\n");
|
return nullptr;
|
}
|
}
|
else
|
{
|
if (EINTR == errno)
|
{
|
LOGE("catch interrupt signal.\n");
|
}
|
else
|
{
|
LOGE("Check recv status failure.\n");
|
}
|
return nullptr;
|
}
|
}
|
|
usleep(10000); /* sleep for 10ms for data incoming */
|
|
// Get data from Comport
|
LOGD("start read");
|
iRet = read(adc_comport->fd, nativeMsg, len);
|
if (0 > iRet)
|
{
|
return nullptr;
|
}
|
LOGD("Receive {%d} bytes data successfully\n", iRet);
|
for(int i=0; i<iRet; i++)
|
{
|
LOGD("%02X", nativeMsg[i]);
|
}
|
|
char *tempHex = (char *) malloc(iRet * 3);
|
char *recvHex = (char *) malloc(iRet * 3 + 12);
|
if (tempHex == NULL || recvHex == NULL)
|
{
|
LOGE("Memory allocation failed: %s", strerror(errno));
|
return nullptr;
|
}
|
memset(tempHex, 0, sizeof (tempHex));
|
memset(recvHex, 0, sizeof (recvHex));
|
for (int i = 0; i < iRet; i++) {
|
sprintf(tempHex + i * 3, "%02X ", nativeMsg[i]);
|
}
|
strcat(recvHex, "Hex result: ");
|
strcat(recvHex, tempHex);
|
|
char recvalue[512];
|
memset(recvalue, 0, sizeof (recvalue));
|
calculate(recvalue, nativeMsg, iRet);
|
strcat(recvalue, recvHex);
|
LOGD("%s", recvalue);
|
return env->NewStringUTF(recvalue);
|
}
|
