xymp
/
TestComm
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

修改拍照

Browse Source
main
jxjajs 6 months ago
parent ef70a2a5d3
commit 1ce54d8c03
5 changed files with 3455 additions and 3901 deletions
Show Stats Download Patch File Download Diff File

6471
app/src/main/cpp/SensorsProtocol.cpp
View File

File diff suppressed because it is too large Load Diff

208
app/src/main/cpp/SensorsProtocol.h
Unescape Escape View File

@ -2,37 +2,26 @@
// Created by hyz on 2024/6/5.
//
#ifndef WEATHERCOMM_H
#define WEATHERCOMM_H
#ifndef __SENSOR_PROTOCOL_H__
#define __SENSOR_PROTOCOL_H__
#include <string>
#include "GPIOControl.h"
#include "termios.h"
#ifndef DWORD
typedef unsigned int DWORD;
#endif
#ifndef WORD
typedef unsigned short WORD;
#endif
#ifndef BYTE
typedef unsigned char BYTE;
#endif
#ifndef LONG
typedef long long LONG;
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#ifndef LOBYTE
#define LOBYTE(w) ((unsigned char)(w))
#endif
#define LOBYTE(w) ((unsigned char)(w))
#ifndef HIBYTE
#define HIBYTE(w) ((unsigned char)(((unsigned short)(w) >> 8) & 0xFF))
#endif
#define LOWORD(l) ((WORD)(l))
#define HIWORD(l) ((WORD)((DWORD)(l) >> 16))
#ifndef LOWORD
#define LOWORD(l) ((uint16_t)(l))
#endif
#ifndef HIWORD
#define HIWORD(l) ((uint16_t)((uint32_t)(l) >> 16))
#endif
#define min(a, b) ((a) < (b) ? (a) : (b))
#define MAX_STRING_LEN 32
@ -63,11 +52,11 @@ typedef long long LONG;
#define AtmosNo 5 /* 大气压数据存储序号*/
#define OpticalRadiationNo 6 /* 日照（光辐射）数据存储序号*/
#define Idle 0 /* 传感器处于空闲状态，未启动采样*/
#define Sample 1 /* 正在采样过程中*/
#define SamplingSuccess 2 /* 采样结束,正常读取到数据*/
#define StartSample 3 /* 启动采样*/
#define SampleFail -1 /* 采样失败，未采集到数据，传感器故障或未接*/
#define SER_IDLE 0 /* 传感器处于空闲状态，未启动采样*/
#define SER_SAMPLE 1 /* 正在采样过程中*/
#define SAMPLINGSUCCESS 2 /* 采样结束,正常读取到数据*/
#define SER_STARTSAMPLE 3 /* 启动采样*/
#define SER_SAMPLEFAIL -1 /* 采样失败，未采集到数据，传感器故障或未接*/
#define PHOTO_SAVE_SUCC 5 /* 图片保存成功*/
#define WEATHER_DATA_NUM 8 /* 气象数据最大数量(一般最多是6要素)*/
@ -138,7 +127,7 @@ typedef long long LONG;
#define SPEED_DOME_CAMERA 0 /* 球机摄像机*/
#define SERIAL_CAMERA 2 /* 串口摄像机a*/
#define COLLECT_DATA 1 /* 调试使用*/
#define COLLECT_DATA 0 /* 调试使用*/
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, "serial_port_comm", fmt, ##args) /* 红色*/
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, "Sensors_Protocol", fmt, ##args) /* 草绿色*/
@ -152,17 +141,16 @@ typedef struct
int cmd;
int value;
int result;
LONG value2;
uint64_t value2;
char str[MAX_STRING_LEN];
}IOT_PARAM;
//SDS包类型结构
typedef struct
{
BYTE PortIdx; // 信息类型
WORD MsgType; // 信息类型
uint8_t PortIdx; // 信息类型
uint16_t MsgType; // 信息类型
int MsgLen; // 信息长度
u_char MsgData[RECVDATA_MAXLENTH];
uint8_t MsgData[RECVDATA_MAXLENTH];
} RTUMSG;
typedef struct
@ -180,7 +168,7 @@ typedef struct
typedef struct
{
BYTE AiState; // 数据标识(-1：采样失败；0:没有采样；1：正在采样；2：采样结束；3：启动采样；）
uint8_t AiState; // 数据标识(-1：采样失败；0:没有采样；1：正在采样；2：采样结束；3：启动采样；）
float EuValue; // 数据工程值
} Data_DEF;
@ -188,7 +176,7 @@ typedef struct
{
int imagelen; // 整个图片大小
int phototime; // 拍照时间
u_char presetno; // 拍照预置点
uint8_t presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
int state;// 标识(-1：拍照失败；0:没有拍照；1：正在取图；2：拍照成功；3：启动拍照；）
} IMAGE_DEF;
@ -198,15 +186,15 @@ typedef struct
int imagelen; // 整个图片大小
int imagenum; // 整个图片的总包数
int phototime; // 拍照时间
u_char presetno; // 拍照预置点
uint8_t presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
u_char buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存
uint8_t buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存
int ilen[MAX_PHOTO_PACKET_NUM]; // 相对应的每包图片数据的长度
int state;// 标识(-1：拍照失败；0:没有拍照；1：正在取图；2：拍照成功；3：启动拍照；）
} PHOTO_DEF;
// 上层调用采集传感器参数
typedef struct
typedef struct SENSOR_PARAM
{
unsigned int baudrate; /* 波特率*/
int databit; /* 数据位*/
@ -214,11 +202,11 @@ typedef struct
char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
//int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/
u_char SensorsType; /* 传感器类型索引，大于 0*/
uint8_t SensorsType; /* 传感器类型索引，大于 0*/
int devaddr; /* 装置(传感器)使用的地址*/
u_char IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
u_char CameraChannel; /* 像机的通道号*/
u_char Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
uint8_t IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
uint8_t CameraChannel; /* 像机的通道号*/
uint8_t Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
} SENSOR_PARAM;
// 需要配置的串口装置参数
@ -230,11 +218,11 @@ typedef struct
char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
int commid; /* 串口序号 注意：从0开始*/
u_char ProtocolIdx; /* 规约索引，大于 0*/
uint8_t ProtocolIdx; /* 规约索引，大于 0*/
int devaddr; /* 装置使用的地址*/
u_char IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
u_char CameraChannel; /* 像机的通道号*/
u_char Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
uint8_t IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
uint8_t CameraChannel; /* 像机的通道号*/
uint8_t Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
} SERIAL_PARAM;
typedef struct
@ -243,40 +231,45 @@ typedef struct
int m_iRecvLen; /* */
int m_iNeedRevLength; /* */
int iRecvTime; /* */
u_char m_au8RecvBuf[RECVDATA_MAXLENTH];/* */
uint8_t m_au8RecvBuf[RECVDATA_MAXLENTH];/* */
int fd; /* 串口打开的文件句柄*/
u_char PollCmd[SENDDATA_MAXLENTH];
uint8_t PollCmd[SENDDATA_MAXLENTH];
int cmdlen; // 发送缓冲区命令长度
//******************** Poll Cmd ****************************
u_char Retry; /* 重试命令次数 */
u_char RetryCnt; /* 重试命令计数*/
LONG RetryTime; /* 重试命令时间 */
LONG RetryTimeCnt; /* 重试命令时间计数*/
LONG WaitTime; /* 命令间隔时间 */
LONG WaitTimeCnt; /* 命令间隔时间计数*/
u_char ForceWaitFlag; /* 强制等待标志*/
u_short ForceWaitCnt; /* 强制等待计数*/
u_char ReSendCmdFlag; /* 重发命令标志 */
u_char SendCmdFlag; /* 命令发送标志 */
u_char RevCmdFlag; /* 命令正常接收标志*/
uint8_t Retry; /* 重试命令次数 */
uint8_t RetryCnt; /* 重试命令计数*/
int64_t RetryTime; /* 重试命令时间 */
int64_t RetryTimeCnt; /* 重试命令时间计数*/
int64_t WaitTime; /* 命令间隔时间 */
int64_t WaitTimeCnt; /* 命令间隔时间计数*/
uint8_t ForceWaitFlag; /* 强制等待标志*/
uint16_t ForceWaitCnt; /* 强制等待计数*/
uint8_t ReSendCmdFlag; /* 重发命令标志 */
uint8_t SendCmdFlag; /* 命令发送标志 */
uint8_t RevCmdFlag; /* 命令正常接收标志*/
//**********************************************************
LONG lsendtime; /* 命令发送绝对时间计时（毫秒）*/
int64_t lsendtime; /* 命令发送绝对时间计时（毫秒）*/
int cameraaddr; /*　摄像机地址*/
int SerialCmdidx; /* 正在使用的串口发送命令的命令序号(-1:表示没有命令发送)
摄像机使用命令序号存储*/
PHOTO_DEF image; /* 临时存储图片数据*/
int64_t FirstCmdTimeCnt; /* 串口读取数据起始时间*/
} SIO_PARAM_SERIAL_DEF;
//串口相关装置所有参数集中定义
typedef struct
{
//******************** 端口基本信息 ************************
u_char IsNeedSerial; /* 是否需要使用串口通讯*/
uint8_t IsNeedSerial; /* 是否需要使用串口通讯*/
int CmdWaitTime; /* 没有使用*/
u_char UseSerialidx; /* 使用的串口序号*/
uint8_t UseSerialidx; /* 使用的串口序号*/
int SerialCmdidx; /* 正在使用的串口发送命令的命令序号(-1:表示没有命令发送)
摄像机使用命令序号存储*/
int enrecvtime; /* 发送加密命令后接收到应答计时*/
LONG FirstCmdTimeCnt; /* 串口读取数据起始时间*/
u_char nextcmd; /* 第二次发送读取气象雨量命令 */
u_char SameTypeDevIdx; /* 相同类型装置顺序排列序号(从0开始)*/
u_char uOpenPowerFlag; /* 传感器上电标志(0:不需要打开; 1:需要打开)*/
int64_t FirstCmdTimeCnt; /* 串口读取数据起始时间*/
uint8_t nextcmd; /* 第二次发送读取气象雨量命令 */
uint8_t SameTypeDevIdx; /* 相同类型装置顺序排列序号(从0开始)*/
uint8_t uOpenPowerFlag; /* 传感器上电标志(0:不需要打开; 1:需要打开)*/
int recvdatacnt; /* 接收到有效数据*/
PHOTO_DEF image; /* 临时存储图片数据*/
AI_DEF aiValue[MAX_DEV_VALUE_NUM]; /* 传感器采样值*/
@ -285,17 +278,17 @@ typedef struct
//串口相关装置所有参数集中定义
typedef struct
{
u_char clcyesampling; /* 正在进行采样(0:没有进行采样;1:正在进行采样;)*/
u_char camerauseserial; /* 摄像机使用那个串口*/
DWORD PtzCmdType; /* 云台指令类型*/
uint8_t clcyesampling; /* 正在进行采样(0:没有进行采样;1:正在进行采样;)*/
uint8_t camerauseserial; /* 摄像机使用那个串口*/
uint32_t PtzCmdType; /* 云台指令类型*/
int usecameradevidx; /* 有像机指令需要执行*/
/* 执行指令的装置序号(-1:表示没有需要执行的指令;)*/
int SendStopPtzCmdTimeCnt; /* 发送云台停止指令*/
u_char serialstatus[MAX_SERIAL_PORT_NUM]; /* 串口是否可以使用状态分别对应串口1、2、3*/
int SendStopPtzCmdTimeCnt; /* 发送云台停止指令*/
uint8_t serialstatus[MAX_SERIAL_PORT_NUM]; /* 串口是否可以使用状态分别对应串口1、2、3*/
SERIAL_DEV_DEF ms_dev[MAX_SERIAL_DEV_NUM]; /* 装置所接传感器数量*/
int UseingSerialdev[MAX_SERIAL_PORT_NUM]; /* 正在使用串口通讯的装置序号(-1,表示串口空闲)*/
int curdevidx[MAX_SERIAL_PORT_NUM]; /* 当前正在通讯的装置序号(-1表示没有装置需要通讯)*/
u_char IsReadWireTem; /* 是否在开始读取测温数据(0:表示没有;1:是)*/
uint8_t IsReadWireTem; /* 是否在开始读取测温数据(0:表示没有;1:是)*/
//int proruntime; /* 程序运行时间*/
int IsSleep; /* 是否使程序休眠(1:不休眠;2:休眠)*/
int tempsamplingstartime; /* 测温启动距离采样启动时间间隔*/
@ -316,16 +309,16 @@ typedef struct
int sendphotocmdcnt; /* 一次拍照过程中发送拍照指令计数*/
int photographtime; /* 图片拍摄的时间*/
int iLastGetPhotoNo; /* 设置串口摄像机参数时暂存拍照命令序号*/
u_char bImageSize; /* 用于临时存储接收上层命令的图片大小*/
u_char presetno; /* 用于临时存储接收上层命令的预置点*/
uint8_t bImageSize; /* 用于临时存储接收上层命令的图片大小*/
uint8_t presetno; /* 用于临时存储接收上层命令的预置点*/
char filedir[512]; /* 用于摄像机拍照之后暂时存放的路径*/
#endif
u_char errorPhotoNoCnt; /* 串口摄像机拍照时回应错误包号计数(如:召第6包回应第3包)*/
u_char RephotographCnt; /* 串口摄像机重拍计数(只在读照片数据应答出错时才重拍)*/
uint8_t errorPhotoNoCnt; /* 串口摄像机拍照时回应错误包号计数(如:召第6包回应第3包)*/
uint8_t RephotographCnt; /* 串口摄像机重拍计数(只在读照片数据应答出错时才重拍)*/
} SRDT_DEF;
static void PortDataProcess( void );
static LONG get_msec();
static int64_t get_msec();
int serial_port_comm();
static int weather_comm(SERIAL_PARAM weatherport);
@ -352,12 +345,12 @@ void Gm_CloseSerialPort();
void DebugLog(int commid, char *szbuf, char flag);
int SaveLogTofile(int commid, char *szbuf);
// 功能说明:串口发送数据 返回实际发送的字节数
int GM_SerialComSend(const unsigned char * cSendBuf, LONG nSendLen, int commid);
int GM_SerialComSend(const unsigned char * cSendBuf, size_t nSendLen, int commid);
void Gm_InitSerialComm(SENSOR_PARAM *sensorParam, char *filedir);
// 启动串口通讯
void GM_StartSerialComm();
// 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx);
int GM_StartSerialCameraPhoto(uint8_t channel, int cmdidx, u_char bImageSize, int phototime, u_char presetno, char *serfile, unsigned int baud, int addr);
void delete_old_files(const char *path, int days);
// 串口轮询通讯定时器
@ -373,12 +366,12 @@ int GM_CloseTimer();
void testComm();
void Gm_InitSerialComm_Test();
// 串口接收数据处理
void SerialDataProcess(int devidx, u_char *buf, int len);
void SerialDataProcess(int devidx, uint8_t *buf, int len);
void CameraRecvData(int commid, u_char *buf, int len);
void CameraRecvData(SIO_PARAM_SERIAL_DEF *pPortParam, u_char *buf, int len);
// 串口摄像机数据处理
void CameraPhotoPortDataProcess( int port);
void CameraPhotoPortDataProcess(SIO_PARAM_SERIAL_DEF *curserial);
// 发送命令
void SendCmdFormPollCmdBuf( int port );
@ -387,29 +380,29 @@ void SendCmdFormPollCmdBuf( int port );
void ClearCmdAllFlag(int commid);
// 下发串口拍照指令控制
int FindNextCameraPhotoCommand(int devidx);
int FindNextCameraPhotoCommand(SIO_PARAM_SERIAL_DEF *pPortParam);
// 生成 CameraPhoto命令
void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoParam, BYTE Threep, int phototime);
void MakeCameraPhotoCommand(SIO_PARAM_SERIAL_DEF *pPortParam, uint8_t cmdidx, int OneParam, uint16_t TwoParam, uint8_t Threep, int phototime);
// 清除命令缓冲区
void ClearCmdFormPollCmdBuf(int port);
// 准备发送云台指令
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd);
int Gm_CtrlPtzCmd(SIO_PARAM_SERIAL_DEF *pPortParam, uint32_t ptzcmd);
// 发送转动摄像机云台命令定时器
int Gm_Camera_Timer();
// 生成 PELCO_P 命令 *
void Gm_SendPelco_pCommand( DWORD cmdtype);
void Gm_SendPelco_pCommand( uint32_t cmdtype);
// 计算Pelco_p校验
BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len );
uint8_t Gm_Pelco_pXORCheck( uint8_t *msg, int len );
// 生成 PELCO_D 命令 *
void Gm_SendPelco_DCommand( DWORD cmdtype);
void Gm_SendPelco_DCommand(SIO_PARAM_SERIAL_DEF *pPortParam, uint32_t cmdtype);
// 计算Pelco_D校验
BYTE Gm_Pelco_DCheck( BYTE *msg, int len );
uint8_t Gm_Pelco_DCheck( uint8_t *msg, int len );
// 查询传感器电源状态
char Gm_GetSensorsPowerState(int port);
@ -421,15 +414,15 @@ int FindNextShxyProtocolCommand( int devidx );
// 倾角命令校验码计算
unsigned char CalLpc(unsigned char *msg, int len);
// 读上海欣影传感器协议数据
void ShxyProtocolRecvData(int commid, u_char *buf, int len);
void ShxyProtocolRecvData(int commid, uint8_t *buf, int len);
// 检查检验和是否正确
int CheckShxyProtocolLpcError( u_char* msg, int len );
int CheckShxyProtocolLpcError( uint8_t* msg, int len );
// 把16进制和10进制ASCII字符串转换成int整数
int ATOI(char *buf);
//生成倾角命令
void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx);
void MakeShxyProtocolPollCommand(int portno, uint8_t cmdidx);
// 上海欣影传感器协议数据处理
void ShxyProtocolDataProcess( int commid);
// 控制关闭传感器电源
@ -439,8 +432,7 @@ void ShxyProtocolDataProcess( int commid);
int SaveImageDataTofile(int devno);
void Collect_sensor_data();
void CameraPhotoCmd(int phototime, u_char channel, int cmdidx, u_char bImageSize, u_char presetno);
int CameraPhotoCmd(int phototime, u_char channel, int cmdidx, u_char bImageSize, u_char presetno, char *serfile, unsigned int baud, int addr);
/* 数据和图片采集数据返回函数 开始*/
int GetWeatherData(Data_DEF *data, int datano);
@ -468,4 +460,26 @@ int GetImage(int devno, IMAGE_DEF *photo);
// 生成一个随机整数
int GeneratingRandomNumber();
#endif //WEATHERCOMM_H
void ClearCameraCmdAllFlag(SIO_PARAM_SERIAL_DEF *pPortParam);
void ClearCameraCmdFormPollCmdBuf(SIO_PARAM_SERIAL_DEF *pPortParam);
int Gm_OpenCameraSerial(SIO_PARAM_SERIAL_DEF *pPortParam, char *serfile, unsigned int baud);
int Gm_SetCameraSerialPortParam(int fd, unsigned int baud);
int GM_CameraComSend(unsigned char * cSendBuf, size_t nSendLen, int fd);
void SendCameraCmdFormPollCmdBuf(SIO_PARAM_SERIAL_DEF *pPortParam);
void Gm_FindCameraCommand(SIO_PARAM_SERIAL_DEF *pPortParam);
void GM_CameraSerialComRecv(SIO_PARAM_SERIAL_DEF *pPortParam);
int GM_IsCloseCamera(SIO_PARAM_SERIAL_DEF *pPortParam);
int GM_CameraSerialTimer(SIO_PARAM_SERIAL_DEF *pPortParam);
#endif // __SENSOR_PROTOCOL_H__

