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

调整N938相关代码

Browse Source
master
Matthew 10 months ago
parent f28eeb3122
commit 22ca063e00
5 changed files with 3469 additions and 3854 deletions
Show Stats Download Patch File Download Diff File

74
app/src/main/cpp/PhoneDevice.cpp
Unescape Escape View File

@ -1841,3 +1841,77 @@ void CPhoneDevice::UpdateSimcard(const std::string& simcard)
{ {
m_simcard = simcard; m_simcard = simcard;
} }
int CPhoneDevice::GetIceData(IDevice::ICE_INFO *iceInfo, IDevice::ICE_TAIL *iceTail, SENSOR_PARAM sensorParam)
{
Collect_sensor_data(); //15s
Data_DEF airt;
//++等值覆冰厚度, 综合悬挂载荷, 不均衡张力差 置0
iceInfo->equal_icethickness = 0;
iceInfo->tension = 0;
iceInfo->tension_difference = 0;
GetPullValue(2, &airt);
iceInfo->t_sensor_data[0].original_tension = airt.EuValue;
GetPullValue(4, &airt);
iceInfo->t_sensor_data[1].original_tension = airt.EuValue;
GetPullValue(5, &airt);
iceInfo->t_sensor_data[2].original_tension = airt.EuValue;
GetAngleValue(6, &airt, 0);
iceInfo->t_sensor_data[0].deflection_angle = airt.EuValue;
GetAngleValue(6, &airt, 1);
iceInfo->t_sensor_data[0].windage_yaw_angle = airt.EuValue;
GetAngleValue(7, &airt, 0);
iceInfo->t_sensor_data[1].deflection_angle = airt.EuValue;
GetAngleValue(7, &airt, 1);
iceInfo->t_sensor_data[1].windage_yaw_angle = airt.EuValue;
GetAngleValue(13, &airt, 0);
iceInfo->t_sensor_data[2].deflection_angle = airt.EuValue;
GetAngleValue(13, &airt, 1);
iceInfo->t_sensor_data[2].windage_yaw_angle = airt.EuValue;
GetWindSpeedData(&airt);
iceTail->instantaneous_windspeed = airt.EuValue;
GetWindDirectionData(&airt);
iceTail->instantaneous_winddirection = airt.EuValue;//需求无符号整数给出浮点数
GetAirTempData(&airt);
iceTail->air_temperature = airt.EuValue;
GetHumidityData(&airt);
iceTail->humidity = airt.EuValue;//需求无符号整数给出浮点数
return true;
}
int CPhoneDevice::GetWData(IDevice::WEATHER_INFO *weatherInfo)
{
Collect_sensor_data(); //15s
Data_DEF airt;
GetWeatherData(&airt, 0);
weatherInfo->air_temperature = airt.EuValue;
if (airt.AiState == -1) return false;
GetWeatherData(&airt, 1);
weatherInfo->humidity = airt.EuValue;
GetWeatherData(&airt, 2);
weatherInfo->avg_windspeed_10min = airt.EuValue;
weatherInfo->extreme_windspeed = airt.EuValue;
weatherInfo->standard_windspeed = airt.EuValue;
GetWeatherData(&airt, 3);
weatherInfo->avg_winddirection_10min = airt.EuValue;
GetWeatherData(&airt, 4);
weatherInfo->precipitation = airt.EuValue;
GetWeatherData(&airt, 5);
weatherInfo->air_pressure = airt.EuValue;
GetWeatherData(&airt, 6);
weatherInfo->radiation_intensity = airt.EuValue;
return true;
}

3
app/src/main/cpp/PhoneDevice.h
Unescape Escape View File

@ -198,6 +198,9 @@ public:
virtual unsigned long RequestWakelock(unsigned long timeout); virtual unsigned long RequestWakelock(unsigned long timeout);
virtual bool ReleaseWakelock(unsigned long wakelock); virtual bool ReleaseWakelock(unsigned long wakelock);
virtual int GetWData(WEATHER_INFO *weatherInfo);
virtual int GetIceData(ICE_INFO *iceInfo, ICE_TAIL *icetail, SENSOR_PARAM sensorParam);
bool GetNextScheduleItem(uint32_t tsBasedZero, uint32_t scheduleTime, vector<uint32_t>& items); bool GetNextScheduleItem(uint32_t tsBasedZero, uint32_t scheduleTime, vector<uint32_t>& items);
void UpdatePosition(double lon, double lat, double radius, time_t ts); void UpdatePosition(double lon, double lat, double radius, time_t ts);

195
app/src/main/cpp/SensorsProtocol.cpp
Unescape Escape View File

