|
|
#include <jni.h>
|
|
|
#include <string>
|
|
|
|
|
|
#include "SpiPort.h"
|
|
|
#include "SpiLib.h"
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
#include <unistd.h>
|
|
|
#include <sys/ioctl.h>
|
|
|
#include <linux/spi/spidev.h>
|
|
|
#include <android/log.h>
|
|
|
#include <stdio.h>
|
|
|
#include <dirent.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <unistd.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <string.h>
|
|
|
#include <termios.h>
|
|
|
#include <time.h>
|
|
|
#include "GPIOControl.h"
|
|
|
#include "serialComm.h"
|
|
|
#include "SensorsProtocol.h"
|
|
|
//#include "WeatherComm.h"
|
|
|
|
|
|
#if 0
|
|
|
#define BYTE u_char;
|
|
|
// 串口参数
|
|
|
typedef struct
|
|
|
{
|
|
|
int baudrate; /* 波特率*/
|
|
|
int databit; /* 数据位*/
|
|
|
char stopbit[8]; /* 停止位*/
|
|
|
char parity; /* 校验位*/
|
|
|
char pathname[128];/* 串口文件名及路径*/
|
|
|
} SERIAL_PARAM;
|
|
|
|
|
|
typedef struct
|
|
|
{
|
|
|
int m_iRevStatus; /* */
|
|
|
int m_iRecvLen; /* */
|
|
|
int m_iNeedRevLength; /* */
|
|
|
int iRecvTime; /* */
|
|
|
int RevCmdFlag;
|
|
|
unsigned char m_au8RecvBuf[128];/* */
|
|
|
} SIO_PARAM_SERIAL_DEF;
|
|
|
|
|
|
extern SIO_PARAM_SERIAL_DEF serialport;
|
|
|
extern float weatherpntmsg[10];
|
|
|
#endif
|
|
|
|
|
|
//set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char parity, int vtime, int vmin )
|
|
|
class NrsecSpiPort : public SpiPort {
|
|
|
public:
|
|
|
NrsecSpiPort(const std::string& path) : SpiPort(path) {
|
|
|
|
|
|
}
|
|
|
|
|
|
bool Open()
|
|
|
{
|
|
|
if (!SpiPort::Open())
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
uint8_t mode = SPI_MODE_3;
|
|
|
uint8_t bits = 8;
|
|
|
uint32_t speed = 33000000;
|
|
|
uint8_t lsb = 1;
|
|
|
// const char *device = "/dev/spidev32766.1";
|
|
|
|
|
|
if (ioctl(m_fd, SPI_IOC_WR_MODE, &mode) == -1 ||
|
|
|
ioctl(m_fd, SPI_IOC_WR_BITS_PER_WORD, &bits) == -1 ||
|
|
|
ioctl(m_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed) == -1 ||
|
|
|
ioctl(m_fd, SPI_IOC_WR_LSB_FIRST, &lsb) == -1)
|
|
|
{
|
|
|
Close();
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
bool GenKeyPair(int keyIdx) {
|
|
|
unsigned char header[] = {0x80, 0xb2, 0x00, (unsigned char)keyIdx, 0x00 };
|
|
|
|
|
|
int bytesWriten = Write(header, sizeof(header));
|
|
|
unsigned char buffer[2] = { 0 };
|
|
|
int bytesRead = Read(buffer, sizeof(buffer));
|
|
|
if (bytesRead > 0) {
|
|
|
int aa = 0;
|
|
|
} else {
|
|
|
int bb = 0;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
#if 0
|
|
|
static void set_baudrate (struct termios *opt, unsigned int baudrate)
|
|
|
{
|
|
|
cfsetispeed(opt, baudrate);
|
|
|
cfsetospeed(opt, baudrate);
|
|
|
}
|
|
|
|
|
|
static void set_data_bit (struct termios *opt, unsigned int databit)
|
|
|
{
|
|
|
opt->c_cflag &= ~CSIZE;
|
|
|
switch (databit)
|
|
|
{
|
|
|
case 8:
|
|
|
opt->c_cflag |= CS8;
|
|
|
break;
|
|
|
case 7:
|
|
|
opt->c_cflag |= CS7;
|
|
|
break;
|
|
|
case 6:
|
|
|
opt->c_cflag |= CS6;
|
|
|
break;
|
|
|
case 5:
|
|
|
opt->c_cflag |= CS5;
|
|
|
break;
|
|
|
default:
|
|
|
opt->c_cflag |= CS8;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void set_parity (struct termios *opt, char parity)
|
|
|
{
|
|
|
switch (parity)
|
|
|
{
|
|
|
case'N':/* 无校验 */
|
|
|
case 'n':
|
|
|
opt->c_cflag &= ~PARENB;
|
|
|
break;
|
|
|
case'E':/*偶校验*/
|
|
|
case 'e':
|
|
|
opt->c_cflag |= PARENB;
|
|
|
opt->c_cflag &= ~PARODD;
|
|
|
break;
|
|
|
case'O':/* 奇校验 */
|
|
|
case 'o':
|
|
|
opt->c_cflag |= PARENB;
|
|
|
opt->c_cflag |= ~PARODD;
|
|
|
break;
|
|
|
default: /*其它选择为无校验 */
|
|
|
opt->c_cflag &= ~PARENB;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static void set_stopbit (struct termios *opt, const char *stopbit)
|
|
|
{
|
|
|
if (strcmp(stopbit, "1") == 0)
|
|
|
{
|
|
|
opt->c_cflag &= ~CSTOPB;/*1 位停止位 t */
|
|
|
}
|
|
|
else if(0 == strcmp(stopbit, "1.5"))
|
|
|
{
|
|
|
opt->c_cflag &= ~CSTOPB;/*1.5 位停止位 */
|
|
|
}
|
|
|
else if(0 == strcmp (stopbit,"2"))
|
|
|
{
|
|
|
opt->c_cflag |= CSTOPB; /*2 位停止位 */
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
opt->c_cflag &= ~CSTOPB; /*1 位停止位 */
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char parity, int vtime, int vmin )
|
|
|
{
|
|
|
struct termios opt;
|
|
|
tcgetattr(fd, &opt);
|
|
|
set_baudrate(&opt, baudrate);
|
|
|
//opt.c_cflag |= CLOCAL|CREAD; /*|CRTSCTS */
|
|
|
opt.c_lflag &= ~(ICANON | ECHO |ECHOE |ISIG);
|
|
|
set_data_bit(&opt, databit);
|
|
|
set_parity(&opt, parity);
|
|
|
set_stopbit(&opt, stopbit);
|
|
|
opt.c_oflag = 0;
|
|
|
//opt.c_lflag |= 0;
|
|
|
opt.c_oflag &= ~OPOST;
|
|
|
opt.c_cc[VTIME] = vtime;
|
|
|
opt.c_cc[VMIN] = vmin;
|
|
|
tcflush (fd, TCIFLUSH);
|
|
|
return (tcsetattr (fd, TCSANOW, &opt));
|
|
|
}
|
|
|
#define MAX_STRING_LEN 32
|
|
|
#define IOT_PARAM_WRITE 0xAE
|
|
|
#define IOT_PARAM_READ 0xAF
|
|
|
|
|
|
typedef struct
|
|
|
{
|
|
|
int cmd;
|
|
|
int value;
|
|
|
int result;
|
|
|
long value2;
|
|
|
char str[MAX_STRING_LEN];
|
|
|
}IOT_PARAM;
|
|
|
|
|
|
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, "serial_port_comm", fmt, ##args)
|
|
|
#endif
|
|
|
void setInt(int cmd, int value)
|
|
|
{
|
|
|
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
|
|
|
IOT_PARAM param;
|
|
|
param.cmd = cmd;
|
|
|
param.value = value;
|
|
|
// LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
|
|
|
if( fd > 0 )
|
|
|
{
|
|
|
int res = ioctl(fd, IOT_PARAM_WRITE, ¶m);
|
|
|
// LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
|
|
|
close(fd);
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
static void setRS485Enable(bool z) {
|
|
|
setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
static void set485WriteMode() {
|
|
|
setInt(CMD_SET_485_STATE, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
static void set485ReadMode() {
|
|
|
setInt(CMD_SET_485_STATE, 0);
|
|
|
}
|
|
|
static void set12VEnable(bool z) {
|
|
|
setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
|
|
|
}
|
|
|
#if 0
|
|
|
static void setCam3V3Enable(bool enabled)
|
|
|
{
|
|
|
setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
* 气象数据处理 *
|
|
|
**********************************************************************************/
|
|
|
void PortDataProcess( void )
|
|
|
{
|
|
|
float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
|
|
|
//WORD uDevAddr;
|
|
|
unsigned char cmdidx;
|
|
|
int i, j, aipnt, datanum;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
char szbuf[64];
|
|
|
|
|
|
pPortParam = &serialport;
|
|
|
//取出装置地址,开始处理地址+++
|
|
|
if(0x02 == pPortParam->m_au8RecvBuf[5])
|
|
|
{
|
|
|
//pPortParam->devaddr = pPortParam->m_au8RecvBuf[4];
|
|
|
return;
|
|
|
}
|
|
|
cmdidx = pPortParam->m_au8RecvBuf[5];
|
|
|
#if 0
|
|
|
aipnt = pPortParam->SameTypeDevIdx;
|
|
|
uDevAddr = serialport->m_au8RecvBuf[4];
|
|
|
if(0 == srdt.IsReadWireTem)
|
|
|
{
|
|
|
if(uDevAddr != pPortParam->devaddr)
|
|
|
return;
|
|
|
}
|
|
|
#endif
|
|
|
fvalua = &fvalue;
|
|
|
datanum = pPortParam->m_au8RecvBuf[6];
|
|
|
if((0x08 != cmdidx) && (0x09 != cmdidx))
|
|
|
return;
|
|
|
|
|
|
for(i = 0, j=7; (i<datanum) && (j<6+pPortParam->m_au8RecvBuf[1]); i++, j+=5 )
|
|
|
{
|
|
|
if(0x08 == cmdidx)
|
|
|
fvalue = (pPortParam->m_au8RecvBuf[j+1]<<24)+(pPortParam->m_au8RecvBuf[j+2]<<16)
|
|
|
+(pPortParam->m_au8RecvBuf[j+3]<<8)+pPortParam->m_au8RecvBuf[j+4];
|
|
|
else
|
|
|
{
|
|
|
*(u_char *)fvalua = pPortParam->m_au8RecvBuf[j+4];
|
|
|
*((u_char *)fvalua+1) = pPortParam->m_au8RecvBuf[j+3];
|
|
|
*((u_char *)fvalua+2) = pPortParam->m_au8RecvBuf[j+2];
|
|
|
*((u_char *)fvalua+3) = pPortParam->m_au8RecvBuf[j+1];
|
|
|
}
|
|
|
switch(pPortParam->m_au8RecvBuf[j])
|
|
|
{
|
|
|
case 1: /*温度*/
|
|
|
weatherpntmsg[0] = fvalue;
|
|
|
LOGE("温度:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 2: /*气压*/
|
|
|
weatherpntmsg[5] = fvalue;
|
|
|
LOGE("气压:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 3: /*湿度*/
|
|
|
weatherpntmsg[1] = fvalue;
|
|
|
LOGE("湿度:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 4: /*雨量*/
|
|
|
break;
|
|
|
case 5: /*日照*/
|
|
|
break;
|
|
|
case 6: /*风速*/
|
|
|
weatherpntmsg[2] = fvalue;
|
|
|
LOGE("风速:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 7: /*风向*/
|
|
|
weatherpntmsg[3] = fvalue;
|
|
|
LOGE("风向:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 8: /*拉力*/
|
|
|
case 9: /*倾角传感器X轴倾角*/
|
|
|
case 10: /*倾角传感器Y轴倾角*/
|
|
|
case 11: /*测温球导线温度*/
|
|
|
case 12: /*测温球内部温度*/
|
|
|
break;
|
|
|
case 13: /*测温球导线X轴倾角*/
|
|
|
break;
|
|
|
case 14: /*测温球导线Y轴倾角*/
|
|
|
break;
|
|
|
case 15: /*测温球导线电流*/
|
|
|
break;
|
|
|
case 16: /*测温球电池电压*/
|
|
|
break;
|
|
|
case 17: /*A相泄漏电流平均值；*/
|
|
|
break;
|
|
|
case 18: /*A相泄漏电流最大值；*/
|
|
|
break;
|
|
|
case 19: /*A相超过3mA的脉冲频次*/
|
|
|
break;
|
|
|
case 20: /*A相超过10mA的脉冲频次*/
|
|
|
break;
|
|
|
case 21: /*B相泄漏电流平均值；*/
|
|
|
break;
|
|
|
case 22: /*B相泄漏电流最大值；*/
|
|
|
break;
|
|
|
case 23: /*B相超过3mA的脉冲频次*/
|
|
|
break;
|
|
|
case 24: /*B相超过10mA的脉冲频次*/
|
|
|
case 25: /*C相泄漏电流平均值；*/
|
|
|
case 26: /*C相泄漏电流最大值；*/
|
|
|
case 27: /*C相超过3mA的脉冲频次*/
|
|
|
case 28: /*C相超过10mA的脉冲频次*/
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//***************************************************************
|
|
|
//* 按照协议格式化接收数据 *
|
|
|
//***************************************************************
|
|
|
void RecvData(u_char *buf, int len)// 规约读数据处理
|
|
|
{
|
|
|
int i, ictime;
|
|
|
//WORD crc, check;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
|
|
|
pPortParam = &serialport;
|
|
|
ictime = (int)time(NULL);
|
|
|
|
|
|
if(pPortParam->m_iRecvLen == 0)
|
|
|
{
|
|
|
pPortParam->iRecvTime = ictime;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if((ictime-pPortParam->iRecvTime > 6) || (ictime - pPortParam->iRecvTime < 0))
|
|
|
pPortParam->iRecvTime = ictime;
|
|
|
else if(ictime - pPortParam->iRecvTime > 2)
|
|
|
{
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for(i=0; i<len; i++)
|
|
|
{
|
|
|
switch(pPortParam->m_iRevStatus)
|
|
|
{
|
|
|
case 0: // 0x68
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 1: // len1
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
break;
|
|
|
case 2: // len2
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
|
|
|
{
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
pPortParam->m_iNeedRevLength = buf[i]+5;
|
|
|
}
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 3: // 0x68
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 4: // 正确接收数据
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iNeedRevLength > 0)
|
|
|
break;
|
|
|
if(buf[i] != 0x16)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus=18;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
//if(CheckLpcError(serialport->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
|
|
|
{
|
|
|
PortDataProcess();
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->RevCmdFlag = 1;
|
|
|
}
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
break;
|
|
|
case 255:// 错误接收数据
|
|
|
default:
|
|
|
if(buf[i] == 0x68)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus = 1;
|
|
|
pPortParam->m_iRecvLen = 1;
|
|
|
pPortParam->m_au8RecvBuf[0] = buf[i];
|
|
|
}
|
|
|
else if(buf[i] == 0x16)
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iRecvLen > 200)
|
|
|
{
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//int inum =0;
|
|
|
//int itimecnt=0;
|
|
|
int weather_comm(SERIAL_PARAM weatherport)
|
|
|
{
|
|
|
int fd = -1;
|
|
|
int len, i,ret, ictime, iruntime, isendtime, irecvtime, icnt=0;
|
|
|
unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16};
|
|
|
char recvbuf[256], szbuf[512];
|
|
|
//char serial_description[] = "/dev/ttyS0";
|
|
|
|
|
|
#if 0
|
|
|
DIR *dir = opendir("/dev");
|
|
|
if (dir == NULL) {
|
|
|
LOGE("_test_ opendir");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 读取目录项
|
|
|
struct dirent *entry;
|
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
|
// 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
|
|
|
if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
|
|
|
(strncmp(entry->d_name, "ttyS0", 5) == 0)) {
|
|
|
LOGE("_test_ Found serial port: %s\n", entry->d_name);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 关闭目录
|
|
|
closedir(dir);
|
|
|
#endif
|
|
|
serialport.RevCmdFlag = 1;
|
|
|
serialport.m_iRecvLen = 0;
|
|
|
serialport.m_iRevStatus = 0;
|
|
|
|
|
|
set12VEnable(true);
|
|
|
setCam3V3Enable(true);
|
|
|
setRS485Enable(true);
|
|
|
|
|
|
ictime = (int)time(NULL);
|
|
|
for(;;)
|
|
|
{
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
fd = open(weatherport.pathname, O_RDWR | O_NDELAY);
|
|
|
//fd = open(weatherport.pathname, O_RDWR | O_NOCTTY);
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
LOGE("_test_ open serial error \n");
|
|
|
perror(weatherport.pathname);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
ret= set_port_attr (fd, weatherport.baudrate,weatherport.databit,weatherport.stopbit,weatherport.parity,0,0 );/*9600 8n1 */
|
|
|
if(ret < 0)
|
|
|
{
|
|
|
LOGE("_test_ set uart arrt faile \n");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
usleep(10000);
|
|
|
iruntime = (int)time(NULL);
|
|
|
if((iruntime - ictime > 120) || (iruntime - ictime < 0))
|
|
|
ictime = iruntime;
|
|
|
if(iruntime - ictime > 19)
|
|
|
{
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "气象采样时间=%d,停止采样!", iruntime-ictime);
|
|
|
LOGE("%s", szbuf);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if(1 == serialport.RevCmdFlag)
|
|
|
{
|
|
|
set485WriteMode();
|
|
|
|
|
|
len = write(fd, sendbuf, sizeof(sendbuf));/* 向串囗发送字符串 */
|
|
|
serialport.RevCmdFlag = 0;
|
|
|
isendtime = time(NULL);
|
|
|
if (len < 0) {
|
|
|
LOGE("write data error \n");
|
|
|
return -1;
|
|
|
} else {
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "Send：");
|
|
|
for (i = 0; i < len; i++) {
|
|
|
sprintf(szbuf, "%s %02X", szbuf, sendbuf[i]);
|
|
|
}
|
|
|
LOGE("%s", szbuf);
|
|
|
//icnt = 0;
|
|
|
//inum++;
|
|
|
}
|
|
|
tcdrain(fd);
|
|
|
//usleep(50000);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
irecvtime = time(NULL);
|
|
|
if((irecvtime-isendtime > 6) ||(irecvtime - isendtime < 0))
|
|
|
isendtime = irecvtime;
|
|
|
if (irecvtime-isendtime > 1)
|
|
|
{
|
|
|
LOGE("传感器超过%d秒未应答", irecvtime-isendtime);
|
|
|
serialport.RevCmdFlag = 1;
|
|
|
serialport.m_iRecvLen = 0;
|
|
|
serialport.m_iRevStatus = 0;
|
|
|
close(fd);
|
|
|
//set12VEnable(false);
|
|
|
//setCam3V3Enable(false);
|
|
|
//setRS485Enable(false);
|
|
|
fd = -1;
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
set485ReadMode();
|
|
|
memset(recvbuf, 0, sizeof(recvbuf));
|
|
|
len = read(fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
|
|
|
if (len < 0) {
|
|
|
LOGE("serial read error \n");
|
|
|
continue;
|
|
|
}
|
|
|
if(0 == len)
|
|
|
{
|
|
|
//icnt++;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "Recv：");
|
|
|
for (i = 0; i < len; i++) {
|
|
|
sprintf(szbuf, "%s %02X", szbuf, recvbuf[i]);
|
|
|
}
|
|
|
__android_log_print(ANDROID_LOG_INFO, "serial", "%s", szbuf);
|
|
|
RecvData((u_char*)recvbuf, len);
|
|
|
//LOGE("一周期空循环次数%d, 读取次数%d, 时间：%d %d", icnt, inum, (int)time(NULL), itimecnt);
|
|
|
icnt = 0;
|
|
|
//serialport.RevCmdFlag =1;
|
|
|
}
|
|
|
|
|
|
close(fd);
|
|
|
set12VEnable(false);
|
|
|
setCam3V3Enable(false);
|
|
|
setRS485Enable(false);
|
|
|
|
|
|
//exit(-1);
|
|
|
return(0);
|
|
|
}
|
|
|
|
|
|
int serial_port_comm()
|
|
|
{
|
|
|
SERIAL_PARAM portparm;
|
|
|
#if 1
|
|
|
memset(portparm.pathname, 0, sizeof(portparm.pathname));
|
|
|
sprintf(portparm.pathname, "/dev/ttyS0");
|
|
|
portparm.parity = 'N';
|
|
|
portparm.databit = 8;
|
|
|
portparm.baudrate = B9600;
|
|
|
memset(portparm.stopbit, 0, sizeof(portparm.stopbit));
|
|
|
sprintf(portparm.stopbit, "1");
|
|
|
#endif
|
|
|
//itimecnt = (int)time(NULL);
|
|
|
|
|
|
for(;;)
|
|
|
weather_comm(portparm);
|
|
|
return 0;
|
|
|
}
|
|
|
#endif
|
|
|
extern "C" JNIEXPORT jstring JNICALL
|
|
|
Java_com_xinyingpower_testcomm_MainActivity_stringFromJNI(
|
|
|
JNIEnv* env,
|
|
|
jobject /* this */) {
|
|
|
std::string hello = "Hello from C++";
|
|
|
return env->NewStringUTF(hello.c_str());
|
|
|
}
|
|
|
|
|
|
extern "C" JNIEXPORT jstring JNICALL
|
|
|
Java_com_xinyingpower_testcomm_MainActivity_testSpi(
|
|
|
JNIEnv* env,
|
|
|
jobject /* this */, jint port) {
|
|
|
//testSpi();
|
|
|
SpiLIb a;
|
|
|
unsigned char newkey[32]={0xaf,0x0c,0xa9,0x40,0x1f,0xe6,0xee,0x0f,0x4c,
|
|
|
0xfb,0xf7,0x17,0x71,0xde,0x61,0x59
|
|
|
,0x0a,0x05,0x77,
|
|
|
0xfa,0xe7,0xd1,0x8d,0x10,0x3a,0x79,0x23,0xf2,0xb3,
|
|
|
0x6d,0xea,0x8e
|
|
|
// ,0xe0,0x64,0xe7,0x5d,0x49,0x84,0xe4,
|
|
|
// 0x5f,0xc9,0x07,0x03,0x52,0x33,0x79,0x87,0xd4,0x62,
|
|
|
// 0x62,0xc0,0xcc,0xf0,0xd6,0x85,0x20,0x7f,0x7a,0xe8,
|
|
|
// 0xc8,0xed,0x12,0xdb,0xdc
|
|
|
};
|
|
|
unsigned char outpub[32],outsign[64], *outen = new unsigned char [256];
|
|
|
unsigned char pucid[16]={0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
|
|
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01};
|
|
|
string b="C=CN,ST=jiangsu,L=nanjing,O=GDD,OU=nari,CN=test001";
|
|
|
//a.SM2keypair(0x00);
|
|
|
//a.SM3Hash(newkey,16, outpub);
|
|
|
//a.sm3hash_tosm2(newkey,16,outpub,newkey,pucid,16);
|
|
|
//a.SM2Sign(0x00,outpub,outsign);
|
|
|
//a.SM2VerifySign(0x00,outpub,outsign);
|
|
|
|
|
|
//lxy modify modify
|
|
|
//LOGE("_test_ setRS485Enable true");
|
|
|
//setRS485Enable(true);
|
|
|
|
|
|
//set12VEnable(true);
|
|
|
//serial_port_comm();
|
|
|
GM_StartSerialComm();
|
|
|
//lxy modify modify
|
|
|
//LOGE("_test_ setRS485Enable false");
|
|
|
//setRS485Enable(false);
|
|
|
return env->NewStringUTF("");
|
|
|
|
|
|
#if 0
|
|
|
DIR *dir = opendir("/dev");
|
|
|
if (dir == NULL) {
|
|
|
perror("opendir");
|
|
|
//return env->NewStringUTF("error");
|
|
|
//return -1;
|
|
|
}
|
|
|
|
|
|
// 读取目录项
|
|
|
struct dirent *entry;
|
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
|
// 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
|
|
|
if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
|
|
|
(strncmp(entry->d_name, "ttyS0", 5) == 0)) {
|
|
|
printf("Found serial port: %s\n", entry->d_name);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 关闭目录
|
|
|
closedir(dir);
|
|
|
#endif
|
|
|
a.SM2cert(0x00,0x00,b,outen);
|
|
|
for (int i = 0; i < 32; i++) {
|
|
|
//sprintf(output, " %02x ", rxbuf[i]);
|
|
|
__android_log_print(ANDROID_LOG_INFO, "SPi", "%02x", outen[i]);
|
|
|
}
|
|
|
// a.SM2decoder(0x00,outen,outpub);
|
|
|
//
|
|
|
// for (int i = 0; i < 64; i++) {
|
|
|
// //sprintf(output, " %02x ", rxbuf[i]);
|
|
|
// __android_log_print(ANDROID_LOG_INFO, "SPi", "%02x", outpub[i]);
|
|
|
// }
|
|
|
|
|
|
//a.SM3Hash(0x00,0x10,newkey);
|
|
|
//testVersion();
|
|
|
|
|
|
return env->NewStringUTF("End");
|
|
|
|
|
|
// NrsecSpiPort spi("/dev/mtkgpioctrl");
|
|
|
NrsecSpiPort spi("/dev/spidevSE");
|
|
|
|
|
|
// NrsecSpiPort spi("/dev/spidev0.0");
|
|
|
|
|
|
if (!spi.Open()) {
|
|
|
return env->NewStringUTF(spi.GetLog().c_str());
|
|
|
}
|
|
|
|
|
|
spi.GenKeyPair(0);
|
|
|
|
|
|
unsigned char header[] = { 0x00, 0x5b, 0x00, 0x00, 0x40 };
|
|
|
|
|
|
int bytesWriten = spi.Write(header, sizeof(header));
|
|
|
unsigned char buffer[1024] = { 0 };
|
|
|
int bytesRead = spi.Read(buffer, 1);
|
|
|
if (bytesRead > 0) {
|
|
|
int aa = 0;
|
|
|
} else {
|
|
|
int bb = 0;
|
|
|
}
|
|
|
int len = buffer[0];
|
|
|
bytesRead += spi.Read(&buffer[1], len);
|
|
|
|
|
|
spi.Close();
|
|
|
|
|
|
std::string result;
|
|
|
char buf[32] = { 0 };
|
|
|
for (int idx = 0; idx < 32; idx++)
|
|
|
{
|
|
|
sprintf(buf, "%X ", buffer[idx]);
|
|
|
result += buf;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return env->NewStringUTF(result.c_str());
|
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
//// lxy add
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static speed_t getBaudrate(jint 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;
|
|
|
}
|
|
|
}
|
|
|
char* jstring2str(JNIEnv* env, jstring jstr)
|
|
|
{
|
|
|
char* rtn = NULL;
|
|
|
jclass clsstring = env->FindClass("java/lang/String");
|
|
|
jstring strencode = env->NewStringUTF("UTF-8");
|
|
|
jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
|
|
|
jbyteArray barr= (jbyteArray)env->CallObjectMethod(jstr,mid,strencode);
|
|
|
jsize alen = env->GetArrayLength(barr);
|
|
|
jbyte* ba = env->GetByteArrayElements(barr,JNI_FALSE);
|
|
|
|
|
|
if(alen > 0)
|
|
|
{
|
|
|
rtn = (char*)malloc(alen+1); //new char[alen+1];
|
|
|
memcpy(rtn,ba,alen);
|
|
|
rtn[alen] = 0;
|
|
|
}
|
|
|
|
|
|
env->ReleaseByteArrayElements(barr,ba,0);
|
|
|
return (char*)rtn;
|
|
|
}
|
|
|
|
|
|
|
|
|
int g_fd = -1;
|
|
|
int serial_open(char *devPath, speed_t baudrate ) {
|
|
|
int ret = 0;
|
|
|
setRS485Enable(true);
|
|
|
int fd = open("/dev/ttyS0", O_RDWR |O_NOCTTY |O_NONBLOCK);
|
|
|
LOGE("_test_ serial_open fd=%d \n",fd);
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
LOGE("_test_ open serial error \n");
|
|
|
return 0;
|
|
|
}
|
|
|
//ret= set_port_attr (fd, baudrate,8,"1",'N',150,0 );/*9600 8n1 */
|
|
|
ret= set_port_attr (fd, baudrate,8,"1",'N',150,0 );/*9600 8n1 */
|
|
|
if(ret < 0)
|
|
|
{
|
|
|
LOGE("_test_ set serial param fail \n");
|
|
|
return 0;
|
|
|
}
|
|
|
g_fd = fd;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
void serial_close()
|
|
|
{
|
|
|
LOGE("_test_ serial_close fd=%d \n",g_fd);
|
|
|
if(g_fd != -1)
|
|
|
{
|
|
|
close(g_fd);
|
|
|
setRS485Enable(false);
|
|
|
}
|
|
|
g_fd = -1;
|
|
|
}
|
|
|
|
|
|
int serial_write(char *sendbuf, int length)
|
|
|
{
|
|
|
int len = 0;
|
|
|
if(g_fd < 0)
|
|
|
return 0;
|
|
|
set485WriteMode();
|
|
|
len = write(g_fd, sendbuf, length);/* 向串囗发送字符串 */
|
|
|
LOGE("_test_ serial_write len=%d \n",len);
|
|
|
if (len < 0)
|
|
|
{
|
|
|
LOGE("_test_ write data error \n");
|
|
|
return 0;
|
|
|
}
|
|
|
return len;
|
|
|
}
|
|
|
|
|
|
int serial_read(char *readbuf,int length)
|
|
|
{
|
|
|
int len = 0;
|
|
|
if(g_fd < 0)
|
|
|
return 0;
|
|
|
set485ReadMode();
|
|
|
memset(readbuf, 0, length);
|
|
|
len = read(g_fd, readbuf, length);/* 在串口读取字符串 */
|
|
|
LOGE("_test_ serial_read len=%d \n",len);
|
|
|
if (len < 0)
|
|
|
{
|
|
|
//LOGE("_test_ read error \n");
|
|
|
return 0;
|
|
|
}
|
|
|
return len;
|
|
|
}
|
|
|
|
|
|
extern "C" JNIEXPORT jboolean JNICALL Java_com_xinyingpower_testcomm_MainActivity_openSerial
|
|
|
(JNIEnv* env, jobject, jstring dev, jint baudrate) {
|
|
|
char *devPath = jstring2str(env, dev);
|
|
|
LOGE("_test open serial path=%s, baudrate=%d\n", devPath, baudrate);
|
|
|
speed_t speed = getBaudrate(baudrate);
|
|
|
int res = serial_open(devPath, speed);
|
|
|
return res == 1 ? JNI_TRUE: JNI_FALSE;
|
|
|
}
|
|
|
|
|
|
extern "C" JNIEXPORT void JNICALL Java_com_xinyingpower_testcomm_MainActivity_closeSerial
|
|
|
(JNIEnv* env, jobject) {
|
|
|
serial_close();
|
|
|
}
|
|
|
|
|
|
extern "C" JNIEXPORT jint JNICALL Java_com_xinyingpower_testcomm_MainActivity_writeSerial
|
|
|
(JNIEnv *env, jobject , jbyteArray jstr) {
|
|
|
jsize len = env->GetArrayLength(jstr);
|
|
|
if (len <= 0)
|
|
|
return 0;
|
|
|
jbyte *jdata = env->GetByteArrayElements(jstr, 0);
|
|
|
int res = serial_write((char*)jdata, len);
|
|
|
env->ReleaseByteArrayElements(jstr, jdata, 0);
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
extern "C" JNIEXPORT jint JNICALL Java_com_xinyingpower_testcomm_MainActivity_readSerial
|
|
|
(JNIEnv *env, jobject, jbyteArray out)
|
|
|
{
|
|
|
jsize outlen = env->GetArrayLength(out);
|
|
|
//LOGE("_test readSerial outlen=%d\n", outlen);
|
|
|
if(outlen <= 0)
|
|
|
return 0;
|
|
|
jbyte* outData = env->GetByteArrayElements(out, 0);
|
|
|
char* outbuf = (char*)outData;
|
|
|
int res = serial_read(outbuf, outlen);
|
|
|
//LOGE("_test serial_read res=%d\n", res);
|
|
|
env->ReleaseByteArrayElements(out, outData, 0);
|
|
|
return res;
|
|
|
} |