595
app/src/main/cpp/WeatherComm.cpp
Unescape Escape View File

@ -1,595 +0,0 @@
#include <jni.h>
#include <string>
#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 "WeatherComm.h"
#include <sys/time.h>
SIO_PARAM_SERIAL_DEF serialport;
float weatherpntmsg[10];
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_iflag &=~(INLCR|ICRNL);
opt.c_iflag &=~(IXON);/* 流控*/
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));
}
static 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, &param);
// 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);
}
static void setCam3V3Enable(bool enabled)
{
setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
}
/*********************************************************************************
* 气象数据处理 *
**********************************************************************************/
void PortDataProcess( )
{
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: /*拉力*/
LOGE("拉力:%0.3f ", fvalue);
break;
case 9: /*倾角传感器X轴倾角*/
LOGE("X:%0.3f ", fvalue);
break;
case 10: /*倾角传感器Y轴倾角*/
LOGE("Y:%0.3f ", fvalue);
break;
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;
}
}
}
//***************************************************************
//* 按照协议格式化接收数据 *
//***************************************************************
static 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;
}
}
}
static long get_msec(void )
{
struct timeval tv;
gettimeofday(&tv, NULL);
long time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000;
return time_in_msec;
}
//int inum =0;
//int itimecnt=0;
static int weather_comm(SERIAL_PARAM weatherport)
{
int fd = -1;
int len, i,ret, icnt=0;
long ictime, iruntime, isendtime, irecvtime;
//unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x0D,0x09,0x16,0x16};
unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x01,0x09,0x0A,0x16};
//unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x0ff,0x02,0x01,0x16};
//unsigned char sendbuf[] = {0x68,0x01,0x01,0x68,0x02,0x01,0x01,0x04, 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);
setInt(CMD_SET_WTH_POWER, 1);
setInt(CMD_SET_PULL_POWER, 1);
setInt(CMD_SET_ANGLE_POWER, 1);
setInt(CMD_SET_OTHER_POWER, 1);
setInt(CMD_SET_PIC1_POWER, 1);
#if 1
setInt(CMD_SET_485_en0, 1);
setInt(CMD_SET_485_en1, 1);
setInt(CMD_SET_485_en2, 1);
setInt(CMD_SET_485_en3, 1);
setInt(CMD_SET_485_en4, 1);
#else
setInt(CMD_SET_485_en0, 0);
setInt(CMD_SET_485_en1, 0);
setInt(CMD_SET_485_en2, 0);
setInt(CMD_SET_485_en3, 0);
setInt(CMD_SET_485_en4, 0);
#endif
sleep(3);
//ictime = (int)time(NULL);
ictime = get_msec();
for(;;)
{
if(fd < 0)
{
fd = open(weatherport.pathname, O_RDWR | O_NDELAY);
//fd = open(weatherport.pathname, O_RDWR | O_NOCTTY);
if(fd < 0)
{
LOGE("open serial %s fail!", weatherport.pathname);
//perror(weatherport.pathname);
return -1;
} else
LOGE("open serial %s success!", weatherport.pathname);
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;
}
}
//tcdrain(fd);
//sleep(2);
usleep(100);
//iruntime = (int)time(NULL);
iruntime = get_msec();
if((iruntime - ictime > 120000) || (iruntime - ictime < 0))
ictime = iruntime;
if(iruntime - ictime > 20000)
{
memset(szbuf, 0, sizeof(szbuf));
sprintf(szbuf, "气象采样时间=%0.3f秒,停止采样!", (iruntime-ictime)/1000.0);
LOGE("%s", szbuf);
break;
}
if(1 == serialport.RevCmdFlag)
{
//set485WriteMode();
len = write(fd, sendbuf, sizeof(sendbuf));/* 向串囗发送字符串 */
serialport.RevCmdFlag = 0;
LOGE("发送命令时间差%ld毫秒", get_msec()-isendtime);
//isendtime = time(NULL);
isendtime = get_msec();
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);
irecvtime = get_msec();
if((irecvtime-isendtime > 6000) ||(irecvtime - isendtime < 0))
isendtime = irecvtime;
if (irecvtime-isendtime > 500)
{
LOGE("传感器超过%ld毫秒未应答", 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;
//struct timeval tv;
//gettimeofday(&tv, NULL);
//long time_in_microseconds = tv.tv_sec * 1000000 + tv.tv_usec;
//LOGE("Current time in microseconds: %ld\n", time_in_microseconds);
#if 1
memset(portparm.pathname, 0, sizeof(portparm.pathname));
//sprintf(portparm.pathname, "/dev/ttyS1");
sprintf(portparm.pathname, "/dev/ttysWK3");
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(;;)
{
sleep(3);
weather_comm(portparm);
}
return 0;
}

51
app/src/main/cpp/WeatherComm.h
Unescape Escape View File

@ -1,51 +0,0 @@
//
// Created by hyz on 2024/6/5.
//
#ifndef WEATHERCOMM_H
#define WEATHERCOMM_H
#include <string>
#include "GPIOControl.h"
#define MAX_STRING_LEN 32
#define IOT_PARAM_WRITE 0xAE
#define IOT_PARAM_READ 0xAF
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, "serial_port_comm", fmt, ##args)
// 串口参数
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;
typedef struct
{
int cmd;
int value;
int result;
long value2;
char str[MAX_STRING_LEN];
}IOT_PARAM;
void PortDataProcess( );
int serial_port_comm();
static int weather_comm(SERIAL_PARAM weatherport);
int set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char parity, int vtime, int vmin );
#endif //WEATHERCOMM_H