@ -19,12 +19,15 @@
#include <asm/termbits.h> #include <asm/termbits.h>
#include <time.h> #include <time.h>
#include "GPIOControl.h" #include "GPIOControl.h"
#include "serialComm.h" #include "SerialComm.h"
#include "SensorsProtocol.h"
#include <sys/time.h> #include <sys/time.h>
#include "SensorsProtocol.h"
#include <AndroidHelper.h>
#include <Client/SensorsProtocol.h>
//#include "Eint.h" //#include "Eint.h"
#include <algorithm>
SIO_PARAM_SERIAL_DEF serialport[MAX_SERIAL_PORT_NUM]; SIO_PARAM_SERIAL_DEF serialport[MAX_SERIAL_PORT_NUM];
SERIAL_PARAM devparam[MAX_SERIAL_DEV_NUM]; SERIAL_PARAM devparam[MAX_SERIAL_DEV_NUM];
SRDT_DEF srdt; SRDT_DEF srdt;
@ -93,7 +96,7 @@ static void setCam3V3Enable(bool enabled)
static void PortDataProcess(void) static void PortDataProcess(void)
{ {
float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/; float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
//WORD uDevAddr; //uint16_t uDevAddr;
unsigned char cmdidx; unsigned char cmdidx;
int i, j, aipnt, datanum; int i, j, aipnt, datanum;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
@ -203,7 +206,7 @@ static void PortDataProcess( void )
static void RecvData(u_char *buf, int len)// 规约读数据处理 static void RecvData(u_char *buf, int len)// 规约读数据处理
{ {
int i, ictime; int i, ictime;
//WORD crc, check; //uint16_t crc, check;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
pPortParam = &serialport; pPortParam = &serialport;
@ -304,12 +307,12 @@ static void RecvData(u_char *buf, int len)// 规约读数据处理
} }
} }
static LONG get_msec(void ) static int64_t get_msec(void)
{ {
struct timeval tv; struct timeval tv;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
LONG time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000; int64_t time_in_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000;
return time_in_msec; return time_in_msec;
} }
@ -319,7 +322,7 @@ static int weather_comm(SERIAL_PARAM weatherport)
{ {
int fd = -1; int fd = -1;
int len, i, ret, icnt = 0; int len, i, ret, icnt = 0;
LONG ictime, iruntime, isendtime, irecvtime; int64_t ictime, iruntime, isendtime, irecvtime;
unsigned char sendbuf[] = { 0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16 }; unsigned char sendbuf[] = { 0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16 };
char recvbuf[256], szbuf[512]; char recvbuf[256], szbuf[512];
//char serial_description[] = "/dev/ttyS0"; //char serial_description[] = "/dev/ttyS0";
@ -400,7 +403,8 @@ static int weather_comm(SERIAL_PARAM weatherport)
if (len < 0) { if (len < 0) {
LOGE("write data error \n"); LOGE("write data error \n");
return -1; return -1;
} else { }
else {
memset(szbuf, 0, sizeof(szbuf)); memset(szbuf, 0, sizeof(szbuf));
sprintf(szbuf, "Send："); sprintf(szbuf, "Send：");
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
@ -470,7 +474,7 @@ int serial_port_comm()
//struct timeval tv; //struct timeval tv;
//gettimeofday(&tv, NULL); //gettimeofday(&tv, NULL);
//LONG time_in_microseconds = tv.tv_sec * 1000000 + tv.tv_usec; //int64_t time_in_microseconds = tv.tv_sec * 1000000 + tv.tv_usec;
//LOGE("Current time in microseconds: %ld\n", time_in_microseconds); //LOGE("Current time in microseconds: %ld\n", time_in_microseconds);
@ -529,10 +533,10 @@ static speed_t getBaudrate(unsigned int baudrate)
} }
} }
static LONG get_msec() static int64_t get_msec()
{ {
struct timeval tv; struct timeval tv;
LONG time_in_msec=0; int64_t time_in_msec = 0;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
time_in_msec = tv.tv_sec; time_in_msec = tv.tv_sec;
@ -703,22 +707,22 @@ void BytestreamLOG(int commid, char* describe, u_char* buf, int len, char flag)
switch (flag) switch (flag)
{ {
case 'E': case 'E':
LOGE("%s", szbuf); ALOGE("%s", szbuf);
break; break;
case 'I': case 'I':
LOGI("%s", szbuf); ALOGI("%s", szbuf);
break; break;
case 'D': case 'D':
LOGD("%s", szbuf); ALOGD("%s", szbuf);
break; break;
case 'V': case 'V':
LOGV("%s", szbuf); ALOGI("%s", szbuf);
break; break;
case 'W': case 'W':
LOGW("%s", szbuf); ALOGW("%s", szbuf);
break; break;
default: default:
LOGI("%s", szbuf); ALOGI("%s", szbuf);
break; break;
} }
} }
@ -767,13 +771,13 @@ void Gm_CloseSerialPort()
} }
/******************************************************************************* /*******************************************************************************
函数名称: int GM_SerialComSend(const BYTE * cSendBuf, DWORD nSendLen, int commid) 函数名称: int GM_SerialComSend(const uint8_t * cSendBuf, uint32_t nSendLen, int commid)
功能说明:串口发送数据 返回实际发送的字节数 功能说明:串口发送数据 返回实际发送的字节数
输入参数: 输入参数:
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
int GM_SerialComSend(unsigned char * cSendBuf, LONG nSendLen, int commid) int GM_SerialComSend(unsigned char * cSendBuf, size_t nSendLen, int commid)
{ {
int i, len; int i, len;
char szbuf[512]; char szbuf[512];
@ -1077,8 +1081,9 @@ void Gm_InitSerialComm(SENSOR_PARAM *sensorParam, char *filedir)
if (NULL == filedir) if (NULL == filedir)
return; return;
memset(srdt.filedir, 0, sizeof(srdt.filedir)); memset(srdt.filedir, 0, sizeof(srdt.filedir));
memmove(srdt.filedir, filedir, MIN(sizeof(srdt.filedir), strlen(filedir))); memmove(srdt.filedir, filedir, std::min(sizeof(srdt.filedir), strlen(filedir)));
FindDevUseSerialCommNo(); FindDevUseSerialCommNo();
#if 0 #if 0
//Collect_sensor_data(); //Collect_sensor_data();
//#else //#else
@ -1258,7 +1263,7 @@ void GM_StartSerialComm()
{ {
int i, j, commid; int i, j, commid;
char szbuf[64], logbuf[128]; char szbuf[64], logbuf[128];
//LONG polltime=0; //int64_t polltime=0;
// 此处不能对轮询设备标识清零，否则如果先起摄像机，就会导致poll乱掉 // 此处不能对轮询设备标识清零，否则如果先起摄像机，就会导致poll乱掉
//memset((void*)srdt.curdevidx, 0, sizeof(srdt.curdevidx)); //memset((void*)srdt.curdevidx, 0, sizeof(srdt.curdevidx));
@ -1407,7 +1412,7 @@ void GM_StartSerialComm()
#if 1 #if 1
// 启动使用串口拍照 // 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx) void GM_StartSerialCameraPhoto(uint8_t channel, int cmdidx)
{ {
int i, flag = 0; int i, flag = 0;
char szbuf[128], logbuf[128]; char szbuf[128], logbuf[128];
@ -1613,7 +1618,7 @@ void GM_IsCloseSensors()
{ {
int i, j; int i, j;
char buf[256]; char buf[256];
LONG lctime; int64_t lctime;
lctime = get_msec(); lctime = get_msec();
for (i = 0; i < MAX_SERIAL_DEV_NUM; i++) for (i = 0; i < MAX_SERIAL_DEV_NUM; i++)
@ -1768,22 +1773,22 @@ void DebugLog(int commid, char *szbuf, char flag)
switch (flag) switch (flag)
{ {
case 'E': case 'E':
LOGE("%s", szbuf); ALOGE("%s", szbuf);
break; break;
case 'I': case 'I':
LOGI("%s", szbuf); ALOGI("%s", szbuf);
break; break;
case 'D': case 'D':
LOGD("%s", szbuf); ALOGD("%s", szbuf);
break; break;
case 'V': case 'V':
LOGV("%s", szbuf); ALOGI("%s", szbuf);
break; break;
case 'W': case 'W':
LOGW("%s", szbuf); ALOGW("%s", szbuf);
break; break;
default: default:
LOGI("%s", szbuf); ALOGI("%s", szbuf);
break; break;
} }
} }
@ -1992,8 +1997,8 @@ void CameraPhotoPortDataProcess( int devno)
SIO_PARAM_SERIAL_DEF *curserial; SIO_PARAM_SERIAL_DEF *curserial;
int img_file_size, packetnum, iNo, packsize, i = 0, presetno, iphototime, pidx; int img_file_size, packetnum, iNo, packsize, i = 0, presetno, iphototime, pidx;
char szbuf[128]; char szbuf[128];
WORD uDevAddr; uint16_t uDevAddr;
BYTE cmdidx, recvend; uint8_t cmdidx, recvend;
pPortParam = &srdt.ms_dev[devno]; pPortParam = &srdt.ms_dev[devno];
curserial = &serialport[devparam[devno].commid]; curserial = &serialport[devparam[devno].commid];
@ -2189,7 +2194,7 @@ void SendCmdFormPollCmdBuf( int port )
{ {
char buf[128]; char buf[128];
int len, ret; int len, ret;
LONG lctime; int64_t lctime;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
pPortParam = &serialport[port]; pPortParam = &serialport[port];
@ -2329,10 +2334,10 @@ void ClearCmdFormPollCmdBuf(int port)
int FindNextCameraPhotoCommand(int devidx) int FindNextCameraPhotoCommand(int devidx)
{ {
int imagesize = 3, cmdno; int imagesize = 3, cmdno;
BYTE channel, imagequality=90, presetno; uint8_t channel, imagequality = 90, presetno;
WORD packetsize; uint16_t packetsize;
LONG lcurtime; int64_t lcurtime;
BYTE cmdidx=0x10; uint8_t cmdidx = 0x10;
char szbuf[128]; char szbuf[128];
//如果命令缓冲区仍有命令，则退出本函数 //如果命令缓冲区仍有命令，则退出本函数
@ -2377,7 +2382,7 @@ int FindNextCameraPhotoCommand(int devidx)
memset(szbuf, 0, sizeof(szbuf)); memset(szbuf, 0, sizeof(szbuf));
sprintf(szbuf, "time=%lldms", lcurtime - srdt.ms_dev[devidx].FirstCmdTimeCnt); sprintf(szbuf, "time=%lldms", lcurtime - srdt.ms_dev[devidx].FirstCmdTimeCnt);
DebugLog(devparam[devidx].commid, szbuf, 'I'); DebugLog(devparam[devidx].commid, szbuf, 'I');
packetsize = (WORD)MAX_PHOTO_FRAME_LEN; packetsize = (uint16_t)MAX_PHOTO_FRAME_LEN;
srdt.sendphotocmdcnt++; srdt.sendphotocmdcnt++;
srdt.imagepacketnum = 0; srdt.imagepacketnum = 0;
srdt.errorPhotoNoCnt = 0; srdt.errorPhotoNoCnt = 0;
@ -2428,7 +2433,7 @@ int FindNextCameraPhotoCommand(int devidx)
case 10003: /* 读取历史图片（15H）*/ case 10003: /* 读取历史图片（15H）*/
cmdidx = 0x15; cmdidx = 0x15;
packetsize = (WORD)MAX_PHOTO_FRAME_LEN; packetsize = (uint16_t)MAX_PHOTO_FRAME_LEN;
break; break;
case 10005: /* 关闭功能*/ case 10005: /* 关闭功能*/
@ -2551,7 +2556,7 @@ int FindNextCameraPhotoCommand(int devidx)
return 1; return 1;
default: default:
imagesize = 0xFF; imagesize = 0xFF;
packetsize = (WORD)srdt.ms_dev[devidx].SerialCmdidx; packetsize = (uint16_t)srdt.ms_dev[devidx].SerialCmdidx;
cmdidx = 0x11; cmdidx = 0x11;
#if 0 #if 0
if (0 == srdt.IsSleep) if (0 == srdt.IsSleep)
@ -2578,7 +2583,7 @@ int FindNextCameraPhotoCommand(int devidx)
/********************************************************************************* /*********************************************************************************
生成 CameraPhoto命令 生成 CameraPhoto命令
**********************************************************************************/ **********************************************************************************/
void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoParam, BYTE Threep, int phototime ) void MakeCameraPhotoCommand(int portno, uint8_t cmdidx, int OneParam, uint16_t TwoParam, uint8_t Threep, int phototime)
{ {
int i, icurtime; int i, icurtime;
u_char *sendbuf; u_char *sendbuf;
@ -2591,10 +2596,10 @@ void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoPara
sendbuf[i++] = 0x00; /* 强制等待时间*/ sendbuf[i++] = 0x00; /* 强制等待时间*/
sendbuf[i++] = 0x00; /* 强制等待时间*/ sendbuf[i++] = 0x00; /* 强制等待时间*/
sendbuf[i++] = 0x68; /* 起始字符*/ sendbuf[i++] = 0x68; /* 起始字符*/
sendbuf[i++] = (BYTE)0x00; /* length */ sendbuf[i++] = (uint8_t)0x00; /* length */
sendbuf[i++] = (BYTE)0x00; /* length */ sendbuf[i++] = (uint8_t)0x00; /* length */
sendbuf[i++] = 0x68; /* 起始字符*/ sendbuf[i++] = 0x68; /* 起始字符*/
sendbuf[i++] = (BYTE)devparam[portno].devaddr;/* 传感器地址*/ sendbuf[i++] = (uint8_t)devparam[portno].devaddr;/* 传感器地址*/
sendbuf[i++] = cmdidx; /* 命令字*/ sendbuf[i++] = cmdidx; /* 命令字*/
switch (cmdidx) switch (cmdidx)
{ {
@ -2605,7 +2610,7 @@ void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoPara
sendbuf[i++] = 0x00; /* 波特率*/ sendbuf[i++] = 0x00; /* 波特率*/
sendbuf[i++] = 0x00; sendbuf[i++] = 0x00;
sendbuf[i++] = 0x00; sendbuf[i++] = 0x00;
sendbuf[i++] = (BYTE)OneParam; sendbuf[i++] = (uint8_t)OneParam;
sendbuf[i++] = 0x08; /* 数据位*/ sendbuf[i++] = 0x08; /* 数据位*/
sendbuf[i++] = 0x00; /* 校验位*/ sendbuf[i++] = 0x00; /* 校验位*/
sendbuf[i++] = 0x01; /* 停止位*/ sendbuf[i++] = 0x01; /* 停止位*/
@ -2634,20 +2639,20 @@ void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoPara
sendbuf[i++] = LOBYTE(HIWORD(OneParam)); sendbuf[i++] = LOBYTE(HIWORD(OneParam));
sendbuf[i++] = HIBYTE(LOWORD(OneParam)); sendbuf[i++] = HIBYTE(LOWORD(OneParam));
sendbuf[i++] = LOBYTE(LOWORD(OneParam)); sendbuf[i++] = LOBYTE(LOWORD(OneParam));
sendbuf[i++] = (BYTE)TwoParam; /* 是否需要保存*/ sendbuf[i++] = (uint8_t)TwoParam; /* 是否需要保存*/
break; break;
} }
sendbuf[i] = CalLpc((u_char *)&sendbuf[6], i - 6); sendbuf[i] = CalLpc((u_char *)&sendbuf[6], i - 6);
i += 1; i += 1;
sendbuf[i++] = 0x16; /* 信息尾*/ sendbuf[i++] = 0x16; /* 信息尾*/
sendbuf[3] = (BYTE)((i-10)>>8); sendbuf[3] = (uint8_t)((i - 10) >> 8);
sendbuf[4] = (BYTE)(i-10); sendbuf[4] = (uint8_t)(i - 10);
serialport[devparam[portno].commid].cmdlen = i; serialport[devparam[portno].commid].cmdlen = i;
//return; //return;
} }
// 准备发送云台指令 // 准备发送云台指令
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd) int Gm_CtrlPtzCmd(u_char channel, uint32_t ptzcmd)
{ {
int i; int i;
char szbuf[64]; char szbuf[64];
@ -2777,21 +2782,21 @@ int Gm_Camera_Timer()
/******************************************************************************** /********************************************************************************
* 生成 PELCO_P 命令 * * 生成 PELCO_P 命令 *
*********************************************************************************/ *********************************************************************************/
void Gm_SendPelco_pCommand( DWORD cmdtype) void Gm_SendPelco_pCommand(uint32_t cmdtype)
{ {
int len; int len;
BYTE commandbuf[32]; uint8_t commandbuf[32];
char buf[128]; char buf[128];
len = 0; len = 0;
commandbuf[len++] = (BYTE)0xA0; commandbuf[len++] = (uint8_t)0xA0;
commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr; commandbuf[len++] = (uint8_t)devparam[srdt.usecameradevidx].devaddr;
commandbuf[len++] = (BYTE)(cmdtype>>24); commandbuf[len++] = (uint8_t)(cmdtype >> 24);
commandbuf[len++] = (BYTE)(cmdtype>>16); commandbuf[len++] = (uint8_t)(cmdtype >> 16);
commandbuf[len++] = (BYTE)(cmdtype>>8); commandbuf[len++] = (uint8_t)(cmdtype >> 8);
commandbuf[len++] = (BYTE)(cmdtype); commandbuf[len++] = (uint8_t)(cmdtype);
commandbuf[len++] = (BYTE)0xAF; commandbuf[len++] = (uint8_t)0xAF;
commandbuf[len] = (BYTE)Gm_Pelco_pXORCheck(commandbuf, len); commandbuf[len] = (uint8_t)Gm_Pelco_pXORCheck(commandbuf, len);
len++; len++;
serialport[srdt.camerauseserial].cmdlen = len; serialport[srdt.camerauseserial].cmdlen = len;
Gm_SetSerialPortParam(srdt.camerauseserial); Gm_SetSerialPortParam(srdt.camerauseserial);
@ -2812,10 +2817,10 @@ void Gm_SendPelco_pCommand( DWORD cmdtype)
ClearCmdFormPollCmdBuf(srdt.camerauseserial); ClearCmdFormPollCmdBuf(srdt.camerauseserial);
} }
BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len ) uint8_t Gm_Pelco_pXORCheck(uint8_t *msg, int len)
{ {
int i; int i;
BYTE checkvalue=0; uint8_t checkvalue = 0;
if (len <= 0) if (len <= 0)
return checkvalue; return checkvalue;
@ -2828,21 +2833,21 @@ BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len )
/******************************************************************************** /********************************************************************************
* 生成 PELCO_D 命令 * * 生成 PELCO_D 命令 *
*********************************************************************************/ *********************************************************************************/
void Gm_SendPelco_DCommand( DWORD cmdtype) void Gm_SendPelco_DCommand(uint32_t cmdtype)
{ {
int len; int len;
BYTE commandbuf[32]; uint8_t commandbuf[32];
char buf[128]; char buf[128];
len = 0; len = 0;
#if 1 /* Pelco_D*/ #if 1 /* Pelco_D*/
commandbuf[len++] = (BYTE)0xFF; commandbuf[len++] = (uint8_t)0xFF;
commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr; commandbuf[len++] = (uint8_t)devparam[srdt.usecameradevidx].devaddr;
commandbuf[len++] = (BYTE)(cmdtype>>24); commandbuf[len++] = (uint8_t)(cmdtype >> 24);
commandbuf[len++] = (BYTE)(cmdtype>>16); commandbuf[len++] = (uint8_t)(cmdtype >> 16);
commandbuf[len++] = (BYTE)(cmdtype>>8); commandbuf[len++] = (uint8_t)(cmdtype >> 8);
commandbuf[len++] = (BYTE)(cmdtype); commandbuf[len++] = (uint8_t)(cmdtype);
commandbuf[len] = (BYTE)Gm_Pelco_DCheck(commandbuf, len); commandbuf[len] = (uint8_t)Gm_Pelco_DCheck(commandbuf, len);
#endif #endif
len++; len++;
serialport[srdt.camerauseserial].cmdlen = len; serialport[srdt.camerauseserial].cmdlen = len;
@ -2864,10 +2869,10 @@ void Gm_SendPelco_DCommand( DWORD cmdtype)
} }
// 计算Pelco_D校验 // 计算Pelco_D校验
BYTE Gm_Pelco_DCheck( BYTE *msg, int len ) uint8_t Gm_Pelco_DCheck(uint8_t *msg, int len)
{ {
int i; int i;
BYTE checkvalue=0; uint8_t checkvalue = 0;
if (len <= 0) if (len <= 0)
return checkvalue; return checkvalue;
@ -2912,7 +2917,7 @@ int FindNextShxyProtocolCommand( int devidx )
/********************************************************************************* /*********************************************************************************
生成下发命令 生成下发命令
**********************************************************************************/ **********************************************************************************/
void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx) void MakeShxyProtocolPollCommand(int portno, uint8_t cmdidx)
{ {
int i, length = 0; int i, length = 0;
int newaddr = 9, baud = 9600, stopbit = 1, parity = 0; int newaddr = 9, baud = 9600, stopbit = 1, parity = 0;
@ -2928,10 +2933,10 @@ void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx)
sendbuf[i++] = 0x00; // 强制等待时间 sendbuf[i++] = 0x00; // 强制等待时间
sendbuf[i++] = 0x00; // sendbuf[i++] = 0x00; //
sendbuf[i++] = 0x68; // 起始字符 sendbuf[i++] = 0x68; // 起始字符
sendbuf[i++] = (BYTE)0x00; // length sendbuf[i++] = (uint8_t)0x00; // length
sendbuf[i++] = (BYTE)0x00; // length sendbuf[i++] = (uint8_t)0x00; // length
sendbuf[i++] = 0x68; sendbuf[i++] = 0x68;
sendbuf[i++] = (BYTE)devparam[portno].devaddr; // 传感器地址 sendbuf[i++] = (uint8_t)devparam[portno].devaddr; // 传感器地址
sendbuf[i++] = cmdidx; // 命令信息0x06 sendbuf[i++] = cmdidx; // 命令信息0x06
switch (cmdidx) switch (cmdidx)
{ {
@ -2979,7 +2984,7 @@ unsigned char CalLpc(unsigned char *msg, int len)
void ShxyProtocolRecvData(int devno, u_char *buf, int len)// 规约读数据处理 void ShxyProtocolRecvData(int devno, u_char *buf, int len)// 规约读数据处理
{ {
int i, ictime; int i, ictime;
//WORD crc, check; //uint16_t crc, check;
//SERIAL_DEV_DEF *pPortParam; //SERIAL_DEV_DEF *pPortParam;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
@ -3034,7 +3039,7 @@ void ShxyProtocolRecvData(int devno, u_char *buf, int len)// 规约读数据处
break; break;
} }
if(CheckShxyProtocolLpcError(pPortParam->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE) if (CheckShxyProtocolLpcError(pPortParam->m_au8RecvBuf, pPortParam->m_iRecvLen) == 1)
{ {
ShxyProtocolDataProcess(devno); ShxyProtocolDataProcess(devno);
pPortParam->m_iRevStatus = 0; pPortParam->m_iRevStatus = 0;
@ -3078,7 +3083,7 @@ void ShxyProtocolRecvData(int devno, u_char *buf, int len)// 规约读数据处
//******************************************************************************** //********************************************************************************
int CheckShxyProtocolLpcError(u_char* msg, int len) int CheckShxyProtocolLpcError(u_char* msg, int len)
{ {
int bRetval = FALSE; int bRetval = 0;
int iCheckLen; int iCheckLen;
if (0x68 == msg[0]) if (0x68 == msg[0])
@ -3092,7 +3097,7 @@ int CheckShxyProtocolLpcError( u_char* msg, int len )
iCheckLen = msg[1]; iCheckLen = msg[1];
if (CalLpc(&msg[4], iCheckLen + 2) != msg[len - 2]) if (CalLpc(&msg[4], iCheckLen + 2) != msg[len - 2])
return bRetval; return bRetval;
bRetval = TRUE; bRetval = 1;
} }
return bRetval; return bRetval;
} }
@ -3103,8 +3108,8 @@ int CheckShxyProtocolLpcError( u_char* msg, int len )
void ShxyProtocolDataProcess(int devno) void ShxyProtocolDataProcess(int devno)
{ {
float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/; float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
WORD uDevAddr; uint16_t uDevAddr;
BYTE cmdidx; uint8_t cmdidx;
int i, j, aipnt, datanum; int i, j, aipnt, datanum;
SERIAL_DEV_DEF *pPortParam; SERIAL_DEV_DEF *pPortParam;
SIO_PARAM_SERIAL_DEF *curserial; SIO_PARAM_SERIAL_DEF *curserial;
@ -3136,10 +3141,10 @@ void ShxyProtocolDataProcess( int devno)
// ++++++++++++++++++++++++++++ // ++++++++++++++++++++++++++++
//g_SelfTest.SensorsFault |= (0x800<<aipnt); //g_SelfTest.SensorsFault |= (0x800<<aipnt);
*(BYTE*)fvalua = curserial->m_au8RecvBuf[9]; *(uint8_t*)fvalua = curserial->m_au8RecvBuf[9];
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[8]; *((uint8_t*)fvalua + 1) = curserial->m_au8RecvBuf[8];
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[7]; *((uint8_t*)fvalua + 2) = curserial->m_au8RecvBuf[7];
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[6]; *((uint8_t*)fvalua + 3) = curserial->m_au8RecvBuf[6];
if ((fvalue < -59) || (fvalue > 59)) if ((fvalue < -59) || (fvalue > 59))
{ {
frnb = (GeneratingRandomNumber() % 101 - 50) / 1000.0; frnb = (GeneratingRandomNumber() % 101 - 50) / 1000.0;
@ -3159,10 +3164,10 @@ void ShxyProtocolDataProcess( int devno)
//XslantSec[aipnt][srdt.SectimesamplingCnt[0]] = (short)slantpntmsg[aipnt][0].EuValue; //XslantSec[aipnt][srdt.SectimesamplingCnt[0]] = (short)slantpntmsg[aipnt][0].EuValue;
//srdt.SectimesamplingCnt[0] += 1; //srdt.SectimesamplingCnt[0] += 1;
*(BYTE*)fvalua = curserial->m_au8RecvBuf[13]; *(uint8_t*)fvalua = curserial->m_au8RecvBuf[13];
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[12]; *((uint8_t*)fvalua + 1) = curserial->m_au8RecvBuf[12];
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[11]; *((uint8_t*)fvalua + 2) = curserial->m_au8RecvBuf[11];
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[10]; *((uint8_t*)fvalua + 3) = curserial->m_au8RecvBuf[10];
//if ((gDisSunRain & 0x20) == 0x20) //if ((gDisSunRain & 0x20) == 0x20)
{ {
sprintf(szbuf, "%sY =%0.3f ", szbuf, fvalue); sprintf(szbuf, "%sY =%0.3f ", szbuf, fvalue);
@ -3194,10 +3199,10 @@ void ShxyProtocolDataProcess( int devno)
+ (curserial->m_au8RecvBuf[j + 3] << 8) + curserial->m_au8RecvBuf[j + 4]; + (curserial->m_au8RecvBuf[j + 3] << 8) + curserial->m_au8RecvBuf[j + 4];
else else
{ {
*(BYTE*)fvalua = curserial->m_au8RecvBuf[j+4]; *(uint8_t*)fvalua = curserial->m_au8RecvBuf[j + 4];
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[j+3]; *((uint8_t*)fvalua + 1) = curserial->m_au8RecvBuf[j + 3];
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[j+2]; *((uint8_t*)fvalua + 2) = curserial->m_au8RecvBuf[j + 2];
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1]; *((uint8_t*)fvalua + 3) = curserial->m_au8RecvBuf[j + 1];
} }
switch (curserial->m_au8RecvBuf[j]) switch (curserial->m_au8RecvBuf[j])
{ {
@ -3489,7 +3494,7 @@ int GeneratingRandomNumber(void)
int ictime, randomdate; int ictime, randomdate;
/* 生成随机数n-m -> rand()%(m-n+1)+n*/ /* 生成随机数n-m -> rand()%(m-n+1)+n*/
ictime = (int)time(NULL); ictime = (int)time(NULL);
srand((DWORD)ictime); srand((uint32_t)ictime);
randomdate = rand(); randomdate = rand();
return randomdate; return randomdate;
} }

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

@ -1,467 +0,0 @@
//
// Created by hyz on 2024/6/5.
//
#ifndef WEATHERCOMM_H
#define WEATHERCOMM_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
#endif
#define LOBYTE(w) ((unsigned char)(w))
#define HIBYTE(w) ((unsigned char)(((unsigned short)(w) >> 8) & 0xFF))
#define LOWORD(l) ((WORD)(l))
#define HIWORD(l) ((WORD)((DWORD)(l) >> 16))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX_STRING_LEN 32
#define IOT_PARAM_WRITE 0xAE
#define IOT_PARAM_READ 0xAF
#define MAX_SERIAL_DEV_NUM 25 /* 最大接串口传感器数量*/
#define MAX_SERIAL_PORT_NUM 5
#define MAX_DEV_VALUE_NUM 12 /* 一台装置最大的采样值数量*/
#define WEATHER_PROTOCOL 1 /* 温湿度协议序号*/
#define WIND_PROTOCOL 2 /* 风速风向协议序号*/
#define SLANT_PROTOCOL 3 /* 倾斜角协议序号*/
#define RALLY_PROTOCOL 4 /* 拉力协议序号*/
#define PELCO_P_PROTOCOL 5 /* 摄像机Pelco_P协议序号*/
#define PELCO_D_PROTOCOL 6 /* 摄像机Pelco_D协议序号*/
#define SERIALCAMERA_PROTOCOL 8 /* 串口摄像机协议序号*/
#define RESERVE2_PROTOCOL 17 /* 备用2协议序号*/
#define RESERVE4_PROTOCOL 19 /* 备用4协议序号*/
#define RESERVE5_PROTOCOL 20 /* 备用5协议序号*/
#define INVALID_PROTOCOL 21 /* 无效协议序号*/
#define AirTempNo 0 /* 空气温度数据存储序号*/
#define HumidityNo 1 /* 相对湿度数据存储序号*/
#define WindSpeedNo 2 /* 风速数据存储序号*/
#define WindDirectionNo 3 /* 风向数据存储序号*/
#define RainfallNo 4 /* 雨量数据存储序号*/
#define AtmosNo 5 /* 大气压数据存储序号*/
#define OpticalRadiationNo 6 /* 日照（光辐射）数据存储序号*/
#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要素)*/
#define RALLY_DATA_NUM 2 /* 拉力数据最大数量(一般是1个)*/
#define SLANTANGLE_DATA_NUM 3 /* 倾角数据最大数量(一般只有X轴和Y轴值)*/
#define PTZ_MOVETIME 1 // 云台移动等待时间为1秒
#define MAX_CHANNEL_NUM 2 /* 视频通道最大通道*/
#define MAX_PHOTO_FRAME_LEN 1024 /* 图片数据一包最大长度*/
#define MAX_PHOTO_PACKET_NUM 1024 /* 图片最大包数（图片最大定为1MB）*/
#define RECVDATA_MAXLENTH 2048 /* 接收数据缓冲区最大值*/
#define TIMER_CNT 50 // Poll命令定时器时间 5 ms
#define SENDDATA_MAXLENTH RECVDATA_MAXLENTH /* 正常发送数据缓冲区最大值*/
// 摄像机控制命令宏定义
#define Cmd_Cancel 0x00000000 // 关闭功能
#define SET_PRESETNO 0x00030000 // 设置预置点
#define MOVE_TO_PRESETNO 0x00070000 // 调用预置点
/* 摄像机PELCO-P控制命令宏定义*/
#define P_Auto_Scan 0x20000000 /* 自动扫描功能控制(1/0 打开/关闭该功能)*/
#define P_IRIS_CLOSE 0x08000000 /* 光圈缩小(1 有效)*/
#define P_IRIS_OPEN 0x04000000 /* 光圈放大(1 有效)*/
#define P_FOCUS_NEAR 0x02000000 /* 近距离聚焦(1 有效)*/
#define P_FOCUS_FAR 0x01000000 /* 远距离聚焦(1 有效)*/
#define P_ZOOM_WIDE 0x00400000 /* 远离物体(1 有效)*/
#define P_ZOOM_TELE 0x00200000 /* 接近物体(1 有效)*/
#define P_MOVE_DOWN 0x0010001f /* 向下移动镜头(1 有效)*/
#define P_MOVE_UP 0x0008001f /* 向上移动镜头(1 有效)*/
#define P_MOVE_LEFT 0x00041f00 /* 向左移动镜头(1 有效)*/
#define P_MOVE_RIGHT 0x00021f00 /* 向右移动镜头(1 有效)*/
// 摄像机PELCO-D控制命令宏定义
#define D_Auto_Scan 0x10000000 /* 自动扫描功能控制(1/0 打开/关闭该功能)*/
#define D_IRIS_CLOSE 0x04000000 /* 光圈缩小(1 有效)*/
#define D_IRIS_OPEN 0x02000000 /* 光圈放大(1 有效)*/
#define D_FOCUS_NEAR 0x01000000 /* 近距离聚焦(1 有效)*/
#define D_FOCUS_FAR 0x00800000 /* 远距离聚焦(1 有效)*/
#define D_ZOOM_WIDE 0x00400000 /* 远离物体(1 有效)*/
#define D_ZOOM_TELE 0x00200000 /* 接近物体(1 有效)*/
#define D_MOVE_DOWN 0x0010002d /* 向下移动镜头(1 有效)*/
#define D_MOVE_UP 0x0008002d /* 向上移动镜头(1 有效)*/
#define D_MOVE_LEFT 0x00042d00 /* 向左移动镜头(1 有效)*/
#define D_MOVE_RIGHT 0x00022d00 /* 向右移动镜头(1 有效)*/
/* 摄像机下发命令宏定义*/
#define Take_Photo 0 /* 拍照*/
#define Stop_Baud 10000 /* 设置球机波特率*/
#define Stop_Cmd 10005 /* 取消或停止指令*/
#define Auto_Scan 10006 /* 自动扫描功能控制(1/0 打开/关闭该功能)*/
#define IRIS_CLOSE 10007 /* 光圈缩小(1 有效)*/
#define IRIS_OPEN 10008 /* 光圈放大(1 有效)*/
#define FOCUS_NEAR 10009 /* 近距离聚焦(1 有效)*/
#define FOCUS_FAR 10010 /* 远距离聚焦(1 有效)*/
#define ZOOM_WIDE 10011 /* 远离物体(1 有效)*/
#define ZOOM_TELE 10012 /* 接近物体(1 有效)*/
#define MOVE_DOWN 10013 /* 向下移动镜头(1 有效)*/
#define MOVE_UP 10014 /* 向上移动镜头(1 有效)*/
#define MOVE_LEFT 10015 /* 向左移动镜头(1 有效)*/
#define MOVE_RIGHT 10016 /* 向右移动镜头(1 有效)*/
#define MOVE_PRESETNO 10017 // 调用预置点
#define SAVE_PRESETNO 10018 // 设置预置点
#define SPEED_DOME_CAMERA 0 /* 球机摄像机*/
#define SERIAL_CAMERA 2 /* 串口摄像机a*/
#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) /* 草绿色*/
#define LOGV(fmt, args...) __android_log_print(ANDROID_LOG_VERBOSE, "serial_port_comm", fmt, ##args)/* 白色*/
#define LOGW(fmt, args...) __android_log_print(ANDROID_LOG_WARN, "Sensors_Protocol", fmt, ##args) /* 黄色*/
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, "Sensors_Protocol", fmt, ##args) /* 蓝色*/
#define HexCharToInt( c ) (((c) >= '0') && ((c) <= '9') ? (c) - '0' : ((c) >= 'a') && ((c) <= 'f') ? (c) - 'a' + 10 :((c) >= 'A') && ((c) <= 'F') ? (c) - 'A' + 10 : 0 )
typedef struct
{
int cmd;
int value;
int result;
LONG value2;
char str[MAX_STRING_LEN];
}IOT_PARAM;
//SDS包类型结构
typedef struct
{
BYTE PortIdx; // 信息类型
WORD MsgType; // 信息类型
int MsgLen; // 信息长度
u_char MsgData[RECVDATA_MAXLENTH];
} RTUMSG;
typedef struct
{
float fFactor; // 数据系数
float EuValueDelta; // 数据工程值偏移
} AI_PARAM;
typedef struct
{
AI_PARAM AiParam; // 数据点配置参数
int AiState; // 数据标识(-1：采样失败；0:没有采样；1：正在采样；2：采样结束；3：启动采样；）
float EuValue; // 数据工程值
} AI_DEF;
typedef struct
{
BYTE AiState; // 数据标识(-1：采样失败；0:没有采样；1：正在采样；2：采样结束；3：启动采样；）
float EuValue; // 数据工程值
} Data_DEF;
typedef struct
{
int imagelen; // 整个图片大小
int phototime; // 拍照时间
u_char presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
int state;// 标识(-1：拍照失败；0:没有拍照；1：正在取图；2：拍照成功；3：启动拍照；）
} IMAGE_DEF;
typedef struct
{
int imagelen; // 整个图片大小
int imagenum; // 整个图片的总包数
int phototime; // 拍照时间
u_char presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
u_char 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
{
unsigned int baudrate; /* 波特率*/
int databit; /* 数据位*/
float stopbit; /* 停止位*/
char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
//int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/
u_char SensorsType; /* 传感器类型索引，大于 0*/
int devaddr; /* 装置(传感器)使用的地址*/
u_char IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
u_char CameraChannel; /* 像机的通道号*/
u_char Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
} SENSOR_PARAM;
// 需要配置的串口装置参数
typedef struct
{
unsigned int baudrate; /* 波特率*/
int databit; /* 数据位*/
int stopbit; /* 停止位*/
char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
int commid; /* 串口序号 注意：从0开始*/
u_char ProtocolIdx; /* 规约索引，大于 0*/
int devaddr; /* 装置使用的地址*/
u_char IsNoInsta; /* 装置没有安装或者已经坏了(1:正常, 0:无效，坏了或没有安装)*/
u_char CameraChannel; /* 像机的通道号*/
u_char Phase; /* 传感器所安装相别，指拉力和倾角11表示A1....*/
} SERIAL_PARAM;
typedef struct
{
int m_iRevStatus; /* */
int m_iRecvLen; /* */
int m_iNeedRevLength; /* */
int iRecvTime; /* */
u_char m_au8RecvBuf[RECVDATA_MAXLENTH];/* */
int fd; /* 串口打开的文件句柄*/
u_char 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; /* 命令正常接收标志*/
//**********************************************************
LONG lsendtime; /* 命令发送绝对时间计时（毫秒）*/
} SIO_PARAM_SERIAL_DEF;
//串口相关装置所有参数集中定义
typedef struct
{
//******************** 端口基本信息 ************************
u_char IsNeedSerial; /* 是否需要使用串口通讯*/
int CmdWaitTime; /* 没有使用*/
u_char UseSerialidx; /* 使用的串口序号*/
int SerialCmdidx; /* 正在使用的串口发送命令的命令序号(-1:表示没有命令发送)
摄像机使用命令序号存储*/
int enrecvtime; /* 发送加密命令后接收到应答计时*/
LONG FirstCmdTimeCnt; /* 串口读取数据起始时间*/
u_char nextcmd; /* 第二次发送读取气象雨量命令 */
u_char SameTypeDevIdx; /* 相同类型装置顺序排列序号(从0开始)*/
u_char uOpenPowerFlag; /* 传感器上电标志(0:不需要打开; 1:需要打开)*/
int recvdatacnt; /* 接收到有效数据*/
PHOTO_DEF image; /* 临时存储图片数据*/
AI_DEF aiValue[MAX_DEV_VALUE_NUM]; /* 传感器采样值*/
} SERIAL_DEV_DEF;
//串口相关装置所有参数集中定义
typedef struct
{
u_char clcyesampling; /* 正在进行采样(0:没有进行采样;1:正在进行采样;)*/
u_char camerauseserial; /* 摄像机使用那个串口*/
DWORD PtzCmdType; /* 云台指令类型*/
int usecameradevidx; /* 有像机指令需要执行*/
/* 执行指令的装置序号(-1:表示没有需要执行的指令;)*/
int SendStopPtzCmdTimeCnt; /* 发送云台停止指令*/
u_char 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:是)*/
//int proruntime; /* 程序运行时间*/
int IsSleep; /* 是否使程序休眠(1:不休眠;2:休眠)*/
int tempsamplingstartime; /* 测温启动距离采样启动时间间隔*/
int tempsamplingsucctime; /* 测温启动距离采样成功时间间隔*/
int samplingtimeSec; /* 高速采样数据秒级时间控制*/
int SectimesamplingCnt[3]; /* 高速采样数据秒级采样数*/
int SunshineSensorsFault; /* 控制日照传感器故障发送*/
int TempSensorsFault; /* 控制测温传感器故障发送*/
int FirstSensorsFault; /* 第一次检测传感器故障发送*/
int SensorsIsUse; /* 传感器是否启用与自检位置匹配*/
int sequsampling; /* 顺序采样控制序号-1:无采样;其他对应相应装置序号*/
int imagepacketnum; /* 串口摄像机拍照图片总包数*/
int historyimagenum[MAX_CHANNEL_NUM]; /* 球机保存的历史图片数量*/
#if 1
//int sendflag; /* 临时上送泄露电流值标志*/
int sendphototime; /* 临时上送图片数据统计*/
int sendphotocmdcnt; /* 一次拍照过程中发送拍照指令计数*/
int photographtime; /* 图片拍摄的时间*/
int iLastGetPhotoNo; /* 设置串口摄像机参数时暂存拍照命令序号*/
u_char bImageSize; /* 用于临时存储接收上层命令的图片大小*/
u_char presetno; /* 用于临时存储接收上层命令的预置点*/
char filedir[512]; /* 用于摄像机拍照之后暂时存放的路径*/
#endif
u_char errorPhotoNoCnt; /* 串口摄像机拍照时回应错误包号计数(如:召第6包回应第3包)*/
u_char RephotographCnt; /* 串口摄像机重拍计数(只在读照片数据应答出错时才重拍)*/
} SRDT_DEF;
static void PortDataProcess( void );
static LONG get_msec();
int serial_port_comm();
static int weather_comm(SERIAL_PARAM weatherport);
static void setRS485Enable(bool z);
static void set485WriteMode();
static void set485ReadMode();
static void set12VEnable(bool z);
static void setCam3V3Enable(bool enabled);
// 串口相关的所有函数定义
/* 打开串口电源*/
void Gm_OpenSerialPower();
// 打开传感器电源
void Gm_OpenSensorsPower();
// 关闭传感器电源
void Gm_CloseSensorsPower(int port);
// 打开串口通讯
void Gm_OpenSerialPort(int devidx);
// 关闭串口通讯
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);
void Gm_InitSerialComm(SENSOR_PARAM *sensorParam, char *filedir);
// 启动串口通讯
void GM_StartSerialComm();
// 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx);
void delete_old_files(const char *path, int days);
// 串口轮询通讯定时器
int GM_SerialTimer();
//轮询所有串口和传感器是否需要生成下发命令
void Gm_FindAllSensorsCommand();
//检查所有传感器是否采集完毕，采集完毕的关闭传感器电源
void GM_IsCloseSensors();
//检查所有串口是否有数据接收，有则启动接收
void GM_AllSerialComRecv();
//判断是否需要关闭定时器
int GM_CloseTimer();
void testComm();
void Gm_InitSerialComm_Test();
// 串口接收数据处理
void SerialDataProcess(int devidx, u_char *buf, int len);
void CameraRecvData(int commid, u_char *buf, int len);
// 串口摄像机数据处理
void CameraPhotoPortDataProcess( int port);
// 发送命令
void SendCmdFormPollCmdBuf( int port );
// 清除发送命令的所有标识
void ClearCmdAllFlag(int commid);
// 下发串口拍照指令控制
int FindNextCameraPhotoCommand(int devidx);
// 生成 CameraPhoto命令
void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoParam, BYTE Threep, int phototime);
// 清除命令缓冲区
void ClearCmdFormPollCmdBuf(int port);
// 准备发送云台指令
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd);
// 发送转动摄像机云台命令定时器
int Gm_Camera_Timer();
// 生成 PELCO_P 命令 *
void Gm_SendPelco_pCommand( DWORD cmdtype);
// 计算Pelco_p校验
BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len );
// 生成 PELCO_D 命令 *
void Gm_SendPelco_DCommand( DWORD cmdtype);
// 计算Pelco_D校验
BYTE Gm_Pelco_DCheck( BYTE *msg, int len );
// 查询传感器电源状态
char Gm_GetSensorsPowerState(int port);
// 通过传感器使用的航空头查找传感器使用的串口序号
void FindDevUseSerialCommNo();
// 寻找并生成下一条倾角命令
int FindNextShxyProtocolCommand( int devidx );
// 倾角命令校验码计算
unsigned char CalLpc(unsigned char *msg, int len);
// 读上海欣影传感器协议数据
void ShxyProtocolRecvData(int commid, u_char *buf, int len);
// 检查检验和是否正确
int CheckShxyProtocolLpcError( u_char* msg, int len );
// 把16进制和10进制ASCII字符串转换成int整数
int ATOI(char *buf);
//生成倾角命令
void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx);
// 上海欣影传感器协议数据处理
void ShxyProtocolDataProcess( int commid);
// 控制关闭传感器电源
//void Gm_CtrlCloseSensorsPower(int devidx);
// 检查传感器电源是否应该关闭或打开
//void Gm_CheckSensorsPower(void);
int SaveImageDataTofile(int devno);
void Collect_sensor_data();
void CameraPhotoCmd(int phototime, u_char channel, int cmdidx, u_char bImageSize, u_char presetno);
/* 数据和图片采集数据返回函数 开始*/
int GetWeatherData(Data_DEF *data, int datano);
int GetAirTempData(Data_DEF *airt);
int GetHumidityData(Data_DEF *airt);
int GetWindSpeedData(Data_DEF *airt);
int GetWindDirectionData(Data_DEF *airt);
int GetRainfallData(Data_DEF *airt);
int GetAtmosData(Data_DEF *airt);
int GetOpticalRadiationData(Data_DEF *airt);
int GetPullValue(int devno, Data_DEF *data);
int GetAngleValue(int devno, Data_DEF *data, int Xy);
int GetImage(int devno, IMAGE_DEF *photo);
/* 数据和图片采集数据返回函数 结束*/
// 生成一个随机整数
int GeneratingRandomNumber();
#endif //WEATHERCOMM_H

2
app/src/main/cpp/serialComm.cpp
Unescape Escape View File

@ -15,7 +15,7 @@
#include <termios.h> #include <termios.h>
#include <time.h> #include <time.h>
#include "GPIOControl.h" #include "GPIOControl.h"
#include "serialComm.h" #include "SerialComm.h"
static void set_baudrate (struct termios *opt, unsigned int baudrate) static void set_baudrate (struct termios *opt, unsigned int baudrate)

Write Preview
Loading…
Cancel
Save