31
app/src/main/cpp/native-lib.cpp
Unescape Escape View File

@ -20,7 +20,7 @@
#include "GPIOControl.h"
#include "serialComm.h"
#include "SensorsProtocol.h"
#include "WeatherComm.h"
//#include "WeatherComm.h"
//#include "jsoncpp/include/json/value.h"
//#include "jsoncpp/include/json/json.h"
#include <json/json.h>
@ -322,7 +322,7 @@ static void InitPLZ()
#if 1
//云台
sensorParam[0].SensorsType = PELCO_D_PROTOCOL;
sensorParam[0].baudrate = 9600;
sensorParam[0].baudrate = 38400;
sensorParam[0].databit = 8;
sensorParam[0].stopbit = 1;
sensorParam[0].parity = '0';
@ -900,51 +900,55 @@ extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnLeft(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, MOVE_LEFT, 0, 0);
CameraPhotoCmd(0, 1, MOVE_LEFT, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnRight(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, MOVE_RIGHT, 0, 0);
CameraPhotoCmd(0, 1, MOVE_RIGHT, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnUp(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, MOVE_UP, 0, 0);
CameraPhotoCmd(0, 1, MOVE_UP, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnDown(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, MOVE_DOWN, 0, 0);
CameraPhotoCmd(0, 1, MOVE_DOWN, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_zoomIn(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, ZOOM_TELE, 0, 0);
CameraPhotoCmd(0, 1, ZOOM_TELE, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_zoomOut(
JNIEnv* env,
jobject /*this*/) {
CameraPhotoCmd(0, 1, ZOOM_WIDE, 0, 0);
CameraPhotoCmd(0, 1, ZOOM_WIDE, 0, 0, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_setSpeed(
JNIEnv* env,
jobject /*this*/, jint speed) {
CameraPhotoCmd(0, 1, OPEN_TOTAL, 0, 0);
//CameraPhotoCmd(0, 1, ZOOM_WIDE, 0, 0);
CameraPhotoCmd(time(NULL), 1, 0, (u_char)(speed/10), speed%10, "/dev/ttyS0", 38400, 1);
return;
CameraPhotoCmd(0, 1, OPEN_TOTAL, 0, 0, "/dev/ttyS0", 38400, 1);
usleep(200000);
CameraPhotoCmd(0, 1, OPEN_MODULE_POWER, 0, 0);
CameraPhotoCmd(0, 1, OPEN_MODULE_POWER, 0, 0, "/dev/ttyS0", 38400, 1);
}
@ -952,21 +956,21 @@ extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_setPreset(
JNIEnv* env,
jobject /*this*/, jint preset) {
CameraPhotoCmd(0, 1, SAVE_PRESETNO, 0, preset);
CameraPhotoCmd(0, 1, SAVE_PRESETNO, 0, preset, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_gotoPreset(
JNIEnv* env,
jobject /*this*/, jint preset) {
CameraPhotoCmd(0, 1, MOVE_PRESETNO, 0, preset);
CameraPhotoCmd(0, 1, MOVE_PRESETNO, 0, preset, "/dev/ttyS0", 38400, 1);
}
extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOnWipers(
JNIEnv* env,
jobject /*this*/) {
int i =0;
}
extern "C" JNIEXPORT void JNICALL
@ -974,6 +978,7 @@ Java_com_xinyingpower_testcomm_MainActivity_turnOffWipers(
JNIEnv* env,
jobject /*this*/) {
int i =0;
}

Write Preview
Loading…
Cancel
Save