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

增加完善采样和图片抓拍结束后，上层获取数据函数接口，增加传感器通讯不上故障判断

Browse Source
serial
huyizhong 12 months ago
parent 9f47f7fa5c
commit a936a62440
5 changed files with 726 additions and 254 deletions
Show Stats Download Patch File Download Diff File

398
TestComm/app/src/main/cpp/SensorsProtocol.cpp
Unescape Escape View File

@ -711,13 +711,6 @@ int GM_SerialComSend(unsigned char * cSendBuf, unsigned long nSendLen, int commi
//memset(szbuf, 0, sizeof(szbuf)); //memset(szbuf, 0, sizeof(szbuf));
//sprintf(szbuf, "串口%d发送%d字节：", commid+1, len); //sprintf(szbuf, "串口%d发送%d字节：", commid+1, len);
//BytestreamLOG(szbuf, cSendBuf, len, 'D'); //BytestreamLOG(szbuf, cSendBuf, len, 'D');
#if 0
for (i = 0; i < len; i++)
{
sprintf(szbuf, "%s %02X", szbuf, cSendBuf[i]);
}
LOGE("%s", szbuf);
#endif
} }
return len; return len;
} }
@ -1217,29 +1210,29 @@ void FindDevUseSerialCommNo()
{ {
case WEATHER_PROTOCOL: case WEATHER_PROTOCOL:
case WIND_PROTOCOL: case WIND_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk0"); //sprintf(devparam[i].pathname, "/dev/swk3");
devparam[i].commid = 0; devparam[i].commid = 3;
break; break;
case SLANT_PROTOCOL: case SLANT_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk2"); //sprintf(devparam[i].pathname, "/dev/swk2");
devparam[i].commid = 2; devparam[i].commid = 2;
break; break;
case RALLY_PROTOCOL: case RALLY_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk1"); //sprintf(devparam[i].pathname, "/dev/swk1");
devparam[i].commid = 1; devparam[i].commid = 1;
break; break;
case PELCO_D_PROTOCOL: /* 摄像机协议*/ case PELCO_D_PROTOCOL: /* 摄像机协议*/
case PELCO_P_PROTOCOL: /* 摄像机协议*/ case PELCO_P_PROTOCOL: /* 摄像机协议*/
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/ case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定//具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/ttyS0"); //sprintf(devparam[i].pathname, "/dev/ttyS1");
devparam[i].commid = 0; devparam[i].commid = 0;
srdt.camerauseserial = 0; srdt.camerauseserial = 0;
break; break;
@ -1274,7 +1267,7 @@ void GM_StartSerialComm()
continue; continue;
serialport[i].Retry = 0; serialport[i].Retry = 0;
//serialport[i].RetryTime = 500/TIMER_CNT; //serialport[i].RetryTime = 500/TIMER_CNT;
serialport[i].RetryTime = 300/TIMER_CNT; serialport[i].RetryTime = 300;
serialport[i].WaitTime = 0; serialport[i].WaitTime = 0;
serialport[i].m_iRevStatus = 0; serialport[i].m_iRevStatus = 0;
serialport[i].m_iRecvLen = 0; serialport[i].m_iRecvLen = 0;
@ -1321,22 +1314,31 @@ void GM_StartSerialComm()
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0; srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<WEATHER_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case RALLY_PROTOCOL: /* 拉力*/ case RALLY_PROTOCOL: /* 拉力*/
sprintf(szbuf, "拉力"); sprintf(szbuf, "拉力");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0; srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<RALLY_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case WIND_PROTOCOL: /* 风速风向*/ case WIND_PROTOCOL: /* 风速风向*/
sprintf(szbuf, "风速风向"); sprintf(szbuf, "风速风向");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
for(j=0; j<WEATHER_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case SLANT_PROTOCOL: /* 倾角*/ case SLANT_PROTOCOL: /* 倾角*/
sprintf(szbuf, "倾角"); sprintf(szbuf, "倾角");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<SLANTANGLE_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case PELCO_D_PROTOCOL: /* 摄像机协议*/ case PELCO_D_PROTOCOL: /* 摄像机协议*/
case PELCO_P_PROTOCOL: /* 摄像机协议*/ case PELCO_P_PROTOCOL: /* 摄像机协议*/
@ -1435,7 +1437,7 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
return; return;
serialport[i].Retry = 0; serialport[i].Retry = 0;
//serialport[i].RetryTime = 500/TIMER_CNT; //serialport[i].RetryTime = 500/TIMER_CNT;
serialport[i].RetryTime = 3000/TIMER_CNT; serialport[i].RetryTime = 1000;
serialport[i].WaitTime = 0; serialport[i].WaitTime = 0;
serialport[i].m_iRevStatus = 0; serialport[i].m_iRevStatus = 0;
serialport[i].m_iRecvLen = 0; serialport[i].m_iRecvLen = 0;
@ -1474,6 +1476,8 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
else else
srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx; srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx;
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
if(0 == cmdidx)
srdt.ms_dev[i].image.state = StartSample;
if((0 == cmdidx) && (srdt.presetno > 0 )) if((0 == cmdidx) && (srdt.presetno > 0 ))
{ {
srdt.ms_dev[i].SerialCmdidx = 10017; srdt.ms_dev[i].SerialCmdidx = 10017;
@ -1498,7 +1502,6 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
Gm_OpenSensorsPower(); Gm_OpenSensorsPower();
Gm_OpenSerialPort(i); Gm_OpenSerialPort(i);
} }
} }
if(0x01 == flag) if(0x01 == flag)
{ {
@ -1512,7 +1515,7 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
if(GM_SerialTimer() < 0) if(GM_SerialTimer() < 0)
{ {
//LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE)); //LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
LOGV("退出采样流程！"); LOGV("退出拍照流程！");
//sleep(15); //sleep(15);
//GM_StartSerialComm(); //GM_StartSerialComm();
//GM_StartSerialCameraPhoto(1,0); //GM_StartSerialCameraPhoto(1,0);
@ -1544,7 +1547,7 @@ int GM_SerialTimer(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void Gm_FindAllSensorsCommand(void) void Gm_FindAllSensorsCommand()
{ {
int i, j,curidx,flag; int i, j,curidx,flag;
@ -1608,9 +1611,9 @@ void Gm_FindAllSensorsCommand(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void GM_IsCloseSensors(void) void GM_IsCloseSensors()
{ {
int i; int i, j;
char buf[256]; char buf[256];
for(i=0; i<MAX_SERIAL_DEV_NUM; i++) for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
@ -1633,6 +1636,20 @@ void GM_IsCloseSensors(void)
srdt.ms_dev[i].IsNeedSerial = 0; srdt.ms_dev[i].IsNeedSerial = 0;
// 关闭传感器电源 // 关闭传感器电源
LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1); LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1);
for(j=0;j<MAX_DEV_VALUE_NUM; j++)
{
if(StartSample == srdt.ms_dev[i].aiValue[j].AiState)
srdt.ms_dev[i].aiValue[j].AiState = SampleFail;
else if(Sample == srdt.ms_dev[i].aiValue[j].AiState)
srdt.ms_dev[i].aiValue[j].AiState = SamplingSuccess;
}
for(j=0; j<WEATHER_DATA_NUM; j++)
{
if(StartSample == weatherpntmsg[j].AiState)
weatherpntmsg[j].AiState = SampleFail;
else if(Sample == weatherpntmsg[j].AiState)
weatherpntmsg[j].AiState = SamplingSuccess;
}
} }
break; break;
case PELCO_D_PROTOCOL: /* 摄像机类型*/ case PELCO_D_PROTOCOL: /* 摄像机类型*/
@ -1640,6 +1657,10 @@ void GM_IsCloseSensors(void)
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/ case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
if(-1 == srdt.ms_dev[i].SerialCmdidx) if(-1 == srdt.ms_dev[i].SerialCmdidx)
{ {
if((StartSample == srdt.ms_dev[i].image.state) || (Sample == srdt.ms_dev[i].image.state))
srdt.ms_dev[i].image.state = SampleFail;
else if(PHOTO_SAVE_SUCC == srdt.ms_dev[i].image.state)
srdt.ms_dev[i].image.state = SamplingSuccess;
srdt.ms_dev[i].IsNeedSerial = 0; srdt.ms_dev[i].IsNeedSerial = 0;
LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel); LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel);
} }
@ -1655,7 +1676,7 @@ void GM_IsCloseSensors(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void GM_AllSerialComRecv(void) void GM_AllSerialComRecv()
{ {
int i, j, recvlen; int i, j, recvlen;
u_char recvbuf[RECVDATA_MAXLENTH]; u_char recvbuf[RECVDATA_MAXLENTH];
@ -1690,7 +1711,7 @@ void GM_AllSerialComRecv(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
int GM_CloseTimer(void) int GM_CloseTimer()
{ {
int i, j, iretime; int i, j, iretime;
char buf[256]; char buf[256];
@ -1770,9 +1791,9 @@ int SaveImageDataTofile(int devno)
return -1; return -1;
} }
// 写入文件到sdcard // 写入文件到sdcard
memset(filename, 0, sizeof(filename)); memset(pPortParam->image.photoname, 0, sizeof(pPortParam->image.photoname));
sprintf(filename, "%s%d-%d-%d.jpg", filedir,devparam[devno].CameraChannel, pPortParam->image.presetno, pPortParam->image.phototime); sprintf(pPortParam->image.photoname, "%s%d-%d-%d.jpg", filedir,devparam[devno].CameraChannel, pPortParam->image.presetno, pPortParam->image.phototime);
fp = fopen(filename, "wb+"); fp = fopen(pPortParam->image.photoname, "wb+");
if(NULL == fp) if(NULL == fp)
return -1; return -1;
len = fwrite(image,1, pPortParam->image.imagelen, fp); len = fwrite(image,1, pPortParam->image.imagelen, fp);
@ -1781,7 +1802,7 @@ int SaveImageDataTofile(int devno)
return -1; return -1;
else else
{ {
LOGI("写入图片文件%s成功！", filename); LOGI("写入图片文件%s成功！", pPortParam->image.photoname);
return 1; return 1;
} }
} }
@ -1937,6 +1958,7 @@ void CameraPhotoPortDataProcess( int devno)
LOGV("%s", szbuf); LOGV("%s", szbuf);
presetno = (int)rtumsg.MsgData[i+8]; presetno = (int)rtumsg.MsgData[i+8];
pPortParam->image.presetno = presetno; pPortParam->image.presetno = presetno;
pPortParam->image.state = Sample;
curserial->RevCmdFlag = 1; curserial->RevCmdFlag = 1;
pPortParam->SerialCmdidx = 1; pPortParam->SerialCmdidx = 1;
srdt.sendphotocmdcnt = 0; srdt.sendphotocmdcnt = 0;
@ -1967,7 +1989,8 @@ void CameraPhotoPortDataProcess( int devno)
} }
else else
{ {
SaveImageDataTofile(devno); if((1 == SaveImageDataTofile(devno)) && (Sample == pPortParam->image.state))
pPortParam->image.state = PHOTO_SAVE_SUCC;
recvend = 1; recvend = 1;
} }
} }
@ -2085,9 +2108,11 @@ void SendCmdFormPollCmdBuf( int port )
{ {
char buf[64]; char buf[64];
int len, ret; int len, ret;
long lctime;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
pPortParam = &serialport[port]; pPortParam = &serialport[port];
lctime = get_msec();
if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt) if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt)
{ {
pPortParam->ForceWaitCnt--; pPortParam->ForceWaitCnt--;
@ -2096,12 +2121,18 @@ void SendCmdFormPollCmdBuf( int port )
if(pPortParam->SendCmdFlag && (pPortParam->RevCmdFlag == 0)) if(pPortParam->SendCmdFlag && (pPortParam->RevCmdFlag == 0))
{ {
pPortParam->RetryTimeCnt++; //pPortParam->RetryTimeCnt++;
if(pPortParam->RetryTimeCnt < pPortParam->RetryTime) if((lctime - pPortParam->RetryTimeCnt > 3*pPortParam->RetryTime) || (lctime - pPortParam->RetryTimeCnt < 0))
{ {
pPortParam->RetryTimeCnt = lctime;
return; return;
} }
pPortParam->RetryTimeCnt = 0; if(lctime - pPortParam->RetryTimeCnt < pPortParam->RetryTime)
//if(pPortParam->RetryTimeCnt < pPortParam->RetryTime)
{
return;
}
pPortParam->RetryTimeCnt = lctime;
pPortParam->RetryCnt++; pPortParam->RetryCnt++;
if(pPortParam->RetryCnt > pPortParam->Retry) if(pPortParam->RetryCnt > pPortParam->Retry)
{ {
@ -2156,16 +2187,16 @@ void SendCmdFormPollCmdBuf( int port )
sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1); sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1);
BytestreamLOG(buf, &pPortParam->PollCmd[2], len, 'D'); BytestreamLOG(buf, &pPortParam->PollCmd[2], len, 'D');
LOGW("sendtimeconst= %ld", get_msec()-lsendtime); LOGW("sendtimeconst= %ld", lctime-lsendtime);
lsendtime = get_msec(); lsendtime = lctime;
} }
pPortParam->SendCmdFlag = 1; pPortParam->SendCmdFlag = 1;
pPortParam->ReSendCmdFlag = 0; pPortParam->ReSendCmdFlag = 0;
pPortParam->RevCmdFlag = 0; pPortParam->RevCmdFlag = 0;
pPortParam->RetryTimeCnt = 0; pPortParam->RetryTimeCnt = lctime;
//pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1; pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1;
//pPortParam->ForceWaitCnt /= TIMER_CNT; pPortParam->ForceWaitCnt /= TIMER_CNT;
if(pPortParam->ForceWaitCnt) if(pPortParam->ForceWaitCnt)
{ {
pPortParam->ForceWaitFlag = 1; pPortParam->ForceWaitFlag = 1;
@ -2178,7 +2209,7 @@ void ClearCmdAllFlag(int commid)
return; return;
serialport[commid].RetryCnt = 0; serialport[commid].RetryCnt = 0;
serialport[commid].RetryTimeCnt = 0; serialport[commid].RetryTimeCnt = get_msec();
serialport[commid].WaitTimeCnt = 0; serialport[commid].WaitTimeCnt = 0;
serialport[commid].ForceWaitFlag = 0; serialport[commid].ForceWaitFlag = 0;
serialport[commid].ForceWaitCnt = 0; serialport[commid].ForceWaitCnt = 0;
@ -2575,7 +2606,7 @@ int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd)
} }
// 发送转动摄像机云台命令定时器 // 发送转动摄像机云台命令定时器
int Gm_Camera_Timer(void) int Gm_Camera_Timer()
{ {
char szbuf[128]; char szbuf[128];
@ -3010,12 +3041,14 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < -59) ||(fvalue > 59)) if((fvalue < -59) ||(fvalue > 59))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
slantpntmsg[aipnt][0].EuValue *= (1+frnb); pPortParam->aiValue[0].EuValue *= (1+frnb);
} }
else else
slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;
+slantpntmsg[aipnt][0].AiParam.EuValueDelta; pPortParam->aiValue[0].AiState = Sample;
slantpntmsg[aipnt][0].AiState = 1; //slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
// +slantpntmsg[aipnt][0].AiParam.EuValueDelta;
//slantpntmsg[aipnt][0].AiState = 1;
//if ((gDisSunRain & 0x20) == 0x20) //if ((gDisSunRain & 0x20) == 0x20)
{ {
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue);
@ -3036,12 +3069,15 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < -59) ||(fvalue > 59)) if((fvalue < -59) ||(fvalue > 59))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
slantpntmsg[aipnt][1].EuValue *= (1+frnb); pPortParam->aiValue[1].EuValue *= (1+frnb);
//slantpntmsg[aipnt][1].EuValue *= (1+frnb);
} }
else else
slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\ pPortParam->aiValue[1].EuValue = fvalue;
pPortParam->aiValue[1].AiState = Sample;
/*slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
+slantpntmsg[aipnt][1].AiParam.EuValueDelta; +slantpntmsg[aipnt][1].AiParam.EuValueDelta;
slantpntmsg[aipnt][1].AiState = 1; slantpntmsg[aipnt][1].AiState = 1;*/
//YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue; //YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue;
srdt.SectimesamplingCnt[1] += 1; srdt.SectimesamplingCnt[1] += 1;
} }
@ -3049,20 +3085,6 @@ void ShxyProtocolDataProcess( int devno)
if((0x08 != cmdidx) && (0x09 != cmdidx)) if((0x08 != cmdidx) && (0x09 != cmdidx))
return; return;
#if 0
if(1 == srdt.IsReadWireTem)
{
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
{
if((WDIITEMP_PROTOCOL_NEW == srdt.ms_dev[i].ProtocolIdx) && (uDevAddr == (WORD)srdt.ms_dev[i].devaddr))
break;
}
if(i == MAX_SERIAL_DEV_NUM)
return;
pPortParam = &srdt.ms_dev[i];
aipnt = pPortParam->SameTypeDevIdx;
}
#endif
for(i = 0, j=7; (i<datanum) && (j<6+curserial->m_au8RecvBuf[1]); i++, j+=5 ) for(i = 0, j=7; (i<datanum) && (j<6+curserial->m_au8RecvBuf[1]); i++, j+=5 )
{ {
if(0x08 == cmdidx) if(0x08 == cmdidx)
@ -3076,21 +3098,24 @@ void ShxyProtocolDataProcess( int devno)
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1]; *((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1];
} }
switch(curserial->m_au8RecvBuf[j]) switch(curserial->m_au8RecvBuf[j])
{ {slantpntmsg[aipnt][1].EuValue *= (1+frnb)slantpntmsg[aipnt][1].EuValue *= (1+frnb);
case 1: /*温度*/ case 1: /*温度*/
if((fvalue < -40) ||(fvalue > 85)) if((fvalue < -40) ||(fvalue > 85))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
pPortParam->aiValue[0].EuValue *= (1+frnb); pPortParam->aiValue[AirTempNo].EuValue *= (1+frnb);
weatherpntmsg[AirTempNo].EuValue *= (1+frnb); weatherpntmsg[AirTempNo].EuValue *= (1+frnb);
//weatherpntmsg[AirTempNo].AiState = Sample;
} }
else else
{ {
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor + pPortParam->aiValue[0].AiParam.EuValueDelta; pPortParam->aiValue[AirTempNo].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor + pPortParam->aiValue[0].AiParam.EuValueDelta;*/
weatherpntmsg[AirTempNo].EuValue = fvalue*weatherpntmsg[AirTempNo].AiParam.fFactor + weatherpntmsg[AirTempNo].AiParam.EuValueDelta; weatherpntmsg[AirTempNo].EuValue = fvalue;/*weatherpntmsg[AirTempNo].AiParam.fFactor + weatherpntmsg[AirTempNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[AirTempNo].AiState = Sample;
weatherpntmsg[AirTempNo].AiState = 1; weatherpntmsg[AirTempNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x01); //g_SelfTest.SensorsFault |= (0x01);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3102,16 +3127,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < 550) ||(fvalue > 1060)) if((fvalue < 550) ||(fvalue > 1060))
{ {
frnb = (GeneratingRandomNumber()%41-20)/10000.0; frnb = (GeneratingRandomNumber()%41-20)/10000.0;
pPortParam->aiValue[5].EuValue *= (1+frnb); pPortParam->aiValue[AtmosNo].EuValue *= (1+frnb);
weatherpntmsg[AtmosNo].EuValue *= (1+frnb); weatherpntmsg[AtmosNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[5].EuValue = fvalue*pPortParam->aiValue[5].AiParam.fFactor + pPortParam->aiValue[5].AiParam.EuValueDelta; pPortParam->aiValue[AtmosNo].EuValue = fvalue;/*pPortParam->aiValue[5].AiParam.fFactor + pPortParam->aiValue[5].AiParam.EuValueDelta;*/
weatherpntmsg[AtmosNo].EuValue = fvalue*weatherpntmsg[AtmosNo].AiParam.fFactor + weatherpntmsg[AtmosNo].AiParam.EuValueDelta; weatherpntmsg[AtmosNo].EuValue = fvalue;/*weatherpntmsg[AtmosNo].AiParam.fFactor + weatherpntmsg[AtmosNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[5].AiState = 1; pPortParam->aiValue[AtmosNo].AiState = Sample;
weatherpntmsg[AtmosNo].AiState = 1; weatherpntmsg[AtmosNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x10); //g_SelfTest.SensorsFault |= (0x10);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3123,16 +3148,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < 0) ||(fvalue > 100)) if((fvalue < 0) ||(fvalue > 100))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[1].EuValue *= (1+frnb); pPortParam->aiValue[HumidityNo].EuValue *= (1+frnb);
weatherpntmsg[HumidityNo].EuValue *= (1+frnb); weatherpntmsg[HumidityNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[1].EuValue = fvalue*pPortParam->aiValue[1].AiParam.fFactor + pPortParam->aiValue[1].AiParam.EuValueDelta; pPortParam->aiValue[HumidityNo].EuValue = fvalue;/*pPortParam->aiValue[1].AiParam.fFactor + pPortParam->aiValue[1].AiParam.EuValueDelta;*/
weatherpntmsg[HumidityNo].EuValue = fvalue*weatherpntmsg[HumidityNo].AiParam.fFactor + weatherpntmsg[HumidityNo].AiParam.EuValueDelta; weatherpntmsg[HumidityNo].EuValue = fvalue;/*weatherpntmsg[HumidityNo].AiParam.fFactor + weatherpntmsg[HumidityNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[1].AiState = 1; pPortParam->aiValue[HumidityNo].AiState = Sample;
weatherpntmsg[HumidityNo].AiState = 1; weatherpntmsg[HumidityNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x02); //g_SelfTest.SensorsFault |= (0x02);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3145,19 +3170,19 @@ void ShxyProtocolDataProcess( int devno)
case 5: /*日照*/ case 5: /*日照*/
break; break;
case 6: /*风速*/ case 6: /*风速*/
if((fvalue/1000 < 0) ||(fvalue/1000 > 80)) if((fvalue < 0) ||(fvalue > 80))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[2].EuValue *= (1+frnb); pPortParam->aiValue[WindSpeedNo].EuValue *= (1+frnb);
weatherpntmsg[WindSpeedNo].EuValue *= (1+frnb); weatherpntmsg[WindSpeedNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[2].EuValue = fvalue*pPortParam->aiValue[2].AiParam.fFactor + pPortParam->aiValue[2].AiParam.EuValueDelta; pPortParam->aiValue[WindSpeedNo].EuValue = fvalue;/*pPortParam->aiValue[2].AiParam.fFactor + pPortParam->aiValue[2].AiParam.EuValueDelta;*/
weatherpntmsg[WindSpeedNo].EuValue = fvalue*weatherpntmsg[WindSpeedNo].AiParam.fFactor + weatherpntmsg[WindSpeedNo].AiParam.EuValueDelta; weatherpntmsg[WindSpeedNo].EuValue = fvalue;/*weatherpntmsg[WindSpeedNo].AiParam.fFactor + weatherpntmsg[WindSpeedNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[2].AiState = 1; pPortParam->aiValue[WindSpeedNo].AiState = Sample;
weatherpntmsg[WindSpeedNo].AiState = 1; weatherpntmsg[WindSpeedNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x04); //g_SelfTest.SensorsFault |= (0x04);
//if ((gDisSunRain & 0x10) == 0x10) //if ((gDisSunRain & 0x10) == 0x10)
{ {
@ -3173,16 +3198,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99)) if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[3].EuValue *= (1+frnb); pPortParam->aiValue[WindDirectionNo].EuValue *= (1+frnb);
weatherpntmsg[WindDirectionNo].EuValue *= (1+frnb); weatherpntmsg[WindDirectionNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[3].EuValue = fvalue*pPortParam->aiValue[3].AiParam.fFactor + pPortParam->aiValue[3].AiParam.EuValueDelta; pPortParam->aiValue[WindDirectionNo].EuValue = fvalue;/*pPortParam->aiValue[3].AiParam.fFactor + pPortParam->aiValue[3].AiParam.EuValueDelta;*/
weatherpntmsg[WindDirectionNo].EuValue = fvalue*weatherpntmsg[WindDirectionNo].AiParam.fFactor + weatherpntmsg[WindDirectionNo].AiParam.EuValueDelta; weatherpntmsg[WindDirectionNo].EuValue = fvalue;/*weatherpntmsg[WindDirectionNo].AiParam.fFactor + weatherpntmsg[WindDirectionNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[3].AiState = 1; pPortParam->aiValue[WindDirectionNo].AiState = Sample;
weatherpntmsg[WindDirectionNo].AiState = 1; weatherpntmsg[WindDirectionNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x08); //g_SelfTest.SensorsFault |= (0x08);
//if ((gDisSunRain & 0x10) == 0x10) //if ((gDisSunRain & 0x10) == 0x10)
{ {
@ -3211,11 +3236,11 @@ void ShxyProtocolDataProcess( int devno)
if(pPortParam->recvdatacnt < 2) if(pPortParam->recvdatacnt < 2)
break; break;
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor\
+pPortParam->aiValue[0].AiParam.EuValueDelta; +pPortParam->aiValue[0].AiParam.EuValueDelta;*/
//rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\ //rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\
// +rallypntmsg[aipnt][0].AiParam.EuValueDelta; // +rallypntmsg[aipnt][0].AiParam.EuValueDelta;
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[0].AiState = Sample;
//rallypntmsg[aipnt][0].AiState = 1; //rallypntmsg[aipnt][0].AiState = 1;
sprintf(szbuf, "地址%d拉力:%0.3fKg ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "地址%d拉力:%0.3fKg ", devparam[devno].devaddr, fvalue);
LOGV("%s", szbuf); LOGV("%s", szbuf);
@ -3230,12 +3255,12 @@ void ShxyProtocolDataProcess( int devno)
} }
else else
{ {
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor\
+pPortParam->aiValue[0].AiParam.EuValueDelta; +pPortParam->aiValue[0].AiParam.EuValueDelta;*/
//slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\ //slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
//+slantpntmsg[aipnt][0].AiParam.EuValueDelta; //+slantpntmsg[aipnt][0].AiParam.EuValueDelta;
} }
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[0].AiState = Sample;
//slantpntmsg[aipnt][0].AiState = 1; //slantpntmsg[aipnt][0].AiState = 1;
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue);
LOGV("%s", szbuf); LOGV("%s", szbuf);
@ -3248,16 +3273,13 @@ void ShxyProtocolDataProcess( int devno)
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
pPortParam->aiValue[1].EuValue *= (1+frnb); pPortParam->aiValue[1].EuValue *= (1+frnb);
slantpntmsg[aipnt][1].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[1].EuValue = fvalue*pPortParam->aiValue[1].AiParam.fFactor\ pPortParam->aiValue[1].EuValue = fvalue;/*pPortParam->aiValue[1].AiParam.fFactor\
+pPortParam->aiValue[1].AiParam.EuValueDelta; +pPortParam->aiValue[1].AiParam.EuValueDelta;*/
//slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
// +slantpntmsg[aipnt][1].AiParam.EuValueDelta;
} }
pPortParam->aiValue[1].AiState = 1; pPortParam->aiValue[1].AiState = Sample;
//slantpntmsg[aipnt][1].AiState = 1; //slantpntmsg[aipnt][1].AiState = 1;
break; break;
#if 0 #if 0
@ -3466,6 +3488,7 @@ int GeneratingRandomNumber(void)
return randomdate; return randomdate;
} }
/* 串口启动接口函数 开始*/
void Collect_sensor_data(SENSOR_PARAM *sensorParam) void Collect_sensor_data(SENSOR_PARAM *sensorParam)
{ {
int i; int i;
@ -3478,6 +3501,8 @@ void Collect_sensor_data(SENSOR_PARAM *sensorParam)
devparam[i].ProtocolIdx = sensorParam[i].SensorsType; devparam[i].ProtocolIdx = sensorParam[i].SensorsType;
devparam[i].devaddr = sensorParam[i].devaddr; devparam[i].devaddr = sensorParam[i].devaddr;
devparam[i].baudrate = getBaudrate(sensorParam[i].baudrate); devparam[i].baudrate = getBaudrate(sensorParam[i].baudrate);
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
memmove(devparam[i].pathname, sensorParam[i].pathname, sizeof(devparam[i].pathname));
devparam[i].databit = sensorParam[i].databit; devparam[i].databit = sensorParam[i].databit;
devparam[i].stopbit = (int)sensorParam[i].stopbit*10; devparam[i].stopbit = (int)sensorParam[i].stopbit*10;
devparam[i].CameraChannel = sensorParam[i].CameraChannel; devparam[i].CameraChannel = sensorParam[i].CameraChannel;
@ -3521,14 +3546,183 @@ void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_cha
//GM_StartSerialComm(); //GM_StartSerialComm();
GM_StartSerialCameraPhoto(1, cmdidx); GM_StartSerialCameraPhoto(1, cmdidx);
} }
/* 串口启动接口函数 结束*/
int GetAirTempData(Data_DEF *airt) /* 数据和图片采集数据返回函数 开始*/
int GetWeatherData(Data_DEF *data, int datano)
{ {
int i; int i;
if(NULL == data)
return -1;
if((AirTempNo > datano) || (datano > OpticalRadiationNo))
return -1;
data->EuValue = weatherpntmsg[datano].EuValue;
data->AiState = weatherpntmsg[datano].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
weatherpntmsg[datano].AiState = Idle;
return 2;
}
return 1;
}
int GetAirTempData(Data_DEF *airt)
{
if(NULL == airt) if(NULL == airt)
return -1; return -1;
airt->EuValue = weatherpntmsg[AirTempNo].EuValue; airt->EuValue = weatherpntmsg[AirTempNo].EuValue;
airt->AiState = weatherpntmsg[AirTempNo].AiState; airt->AiState = weatherpntmsg[AirTempNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[AirTempNo].AiState = Idle;
return 2;
}
return 1;
} }
int GetHumidityData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[HumidityNo].EuValue;
airt->AiState = weatherpntmsg[HumidityNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[HumidityNo].AiState = Idle;
return 2;
}
return 1;
}
int GetWindSpeedData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[WindSpeedNo].EuValue;
airt->AiState = weatherpntmsg[WindSpeedNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[WindSpeedNo].AiState = Idle;
return 2;
}
return 1;
}
int GetWindDirectionData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[WindDirectionNo].EuValue;
airt->AiState = weatherpntmsg[WindDirectionNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[WindDirectionNo].AiState = Idle;
return 2;
}
return 1;
}
int GetRainfallData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[RainfallNo].EuValue;
airt->AiState = weatherpntmsg[RainfallNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[RainfallNo].AiState = Idle;
return 2;
}
return 1;
}
int GetAtmosData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[AtmosNo].EuValue;
airt->AiState = weatherpntmsg[AtmosNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[AtmosNo].AiState = Idle;
return 2;
}
return 1;
}
int GetOpticalRadiationData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[OpticalRadiationNo].EuValue;
airt->AiState = weatherpntmsg[OpticalRadiationNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[OpticalRadiationNo].AiState = Idle;
return 2;
}
return 1;
}
int GetPullValue(int devno, Data_DEF *data)
{
if(NULL == data)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if(RALLY_PROTOCOL != devparam[devno].ProtocolIdx)
return -1;
data->EuValue = srdt.ms_dev[devno].aiValue[0].EuValue;
data->AiState = srdt.ms_dev[devno].aiValue[0].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
srdt.ms_dev[devno].aiValue[0].AiState = Idle;
return 2;
}
return 1;
}
int GetAngleValue(int devno, Data_DEF *data, int Xy)
{
if(NULL == data)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if(SLANT_PROTOCOL != devparam[devno].ProtocolIdx)
return -1;
if((0 > Xy) || (1 < Xy))
return -1;
data->EuValue = srdt.ms_dev[devno].aiValue[Xy].EuValue;
data->AiState = srdt.ms_dev[devno].aiValue[Xy].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
srdt.ms_dev[devno].aiValue[Xy].AiState = Idle;
return 2;
}
return 1;
}
int GetImage(int devno, IMAGE_DEF *photo)
{
if(NULL == photo)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if((PELCO_D_PROTOCOL != devparam[devno].ProtocolIdx) && (PELCO_P_PROTOCOL != devparam[devno].ProtocolIdx) &&(SERIALCAMERA_PROTOCOL != devparam[devno].ProtocolIdx))
return -1;
photo->presetno = srdt.ms_dev[devno].image.presetno;
photo->phototime = srdt.ms_dev[devno].image.phototime;
memset(photo->photoname, 0, sizeof(photo->photoname));
memmove(photo->photoname, srdt.ms_dev[devno].image.photoname, sizeof(photo->photoname));
photo->imagelen = srdt.ms_dev[devno].image.imagelen;
photo->state = srdt.ms_dev[devno].image.state;
if((SampleFail == photo->state) || (SamplingSuccess == photo->state))
{
srdt.ms_dev[devno].image.state = Idle;
return 2;
}
return 1;
}
/* 数据和图片采集数据返回函数 结束*/

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

@ -61,9 +61,10 @@ typedef unsigned char BYTE;
#define Idle 0 /* 传感器处于空闲状态，未启动采样*/ #define Idle 0 /* 传感器处于空闲状态，未启动采样*/
#define Sample 1 /* 正在采样过程中*/ #define Sample 1 /* 正在采样过程中*/
#define SamplingEnd 2 /* 采样结束*/ #define SamplingSuccess 2 /* 采样结束,正常读取到数据*/
#define StartSample 3 /* 启动采样*/ #define StartSample 3 /* 启动采样*/
#define SampleFail -1 /* 采样失败，传感器故障或未接*/ #define SampleFail -1 /* 采样失败，未采集到数据，传感器故障或未接*/
#define PHOTO_SAVE_SUCC 5 /* 图片保存成功*/
#define WEATHER_DATA_NUM 8 /* 气象数据最大数量(一般最多是6要素)*/ #define WEATHER_DATA_NUM 8 /* 气象数据最大数量(一般最多是6要素)*/
#define RALLY_DATA_NUM 2 /* 拉力数据最大数量(一般是1个)*/ #define RALLY_DATA_NUM 2 /* 拉力数据最大数量(一般是1个)*/
@ -110,6 +111,9 @@ typedef unsigned char BYTE;
#define D_MOVE_RIGHT 0x00022d00 /* 向右移动镜头(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 Auto_Scan 10006 /* 自动扫描功能控制(1/0 打开/关闭该功能)*/
#define IRIS_CLOSE 10007 /* 光圈缩小(1 有效)*/ #define IRIS_CLOSE 10007 /* 光圈缩小(1 有效)*/
#define IRIS_OPEN 10008 /* 光圈放大(1 有效)*/ #define IRIS_OPEN 10008 /* 光圈放大(1 有效)*/
@ -121,7 +125,8 @@ typedef unsigned char BYTE;
#define MOVE_UP 10014 /* 向上移动镜头(1 有效)*/ #define MOVE_UP 10014 /* 向上移动镜头(1 有效)*/
#define MOVE_LEFT 10015 /* 向左移动镜头(1 有效)*/ #define MOVE_LEFT 10015 /* 向左移动镜头(1 有效)*/
#define MOVE_RIGHT 10016 /* 向右移动镜头(1 有效)*/ #define MOVE_RIGHT 10016 /* 向右移动镜头(1 有效)*/
#define MOVE_PRESETNO 10017 // 调用预置点
#define SAVE_PRESETNO 10018 // 设置预置点
#define SPEED_DOME_CAMERA 0 /* 球机摄像机*/ #define SPEED_DOME_CAMERA 0 /* 球机摄像机*/
#define SERIAL_CAMERA 2 /* 串口摄像机a*/ #define SERIAL_CAMERA 2 /* 串口摄像机a*/
@ -171,14 +176,25 @@ typedef struct
float EuValue; // 数据工程值 float EuValue; // 数据工程值
} Data_DEF; } 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 typedef struct
{ {
int imagelen; // 整个图片大小 int imagelen; // 整个图片大小
int imagenum; // 整个图片的总包数 int imagenum; // 整个图片的总包数
int phototime; // 拍照时间 int phototime; // 拍照时间
u_char presetno; // 拍照预置点 u_char presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
u_char buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存 u_char buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存
int ilen[MAX_PHOTO_PACKET_NUM]; // 相对应的每包图片数据的长度 int ilen[MAX_PHOTO_PACKET_NUM]; // 相对应的每包图片数据的长度
int state;// 标识(-1：拍照失败；0:没有拍照；1：正在取图；2：拍照成功；3：启动拍照；）
} PHOTO_DEF; } PHOTO_DEF;
// 上层调用采集传感器参数 // 上层调用采集传感器参数
@ -188,6 +204,7 @@ typedef struct
int databit; /* 数据位*/ int databit; /* 数据位*/
float stopbit; /* 停止位*/ float stopbit; /* 停止位*/
char parity; /* 校验位*/ char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
//int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/ //int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/
u_char SensorsType; /* 传感器类型索引，大于 0*/ u_char SensorsType; /* 传感器类型索引，大于 0*/
int devaddr; /* 装置(传感器)使用的地址*/ int devaddr; /* 装置(传感器)使用的地址*/
@ -225,8 +242,8 @@ typedef struct
//******************** Poll Cmd **************************** //******************** Poll Cmd ****************************
u_char Retry; /* 重试命令次数 */ u_char Retry; /* 重试命令次数 */
u_char RetryCnt; /* 重试命令计数*/ u_char RetryCnt; /* 重试命令计数*/
u_long RetryTime; /* 重试命令时间 */ long RetryTime; /* 重试命令时间 */
u_long RetryTimeCnt; /* 重试命令时间计数*/ long RetryTimeCnt; /* 重试命令时间计数*/
u_long WaitTime; /* 命令间隔时间 */ u_long WaitTime; /* 命令间隔时间 */
u_long WaitTimeCnt; /* 命令间隔时间计数*/ u_long WaitTimeCnt; /* 命令间隔时间计数*/
u_char ForceWaitFlag; /* 强制等待标志*/ u_char ForceWaitFlag; /* 强制等待标志*/
@ -343,7 +360,7 @@ static void setCam3V3Enable(bool enabled);
// 串口相关的所有函数定义 // 串口相关的所有函数定义
/* 打开串口电源*/ /* 打开串口电源*/
void Gm_OpenSerialPower(void); void Gm_OpenSerialPower();
// 打开传感器电源 // 打开传感器电源
void Gm_OpenSensorsPower(); void Gm_OpenSensorsPower();
@ -354,27 +371,26 @@ void Gm_CloseSensorsPower(int port);
void Gm_OpenSerialPort(int devidx); void Gm_OpenSerialPort(int devidx);
// 关闭串口通讯 // 关闭串口通讯
void Gm_CloseSerialPort(void); void Gm_CloseSerialPort();
// 功能说明:串口发送数据 返回实际发送的字节数 // 功能说明:串口发送数据 返回实际发送的字节数
int GM_SerialComSend(const unsigned char * cSendBuf, unsigned long nSendLen, int commid); int GM_SerialComSend(const unsigned char * cSendBuf, unsigned long nSendLen, int commid);
void Gm_InitSerialComm(); void Gm_InitSerialComm();
void Collect_sensor_data(SENSOR_PARAM *sensorParam);
// 启动串口通讯 // 启动串口通讯
void GM_StartSerialComm(void); void GM_StartSerialComm();
// 启动使用串口拍照 // 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx); void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx);
// 串口轮询通讯定时器 // 串口轮询通讯定时器
int GM_SerialTimer(void); int GM_SerialTimer();
//轮询所有串口和传感器是否需要生成下发命令 //轮询所有串口和传感器是否需要生成下发命令
void Gm_FindAllSensorsCommand(void); void Gm_FindAllSensorsCommand();
//检查所有传感器是否采集完毕，采集完毕的关闭传感器电源 //检查所有传感器是否采集完毕，采集完毕的关闭传感器电源
void GM_IsCloseSensors(void); void GM_IsCloseSensors();
//检查所有串口是否有数据接收，有则启动接收 //检查所有串口是否有数据接收，有则启动接收
void GM_AllSerialComRecv(void); void GM_AllSerialComRecv();
//判断是否需要关闭定时器 //判断是否需要关闭定时器
int GM_CloseTimer(void); int GM_CloseTimer();
// 串口接收数据处理 // 串口接收数据处理
void SerialDataProcess(int devidx, u_char *buf, int len); void SerialDataProcess(int devidx, u_char *buf, int len);
@ -402,7 +418,7 @@ void ClearCmdFormPollCmdBuf(int port);
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd); int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd);
// 发送转动摄像机云台命令定时器 // 发送转动摄像机云台命令定时器
int Gm_Camera_Timer(void); int Gm_Camera_Timer();
// 生成 PELCO_P 命令 * // 生成 PELCO_P 命令 *
void Gm_SendPelco_pCommand( DWORD cmdtype); void Gm_SendPelco_pCommand( DWORD cmdtype);
@ -418,10 +434,10 @@ BYTE Gm_Pelco_DCheck( BYTE *msg, int len );
char Gm_GetSensorsPowerState(int port); char Gm_GetSensorsPowerState(int port);
// 通过传感器使用的航空头查找传感器使用的串口序号 // 通过传感器使用的航空头查找传感器使用的串口序号
void FindDevUseSerialCommNo(void); void FindDevUseSerialCommNo();
// 初始化所有串口及所接传感器的配置 // 初始化所有串口及所接传感器的配置
void Gm_InitSerialComm(void); void Gm_InitSerialComm();
// 寻找并生成下一条倾角命令 // 寻找并生成下一条倾角命令
int FindNextShxyProtocolCommand( int devidx ); int FindNextShxyProtocolCommand( int devidx );
@ -443,13 +459,35 @@ void ShxyProtocolDataProcess( int commid);
//void Gm_CtrlCloseSensorsPower(int devidx); //void Gm_CtrlCloseSensorsPower(int devidx);
// 检查传感器电源是否应该关闭或打开 // 检查传感器电源是否应该关闭或打开
//void Gm_CheckSensorsPower(void); //void Gm_CheckSensorsPower(void);
int Gm_SetSerialPortBaud(int commid); int SaveImageDataTofile(int devno);
// 得到串口波特率 void Collect_sensor_data(SENSOR_PARAM *sensorParam);
//T_baudrate Gm_GetSerialPortBaud(UART_baudrate Baudrate);
void Gm_CloseSerialCamera();
void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_char bImageSize, u_char presetno); void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_char bImageSize, u_char presetno);
int SaveImageDataTofile(int devno);
/* 数据和图片采集数据返回函数 开始*/
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(); int GeneratingRandomNumber();

20
TestComm/app/src/main/cpp/WeatherComm.cpp
Unescape Escape View File

@ -101,11 +101,11 @@ int set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char
set_baudrate(&opt, baudrate); set_baudrate(&opt, baudrate);
//opt.c_cflag |= CLOCAL|CREAD; /*|CRTSCTS */ //opt.c_cflag |= CLOCAL|CREAD; /*|CRTSCTS */
opt.c_lflag &= ~(ICANON | ECHO |ECHOE |ISIG); opt.c_lflag &= ~(ICANON | ECHO |ECHOE |ISIG);
opt.c_iflag &=~(INLCR|ICRNL);
opt.c_iflag &=~(IXON);/* 流控*/
set_data_bit(&opt, databit); set_data_bit(&opt, databit);
set_parity(&opt, parity); set_parity(&opt, parity);
set_stopbit(&opt, stopbit); set_stopbit(&opt, stopbit);
opt.c_iflag &=~(INLCR|ICRNL);
opt.c_iflag &=~(IXON);/* 流控*/
opt.c_oflag = 0; opt.c_oflag = 0;
//opt.c_lflag |= 0; //opt.c_lflag |= 0;
opt.c_oflag &= ~OPOST; opt.c_oflag &= ~OPOST;
@ -429,11 +429,19 @@ static int weather_comm(SERIAL_PARAM weatherport)
setInt(CMD_SET_ANGLE_POWER, 1); setInt(CMD_SET_ANGLE_POWER, 1);
setInt(CMD_SET_OTHER_POWER, 1); setInt(CMD_SET_OTHER_POWER, 1);
setInt(CMD_SET_PIC1_POWER, 1); setInt(CMD_SET_PIC1_POWER, 1);
#if 1
setInt(CMD_SET_485_en0, 1); setInt(CMD_SET_485_en0, 1);
setInt(CMD_SET_485_en1, 1); setInt(CMD_SET_485_en1, 1);
setInt(CMD_SET_485_en2, 1); setInt(CMD_SET_485_en2, 1);
setInt(CMD_SET_485_en3, 1); setInt(CMD_SET_485_en3, 1);
setInt(CMD_SET_485_en4, 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); sleep(3);
//ictime = (int)time(NULL); //ictime = (int)time(NULL);
ictime = get_msec(); ictime = get_msec();
@ -505,7 +513,7 @@ static int weather_comm(SERIAL_PARAM weatherport)
irecvtime = get_msec(); irecvtime = get_msec();
if((irecvtime-isendtime > 6000) ||(irecvtime - isendtime < 0)) if((irecvtime-isendtime > 6000) ||(irecvtime - isendtime < 0))
isendtime = irecvtime; isendtime = irecvtime;
if (irecvtime-isendtime > 1500) if (irecvtime-isendtime > 500)
{ {
LOGE("传感器超过%ld毫秒未应答", irecvtime-isendtime); LOGE("传感器超过%ld毫秒未应答", irecvtime-isendtime);
serialport.RevCmdFlag = 1; serialport.RevCmdFlag = 1;
@ -566,11 +574,11 @@ int serial_port_comm()
#if 1 #if 1
memset(portparm.pathname, 0, sizeof(portparm.pathname)); memset(portparm.pathname, 0, sizeof(portparm.pathname));
sprintf(portparm.pathname, "/dev/ttyS1"); //sprintf(portparm.pathname, "/dev/ttyS1");
//sprintf(portparm.pathname, "/dev/ttysWK1"); sprintf(portparm.pathname, "/dev/ttysWK3");
portparm.parity = 'N'; portparm.parity = 'N';
portparm.databit = 8; portparm.databit = 8;
portparm.baudrate = B38400; portparm.baudrate = B9600;
memset(portparm.stopbit, 0, sizeof(portparm.stopbit)); memset(portparm.stopbit, 0, sizeof(portparm.stopbit));
sprintf(portparm.stopbit, "1"); sprintf(portparm.stopbit, "1");
#endif #endif

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

@ -711,13 +711,6 @@ int GM_SerialComSend(unsigned char * cSendBuf, unsigned long nSendLen, int commi
//memset(szbuf, 0, sizeof(szbuf)); //memset(szbuf, 0, sizeof(szbuf));
//sprintf(szbuf, "串口%d发送%d字节：", commid+1, len); //sprintf(szbuf, "串口%d发送%d字节：", commid+1, len);
//BytestreamLOG(szbuf, cSendBuf, len, 'D'); //BytestreamLOG(szbuf, cSendBuf, len, 'D');
#if 0
for (i = 0; i < len; i++)
{
sprintf(szbuf, "%s %02X", szbuf, cSendBuf[i]);
}
LOGE("%s", szbuf);
#endif
} }
return len; return len;
} }
@ -1217,29 +1210,29 @@ void FindDevUseSerialCommNo()
{ {
case WEATHER_PROTOCOL: case WEATHER_PROTOCOL:
case WIND_PROTOCOL: case WIND_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk0"); //sprintf(devparam[i].pathname, "/dev/swk3");
devparam[i].commid = 0; devparam[i].commid = 3;
break; break;
case SLANT_PROTOCOL: case SLANT_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk2"); //sprintf(devparam[i].pathname, "/dev/swk2");
devparam[i].commid = 2; devparam[i].commid = 2;
break; break;
case RALLY_PROTOCOL: case RALLY_PROTOCOL:
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); //memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/swk1"); //sprintf(devparam[i].pathname, "/dev/swk1");
devparam[i].commid = 1; devparam[i].commid = 1;
break; break;
case PELCO_D_PROTOCOL: /* 摄像机协议*/ case PELCO_D_PROTOCOL: /* 摄像机协议*/
case PELCO_P_PROTOCOL: /* 摄像机协议*/ case PELCO_P_PROTOCOL: /* 摄像机协议*/
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/ case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname)); memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/ /* 目前还不确定//具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
sprintf(devparam[i].pathname, "/dev/ttyS0"); //sprintf(devparam[i].pathname, "/dev/ttyS1");
devparam[i].commid = 0; devparam[i].commid = 0;
srdt.camerauseserial = 0; srdt.camerauseserial = 0;
break; break;
@ -1274,7 +1267,7 @@ void GM_StartSerialComm()
continue; continue;
serialport[i].Retry = 0; serialport[i].Retry = 0;
//serialport[i].RetryTime = 500/TIMER_CNT; //serialport[i].RetryTime = 500/TIMER_CNT;
serialport[i].RetryTime = 300/TIMER_CNT; serialport[i].RetryTime = 300;
serialport[i].WaitTime = 0; serialport[i].WaitTime = 0;
serialport[i].m_iRevStatus = 0; serialport[i].m_iRevStatus = 0;
serialport[i].m_iRecvLen = 0; serialport[i].m_iRecvLen = 0;
@ -1321,22 +1314,31 @@ void GM_StartSerialComm()
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0; srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<WEATHER_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case RALLY_PROTOCOL: /* 拉力*/ case RALLY_PROTOCOL: /* 拉力*/
sprintf(szbuf, "拉力"); sprintf(szbuf, "拉力");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0; srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<RALLY_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case WIND_PROTOCOL: /* 风速风向*/ case WIND_PROTOCOL: /* 风速风向*/
sprintf(szbuf, "风速风向"); sprintf(szbuf, "风速风向");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
for(j=0; j<WEATHER_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case SLANT_PROTOCOL: /* 倾角*/ case SLANT_PROTOCOL: /* 倾角*/
sprintf(szbuf, "倾角"); sprintf(szbuf, "倾角");
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec(); srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
srdt.ms_dev[i].recvdatacnt = 0;
for(j=0; j<SLANTANGLE_DATA_NUM; j++)
srdt.ms_dev[i].aiValue[j].AiState = StartSample;
break; break;
case PELCO_D_PROTOCOL: /* 摄像机协议*/ case PELCO_D_PROTOCOL: /* 摄像机协议*/
case PELCO_P_PROTOCOL: /* 摄像机协议*/ case PELCO_P_PROTOCOL: /* 摄像机协议*/
@ -1435,7 +1437,7 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
return; return;
serialport[i].Retry = 0; serialport[i].Retry = 0;
//serialport[i].RetryTime = 500/TIMER_CNT; //serialport[i].RetryTime = 500/TIMER_CNT;
serialport[i].RetryTime = 3000/TIMER_CNT; serialport[i].RetryTime = 1000;
serialport[i].WaitTime = 0; serialport[i].WaitTime = 0;
serialport[i].m_iRevStatus = 0; serialport[i].m_iRevStatus = 0;
serialport[i].m_iRecvLen = 0; serialport[i].m_iRecvLen = 0;
@ -1474,6 +1476,8 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
else else
srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx; srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx;
srdt.ms_dev[i].IsNeedSerial = 1; srdt.ms_dev[i].IsNeedSerial = 1;
if(0 == cmdidx)
srdt.ms_dev[i].image.state = StartSample;
if((0 == cmdidx) && (srdt.presetno > 0 )) if((0 == cmdidx) && (srdt.presetno > 0 ))
{ {
srdt.ms_dev[i].SerialCmdidx = 10017; srdt.ms_dev[i].SerialCmdidx = 10017;
@ -1498,7 +1502,6 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
Gm_OpenSensorsPower(); Gm_OpenSensorsPower();
Gm_OpenSerialPort(i); Gm_OpenSerialPort(i);
} }
} }
if(0x01 == flag) if(0x01 == flag)
{ {
@ -1512,7 +1515,7 @@ void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
if(GM_SerialTimer() < 0) if(GM_SerialTimer() < 0)
{ {
//LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE)); //LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
LOGV("退出采样流程！"); LOGV("退出拍照流程！");
//sleep(15); //sleep(15);
//GM_StartSerialComm(); //GM_StartSerialComm();
//GM_StartSerialCameraPhoto(1,0); //GM_StartSerialCameraPhoto(1,0);
@ -1544,7 +1547,7 @@ int GM_SerialTimer(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void Gm_FindAllSensorsCommand(void) void Gm_FindAllSensorsCommand()
{ {
int i, j,curidx,flag; int i, j,curidx,flag;
@ -1608,9 +1611,9 @@ void Gm_FindAllSensorsCommand(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void GM_IsCloseSensors(void) void GM_IsCloseSensors()
{ {
int i; int i, j;
char buf[256]; char buf[256];
for(i=0; i<MAX_SERIAL_DEV_NUM; i++) for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
@ -1633,6 +1636,20 @@ void GM_IsCloseSensors(void)
srdt.ms_dev[i].IsNeedSerial = 0; srdt.ms_dev[i].IsNeedSerial = 0;
// 关闭传感器电源 // 关闭传感器电源
LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1); LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1);
for(j=0;j<MAX_DEV_VALUE_NUM; j++)
{
if(StartSample == srdt.ms_dev[i].aiValue[j].AiState)
srdt.ms_dev[i].aiValue[j].AiState = SampleFail;
else if(Sample == srdt.ms_dev[i].aiValue[j].AiState)
srdt.ms_dev[i].aiValue[j].AiState = SamplingSuccess;
}
for(j=0; j<WEATHER_DATA_NUM; j++)
{
if(StartSample == weatherpntmsg[j].AiState)
weatherpntmsg[j].AiState = SampleFail;
else if(Sample == weatherpntmsg[j].AiState)
weatherpntmsg[j].AiState = SamplingSuccess;
}
} }
break; break;
case PELCO_D_PROTOCOL: /* 摄像机类型*/ case PELCO_D_PROTOCOL: /* 摄像机类型*/
@ -1640,6 +1657,10 @@ void GM_IsCloseSensors(void)
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/ case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
if(-1 == srdt.ms_dev[i].SerialCmdidx) if(-1 == srdt.ms_dev[i].SerialCmdidx)
{ {
if((StartSample == srdt.ms_dev[i].image.state) || (Sample == srdt.ms_dev[i].image.state))
srdt.ms_dev[i].image.state = SampleFail;
else if(PHOTO_SAVE_SUCC == srdt.ms_dev[i].image.state)
srdt.ms_dev[i].image.state = SamplingSuccess;
srdt.ms_dev[i].IsNeedSerial = 0; srdt.ms_dev[i].IsNeedSerial = 0;
LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel); LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel);
} }
@ -1655,7 +1676,7 @@ void GM_IsCloseSensors(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
void GM_AllSerialComRecv(void) void GM_AllSerialComRecv()
{ {
int i, j, recvlen; int i, j, recvlen;
u_char recvbuf[RECVDATA_MAXLENTH]; u_char recvbuf[RECVDATA_MAXLENTH];
@ -1690,7 +1711,7 @@ void GM_AllSerialComRecv(void)
输出参数: 输出参数:
其它说明: 其它说明:
*********************************************************************************/ *********************************************************************************/
int GM_CloseTimer(void) int GM_CloseTimer()
{ {
int i, j, iretime; int i, j, iretime;
char buf[256]; char buf[256];
@ -1770,9 +1791,9 @@ int SaveImageDataTofile(int devno)
return -1; return -1;
} }
// 写入文件到sdcard // 写入文件到sdcard
memset(filename, 0, sizeof(filename)); memset(pPortParam->image.photoname, 0, sizeof(pPortParam->image.photoname));
sprintf(filename, "%s%d-%d-%d.jpg", filedir,devparam[devno].CameraChannel, pPortParam->image.presetno, pPortParam->image.phototime); sprintf(pPortParam->image.photoname, "%s%d-%d-%d.jpg", filedir,devparam[devno].CameraChannel, pPortParam->image.presetno, pPortParam->image.phototime);
fp = fopen(filename, "wb+"); fp = fopen(pPortParam->image.photoname, "wb+");
if(NULL == fp) if(NULL == fp)
return -1; return -1;
len = fwrite(image,1, pPortParam->image.imagelen, fp); len = fwrite(image,1, pPortParam->image.imagelen, fp);
@ -1781,7 +1802,7 @@ int SaveImageDataTofile(int devno)
return -1; return -1;
else else
{ {
LOGI("写入图片文件%s成功！", filename); LOGI("写入图片文件%s成功！", pPortParam->image.photoname);
return 1; return 1;
} }
} }
@ -1937,6 +1958,7 @@ void CameraPhotoPortDataProcess( int devno)
LOGV("%s", szbuf); LOGV("%s", szbuf);
presetno = (int)rtumsg.MsgData[i+8]; presetno = (int)rtumsg.MsgData[i+8];
pPortParam->image.presetno = presetno; pPortParam->image.presetno = presetno;
pPortParam->image.state = Sample;
curserial->RevCmdFlag = 1; curserial->RevCmdFlag = 1;
pPortParam->SerialCmdidx = 1; pPortParam->SerialCmdidx = 1;
srdt.sendphotocmdcnt = 0; srdt.sendphotocmdcnt = 0;
@ -1967,7 +1989,8 @@ void CameraPhotoPortDataProcess( int devno)
} }
else else
{ {
SaveImageDataTofile(devno); if((1 == SaveImageDataTofile(devno)) && (Sample == pPortParam->image.state))
pPortParam->image.state = PHOTO_SAVE_SUCC;
recvend = 1; recvend = 1;
} }
} }
@ -2085,9 +2108,11 @@ void SendCmdFormPollCmdBuf( int port )
{ {
char buf[64]; char buf[64];
int len, ret; int len, ret;
long lctime;
SIO_PARAM_SERIAL_DEF *pPortParam; SIO_PARAM_SERIAL_DEF *pPortParam;
pPortParam = &serialport[port]; pPortParam = &serialport[port];
lctime = get_msec();
if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt) if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt)
{ {
pPortParam->ForceWaitCnt--; pPortParam->ForceWaitCnt--;
@ -2096,12 +2121,18 @@ void SendCmdFormPollCmdBuf( int port )
if(pPortParam->SendCmdFlag && (pPortParam->RevCmdFlag == 0)) if(pPortParam->SendCmdFlag && (pPortParam->RevCmdFlag == 0))
{ {
pPortParam->RetryTimeCnt++; //pPortParam->RetryTimeCnt++;
if(pPortParam->RetryTimeCnt < pPortParam->RetryTime) if((lctime - pPortParam->RetryTimeCnt > 3*pPortParam->RetryTime) || (lctime - pPortParam->RetryTimeCnt < 0))
{ {
pPortParam->RetryTimeCnt = lctime;
return; return;
} }
pPortParam->RetryTimeCnt = 0; if(lctime - pPortParam->RetryTimeCnt < pPortParam->RetryTime)
//if(pPortParam->RetryTimeCnt < pPortParam->RetryTime)
{
return;
}
pPortParam->RetryTimeCnt = lctime;
pPortParam->RetryCnt++; pPortParam->RetryCnt++;
if(pPortParam->RetryCnt > pPortParam->Retry) if(pPortParam->RetryCnt > pPortParam->Retry)
{ {
@ -2156,16 +2187,16 @@ void SendCmdFormPollCmdBuf( int port )
sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1); sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1);
BytestreamLOG(buf, &pPortParam->PollCmd[2], len, 'D'); BytestreamLOG(buf, &pPortParam->PollCmd[2], len, 'D');
LOGW("sendtimeconst= %ld", get_msec()-lsendtime); LOGW("sendtimeconst= %ld", lctime-lsendtime);
lsendtime = get_msec(); lsendtime = lctime;
} }
pPortParam->SendCmdFlag = 1; pPortParam->SendCmdFlag = 1;
pPortParam->ReSendCmdFlag = 0; pPortParam->ReSendCmdFlag = 0;
pPortParam->RevCmdFlag = 0; pPortParam->RevCmdFlag = 0;
pPortParam->RetryTimeCnt = 0; pPortParam->RetryTimeCnt = lctime;
//pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1; pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1;
//pPortParam->ForceWaitCnt /= TIMER_CNT; pPortParam->ForceWaitCnt /= TIMER_CNT;
if(pPortParam->ForceWaitCnt) if(pPortParam->ForceWaitCnt)
{ {
pPortParam->ForceWaitFlag = 1; pPortParam->ForceWaitFlag = 1;
@ -2178,7 +2209,7 @@ void ClearCmdAllFlag(int commid)
return; return;
serialport[commid].RetryCnt = 0; serialport[commid].RetryCnt = 0;
serialport[commid].RetryTimeCnt = 0; serialport[commid].RetryTimeCnt = get_msec();
serialport[commid].WaitTimeCnt = 0; serialport[commid].WaitTimeCnt = 0;
serialport[commid].ForceWaitFlag = 0; serialport[commid].ForceWaitFlag = 0;
serialport[commid].ForceWaitCnt = 0; serialport[commid].ForceWaitCnt = 0;
@ -2575,7 +2606,7 @@ int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd)
} }
// 发送转动摄像机云台命令定时器 // 发送转动摄像机云台命令定时器
int Gm_Camera_Timer(void) int Gm_Camera_Timer()
{ {
char szbuf[128]; char szbuf[128];
@ -3010,12 +3041,14 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < -59) ||(fvalue > 59)) if((fvalue < -59) ||(fvalue > 59))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
slantpntmsg[aipnt][0].EuValue *= (1+frnb); pPortParam->aiValue[0].EuValue *= (1+frnb);
} }
else else
slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;
+slantpntmsg[aipnt][0].AiParam.EuValueDelta; pPortParam->aiValue[0].AiState = Sample;
slantpntmsg[aipnt][0].AiState = 1; //slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
// +slantpntmsg[aipnt][0].AiParam.EuValueDelta;
//slantpntmsg[aipnt][0].AiState = 1;
//if ((gDisSunRain & 0x20) == 0x20) //if ((gDisSunRain & 0x20) == 0x20)
{ {
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue);
@ -3036,12 +3069,15 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < -59) ||(fvalue > 59)) if((fvalue < -59) ||(fvalue > 59))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
slantpntmsg[aipnt][1].EuValue *= (1+frnb); pPortParam->aiValue[1].EuValue *= (1+frnb);
//slantpntmsg[aipnt][1].EuValue *= (1+frnb);
} }
else else
slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\ pPortParam->aiValue[1].EuValue = fvalue;
pPortParam->aiValue[1].AiState = Sample;
/*slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
+slantpntmsg[aipnt][1].AiParam.EuValueDelta; +slantpntmsg[aipnt][1].AiParam.EuValueDelta;
slantpntmsg[aipnt][1].AiState = 1; slantpntmsg[aipnt][1].AiState = 1;*/
//YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue; //YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue;
srdt.SectimesamplingCnt[1] += 1; srdt.SectimesamplingCnt[1] += 1;
} }
@ -3049,20 +3085,6 @@ void ShxyProtocolDataProcess( int devno)
if((0x08 != cmdidx) && (0x09 != cmdidx)) if((0x08 != cmdidx) && (0x09 != cmdidx))
return; return;
#if 0
if(1 == srdt.IsReadWireTem)
{
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
{
if((WDIITEMP_PROTOCOL_NEW == srdt.ms_dev[i].ProtocolIdx) && (uDevAddr == (WORD)srdt.ms_dev[i].devaddr))
break;
}
if(i == MAX_SERIAL_DEV_NUM)
return;
pPortParam = &srdt.ms_dev[i];
aipnt = pPortParam->SameTypeDevIdx;
}
#endif
for(i = 0, j=7; (i<datanum) && (j<6+curserial->m_au8RecvBuf[1]); i++, j+=5 ) for(i = 0, j=7; (i<datanum) && (j<6+curserial->m_au8RecvBuf[1]); i++, j+=5 )
{ {
if(0x08 == cmdidx) if(0x08 == cmdidx)
@ -3076,21 +3098,24 @@ void ShxyProtocolDataProcess( int devno)
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1]; *((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1];
} }
switch(curserial->m_au8RecvBuf[j]) switch(curserial->m_au8RecvBuf[j])
{ {slantpntmsg[aipnt][1].EuValue *= (1+frnb)slantpntmsg[aipnt][1].EuValue *= (1+frnb);
case 1: /*温度*/ case 1: /*温度*/
if((fvalue < -40) ||(fvalue > 85)) if((fvalue < -40) ||(fvalue > 85))
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
pPortParam->aiValue[0].EuValue *= (1+frnb); pPortParam->aiValue[AirTempNo].EuValue *= (1+frnb);
weatherpntmsg[AirTempNo].EuValue *= (1+frnb); weatherpntmsg[AirTempNo].EuValue *= (1+frnb);
//weatherpntmsg[AirTempNo].AiState = Sample;
} }
else else
{ {
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor + pPortParam->aiValue[0].AiParam.EuValueDelta; pPortParam->aiValue[AirTempNo].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor + pPortParam->aiValue[0].AiParam.EuValueDelta;*/
weatherpntmsg[AirTempNo].EuValue = fvalue*weatherpntmsg[AirTempNo].AiParam.fFactor + weatherpntmsg[AirTempNo].AiParam.EuValueDelta; weatherpntmsg[AirTempNo].EuValue = fvalue;/*weatherpntmsg[AirTempNo].AiParam.fFactor + weatherpntmsg[AirTempNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[AirTempNo].AiState = Sample;
weatherpntmsg[AirTempNo].AiState = 1; weatherpntmsg[AirTempNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x01); //g_SelfTest.SensorsFault |= (0x01);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3102,16 +3127,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < 550) ||(fvalue > 1060)) if((fvalue < 550) ||(fvalue > 1060))
{ {
frnb = (GeneratingRandomNumber()%41-20)/10000.0; frnb = (GeneratingRandomNumber()%41-20)/10000.0;
pPortParam->aiValue[5].EuValue *= (1+frnb); pPortParam->aiValue[AtmosNo].EuValue *= (1+frnb);
weatherpntmsg[AtmosNo].EuValue *= (1+frnb); weatherpntmsg[AtmosNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[5].EuValue = fvalue*pPortParam->aiValue[5].AiParam.fFactor + pPortParam->aiValue[5].AiParam.EuValueDelta; pPortParam->aiValue[AtmosNo].EuValue = fvalue;/*pPortParam->aiValue[5].AiParam.fFactor + pPortParam->aiValue[5].AiParam.EuValueDelta;*/
weatherpntmsg[AtmosNo].EuValue = fvalue*weatherpntmsg[AtmosNo].AiParam.fFactor + weatherpntmsg[AtmosNo].AiParam.EuValueDelta; weatherpntmsg[AtmosNo].EuValue = fvalue;/*weatherpntmsg[AtmosNo].AiParam.fFactor + weatherpntmsg[AtmosNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[5].AiState = 1; pPortParam->aiValue[AtmosNo].AiState = Sample;
weatherpntmsg[AtmosNo].AiState = 1; weatherpntmsg[AtmosNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x10); //g_SelfTest.SensorsFault |= (0x10);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3123,16 +3148,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue < 0) ||(fvalue > 100)) if((fvalue < 0) ||(fvalue > 100))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[1].EuValue *= (1+frnb); pPortParam->aiValue[HumidityNo].EuValue *= (1+frnb);
weatherpntmsg[HumidityNo].EuValue *= (1+frnb); weatherpntmsg[HumidityNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[1].EuValue = fvalue*pPortParam->aiValue[1].AiParam.fFactor + pPortParam->aiValue[1].AiParam.EuValueDelta; pPortParam->aiValue[HumidityNo].EuValue = fvalue;/*pPortParam->aiValue[1].AiParam.fFactor + pPortParam->aiValue[1].AiParam.EuValueDelta;*/
weatherpntmsg[HumidityNo].EuValue = fvalue*weatherpntmsg[HumidityNo].AiParam.fFactor + weatherpntmsg[HumidityNo].AiParam.EuValueDelta; weatherpntmsg[HumidityNo].EuValue = fvalue;/*weatherpntmsg[HumidityNo].AiParam.fFactor + weatherpntmsg[HumidityNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[1].AiState = 1; pPortParam->aiValue[HumidityNo].AiState = Sample;
weatherpntmsg[HumidityNo].AiState = 1; weatherpntmsg[HumidityNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x02); //g_SelfTest.SensorsFault |= (0x02);
//if ((gDisSunRain & 0x80) == 0x80) //if ((gDisSunRain & 0x80) == 0x80)
{ {
@ -3145,19 +3170,19 @@ void ShxyProtocolDataProcess( int devno)
case 5: /*日照*/ case 5: /*日照*/
break; break;
case 6: /*风速*/ case 6: /*风速*/
if((fvalue/1000 < 0) ||(fvalue/1000 > 80)) if((fvalue < 0) ||(fvalue > 80))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[2].EuValue *= (1+frnb); pPortParam->aiValue[WindSpeedNo].EuValue *= (1+frnb);
weatherpntmsg[WindSpeedNo].EuValue *= (1+frnb); weatherpntmsg[WindSpeedNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[2].EuValue = fvalue*pPortParam->aiValue[2].AiParam.fFactor + pPortParam->aiValue[2].AiParam.EuValueDelta; pPortParam->aiValue[WindSpeedNo].EuValue = fvalue;/*pPortParam->aiValue[2].AiParam.fFactor + pPortParam->aiValue[2].AiParam.EuValueDelta;*/
weatherpntmsg[WindSpeedNo].EuValue = fvalue*weatherpntmsg[WindSpeedNo].AiParam.fFactor + weatherpntmsg[WindSpeedNo].AiParam.EuValueDelta; weatherpntmsg[WindSpeedNo].EuValue = fvalue;/*weatherpntmsg[WindSpeedNo].AiParam.fFactor + weatherpntmsg[WindSpeedNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[2].AiState = 1; pPortParam->aiValue[WindSpeedNo].AiState = Sample;
weatherpntmsg[WindSpeedNo].AiState = 1; weatherpntmsg[WindSpeedNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x04); //g_SelfTest.SensorsFault |= (0x04);
//if ((gDisSunRain & 0x10) == 0x10) //if ((gDisSunRain & 0x10) == 0x10)
{ {
@ -3173,16 +3198,16 @@ void ShxyProtocolDataProcess( int devno)
if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99)) if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99))
{ {
frnb = (GeneratingRandomNumber()%41-20)/1000.0; frnb = (GeneratingRandomNumber()%41-20)/1000.0;
pPortParam->aiValue[3].EuValue *= (1+frnb); pPortParam->aiValue[WindDirectionNo].EuValue *= (1+frnb);
weatherpntmsg[WindDirectionNo].EuValue *= (1+frnb); weatherpntmsg[WindDirectionNo].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[3].EuValue = fvalue*pPortParam->aiValue[3].AiParam.fFactor + pPortParam->aiValue[3].AiParam.EuValueDelta; pPortParam->aiValue[WindDirectionNo].EuValue = fvalue;/*pPortParam->aiValue[3].AiParam.fFactor + pPortParam->aiValue[3].AiParam.EuValueDelta;*/
weatherpntmsg[WindDirectionNo].EuValue = fvalue*weatherpntmsg[WindDirectionNo].AiParam.fFactor + weatherpntmsg[WindDirectionNo].AiParam.EuValueDelta; weatherpntmsg[WindDirectionNo].EuValue = fvalue;/*weatherpntmsg[WindDirectionNo].AiParam.fFactor + weatherpntmsg[WindDirectionNo].AiParam.EuValueDelta;*/
} }
pPortParam->aiValue[3].AiState = 1; pPortParam->aiValue[WindDirectionNo].AiState = Sample;
weatherpntmsg[WindDirectionNo].AiState = 1; weatherpntmsg[WindDirectionNo].AiState = Sample;
//g_SelfTest.SensorsFault |= (0x08); //g_SelfTest.SensorsFault |= (0x08);
//if ((gDisSunRain & 0x10) == 0x10) //if ((gDisSunRain & 0x10) == 0x10)
{ {
@ -3211,11 +3236,11 @@ void ShxyProtocolDataProcess( int devno)
if(pPortParam->recvdatacnt < 2) if(pPortParam->recvdatacnt < 2)
break; break;
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor\
+pPortParam->aiValue[0].AiParam.EuValueDelta; +pPortParam->aiValue[0].AiParam.EuValueDelta;*/
//rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\ //rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\
// +rallypntmsg[aipnt][0].AiParam.EuValueDelta; // +rallypntmsg[aipnt][0].AiParam.EuValueDelta;
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[0].AiState = Sample;
//rallypntmsg[aipnt][0].AiState = 1; //rallypntmsg[aipnt][0].AiState = 1;
sprintf(szbuf, "地址%d拉力:%0.3fKg ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "地址%d拉力:%0.3fKg ", devparam[devno].devaddr, fvalue);
LOGV("%s", szbuf); LOGV("%s", szbuf);
@ -3230,12 +3255,12 @@ void ShxyProtocolDataProcess( int devno)
} }
else else
{ {
pPortParam->aiValue[0].EuValue = fvalue*pPortParam->aiValue[0].AiParam.fFactor\ pPortParam->aiValue[0].EuValue = fvalue;/*pPortParam->aiValue[0].AiParam.fFactor\
+pPortParam->aiValue[0].AiParam.EuValueDelta; +pPortParam->aiValue[0].AiParam.EuValueDelta;*/
//slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\ //slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
//+slantpntmsg[aipnt][0].AiParam.EuValueDelta; //+slantpntmsg[aipnt][0].AiParam.EuValueDelta;
} }
pPortParam->aiValue[0].AiState = 1; pPortParam->aiValue[0].AiState = Sample;
//slantpntmsg[aipnt][0].AiState = 1; //slantpntmsg[aipnt][0].AiState = 1;
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue); sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[devno].devaddr, fvalue);
LOGV("%s", szbuf); LOGV("%s", szbuf);
@ -3248,16 +3273,13 @@ void ShxyProtocolDataProcess( int devno)
{ {
frnb = (GeneratingRandomNumber()%101-50)/1000.0; frnb = (GeneratingRandomNumber()%101-50)/1000.0;
pPortParam->aiValue[1].EuValue *= (1+frnb); pPortParam->aiValue[1].EuValue *= (1+frnb);
slantpntmsg[aipnt][1].EuValue *= (1+frnb);
} }
else else
{ {
pPortParam->aiValue[1].EuValue = fvalue*pPortParam->aiValue[1].AiParam.fFactor\ pPortParam->aiValue[1].EuValue = fvalue;/*pPortParam->aiValue[1].AiParam.fFactor\
+pPortParam->aiValue[1].AiParam.EuValueDelta; +pPortParam->aiValue[1].AiParam.EuValueDelta;*/
//slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
// +slantpntmsg[aipnt][1].AiParam.EuValueDelta;
} }
pPortParam->aiValue[1].AiState = 1; pPortParam->aiValue[1].AiState = Sample;
//slantpntmsg[aipnt][1].AiState = 1; //slantpntmsg[aipnt][1].AiState = 1;
break; break;
#if 0 #if 0
@ -3466,6 +3488,7 @@ int GeneratingRandomNumber(void)
return randomdate; return randomdate;
} }
/* 串口启动接口函数 开始*/
void Collect_sensor_data(SENSOR_PARAM *sensorParam) void Collect_sensor_data(SENSOR_PARAM *sensorParam)
{ {
int i; int i;
@ -3478,6 +3501,8 @@ void Collect_sensor_data(SENSOR_PARAM *sensorParam)
devparam[i].ProtocolIdx = sensorParam[i].SensorsType; devparam[i].ProtocolIdx = sensorParam[i].SensorsType;
devparam[i].devaddr = sensorParam[i].devaddr; devparam[i].devaddr = sensorParam[i].devaddr;
devparam[i].baudrate = getBaudrate(sensorParam[i].baudrate); devparam[i].baudrate = getBaudrate(sensorParam[i].baudrate);
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
memmove(devparam[i].pathname, sensorParam[i].pathname, sizeof(devparam[i].pathname));
devparam[i].databit = sensorParam[i].databit; devparam[i].databit = sensorParam[i].databit;
devparam[i].stopbit = (int)sensorParam[i].stopbit*10; devparam[i].stopbit = (int)sensorParam[i].stopbit*10;
devparam[i].CameraChannel = sensorParam[i].CameraChannel; devparam[i].CameraChannel = sensorParam[i].CameraChannel;
@ -3521,14 +3546,183 @@ void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_cha
//GM_StartSerialComm(); //GM_StartSerialComm();
GM_StartSerialCameraPhoto(1, cmdidx); GM_StartSerialCameraPhoto(1, cmdidx);
} }
/* 串口启动接口函数 结束*/
int GetAirTempData(Data_DEF *airt) /* 数据和图片采集数据返回函数 开始*/
int GetWeatherData(Data_DEF *data, int datano)
{ {
int i; int i;
if(NULL == data)
return -1;
if((AirTempNo > datano) || (datano > OpticalRadiationNo))
return -1;
data->EuValue = weatherpntmsg[datano].EuValue;
data->AiState = weatherpntmsg[datano].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
weatherpntmsg[datano].AiState = Idle;
return 2;
}
return 1;
}
int GetAirTempData(Data_DEF *airt)
{
if(NULL == airt) if(NULL == airt)
return -1; return -1;
airt->EuValue = weatherpntmsg[AirTempNo].EuValue; airt->EuValue = weatherpntmsg[AirTempNo].EuValue;
airt->AiState = weatherpntmsg[AirTempNo].AiState; airt->AiState = weatherpntmsg[AirTempNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[AirTempNo].AiState = Idle;
return 2;
}
return 1;
} }
int GetHumidityData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[HumidityNo].EuValue;
airt->AiState = weatherpntmsg[HumidityNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[HumidityNo].AiState = Idle;
return 2;
}
return 1;
}
int GetWindSpeedData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[WindSpeedNo].EuValue;
airt->AiState = weatherpntmsg[WindSpeedNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[WindSpeedNo].AiState = Idle;
return 2;
}
return 1;
}
int GetWindDirectionData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[WindDirectionNo].EuValue;
airt->AiState = weatherpntmsg[WindDirectionNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[WindDirectionNo].AiState = Idle;
return 2;
}
return 1;
}
int GetRainfallData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[RainfallNo].EuValue;
airt->AiState = weatherpntmsg[RainfallNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[RainfallNo].AiState = Idle;
return 2;
}
return 1;
}
int GetAtmosData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[AtmosNo].EuValue;
airt->AiState = weatherpntmsg[AtmosNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[AtmosNo].AiState = Idle;
return 2;
}
return 1;
}
int GetOpticalRadiationData(Data_DEF *airt)
{
if(NULL == airt)
return -1;
airt->EuValue = weatherpntmsg[OpticalRadiationNo].EuValue;
airt->AiState = weatherpntmsg[OpticalRadiationNo].AiState;
if((SampleFail == airt->AiState) || (SamplingSuccess == airt->AiState))
{
weatherpntmsg[OpticalRadiationNo].AiState = Idle;
return 2;
}
return 1;
}
int GetPullValue(int devno, Data_DEF *data)
{
if(NULL == data)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if(RALLY_PROTOCOL != devparam[devno].ProtocolIdx)
return -1;
data->EuValue = srdt.ms_dev[devno].aiValue[0].EuValue;
data->AiState = srdt.ms_dev[devno].aiValue[0].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
srdt.ms_dev[devno].aiValue[0].AiState = Idle;
return 2;
}
return 1;
}
int GetAngleValue(int devno, Data_DEF *data, int Xy)
{
if(NULL == data)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if(SLANT_PROTOCOL != devparam[devno].ProtocolIdx)
return -1;
if((0 > Xy) || (1 < Xy))
return -1;
data->EuValue = srdt.ms_dev[devno].aiValue[Xy].EuValue;
data->AiState = srdt.ms_dev[devno].aiValue[Xy].AiState;
if((SampleFail == data->AiState) || (SamplingSuccess == data->AiState))
{
srdt.ms_dev[devno].aiValue[Xy].AiState = Idle;
return 2;
}
return 1;
}
int GetImage(int devno, IMAGE_DEF *photo)
{
if(NULL == photo)
return -1;
if((0>devno)||(MAX_SERIAL_DEV_NUM < devno))
return -1;
if((PELCO_D_PROTOCOL != devparam[devno].ProtocolIdx) && (PELCO_P_PROTOCOL != devparam[devno].ProtocolIdx) &&(SERIALCAMERA_PROTOCOL != devparam[devno].ProtocolIdx))
return -1;
photo->presetno = srdt.ms_dev[devno].image.presetno;
photo->phototime = srdt.ms_dev[devno].image.phototime;
memset(photo->photoname, 0, sizeof(photo->photoname));
memmove(photo->photoname, srdt.ms_dev[devno].image.photoname, sizeof(photo->photoname));
photo->imagelen = srdt.ms_dev[devno].image.imagelen;
photo->state = srdt.ms_dev[devno].image.state;
if((SampleFail == photo->state) || (SamplingSuccess == photo->state))
{
srdt.ms_dev[devno].image.state = Idle;
return 2;
}
return 1;
}
/* 数据和图片采集数据返回函数 结束*/

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

@ -61,9 +61,10 @@ typedef unsigned char BYTE;
#define Idle 0 /* 传感器处于空闲状态，未启动采样*/ #define Idle 0 /* 传感器处于空闲状态，未启动采样*/
#define Sample 1 /* 正在采样过程中*/ #define Sample 1 /* 正在采样过程中*/
#define SamplingEnd 2 /* 采样结束*/ #define SamplingSuccess 2 /* 采样结束,正常读取到数据*/
#define StartSample 3 /* 启动采样*/ #define StartSample 3 /* 启动采样*/
#define SampleFail -1 /* 采样失败，传感器故障或未接*/ #define SampleFail -1 /* 采样失败，未采集到数据，传感器故障或未接*/
#define PHOTO_SAVE_SUCC 5 /* 图片保存成功*/
#define WEATHER_DATA_NUM 8 /* 气象数据最大数量(一般最多是6要素)*/ #define WEATHER_DATA_NUM 8 /* 气象数据最大数量(一般最多是6要素)*/
#define RALLY_DATA_NUM 2 /* 拉力数据最大数量(一般是1个)*/ #define RALLY_DATA_NUM 2 /* 拉力数据最大数量(一般是1个)*/
@ -110,6 +111,9 @@ typedef unsigned char BYTE;
#define D_MOVE_RIGHT 0x00022d00 /* 向右移动镜头(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 Auto_Scan 10006 /* 自动扫描功能控制(1/0 打开/关闭该功能)*/
#define IRIS_CLOSE 10007 /* 光圈缩小(1 有效)*/ #define IRIS_CLOSE 10007 /* 光圈缩小(1 有效)*/
#define IRIS_OPEN 10008 /* 光圈放大(1 有效)*/ #define IRIS_OPEN 10008 /* 光圈放大(1 有效)*/
@ -121,7 +125,8 @@ typedef unsigned char BYTE;
#define MOVE_UP 10014 /* 向上移动镜头(1 有效)*/ #define MOVE_UP 10014 /* 向上移动镜头(1 有效)*/
#define MOVE_LEFT 10015 /* 向左移动镜头(1 有效)*/ #define MOVE_LEFT 10015 /* 向左移动镜头(1 有效)*/
#define MOVE_RIGHT 10016 /* 向右移动镜头(1 有效)*/ #define MOVE_RIGHT 10016 /* 向右移动镜头(1 有效)*/
#define MOVE_PRESETNO 10017 // 调用预置点
#define SAVE_PRESETNO 10018 // 设置预置点
#define SPEED_DOME_CAMERA 0 /* 球机摄像机*/ #define SPEED_DOME_CAMERA 0 /* 球机摄像机*/
#define SERIAL_CAMERA 2 /* 串口摄像机a*/ #define SERIAL_CAMERA 2 /* 串口摄像机a*/
@ -171,14 +176,25 @@ typedef struct
float EuValue; // 数据工程值 float EuValue; // 数据工程值
} Data_DEF; } 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 typedef struct
{ {
int imagelen; // 整个图片大小 int imagelen; // 整个图片大小
int imagenum; // 整个图片的总包数 int imagenum; // 整个图片的总包数
int phototime; // 拍照时间 int phototime; // 拍照时间
u_char presetno; // 拍照预置点 u_char presetno; // 拍照预置点
char photoname[512]; // 图片存储名称和路径
u_char buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存 u_char buf[MAX_PHOTO_PACKET_NUM][MAX_PHOTO_FRAME_LEN]; // 图片数据缓存
int ilen[MAX_PHOTO_PACKET_NUM]; // 相对应的每包图片数据的长度 int ilen[MAX_PHOTO_PACKET_NUM]; // 相对应的每包图片数据的长度
int state;// 标识(-1：拍照失败；0:没有拍照；1：正在取图；2：拍照成功；3：启动拍照；）
} PHOTO_DEF; } PHOTO_DEF;
// 上层调用采集传感器参数 // 上层调用采集传感器参数
@ -188,6 +204,7 @@ typedef struct
int databit; /* 数据位*/ int databit; /* 数据位*/
float stopbit; /* 停止位*/ float stopbit; /* 停止位*/
char parity; /* 校验位*/ char parity; /* 校验位*/
char pathname[64]; /* 串口文件名及路径*/
//int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/ //int commNo; /* 约定的串口序号，例如我们PC机上显示的COM1。。。*/
u_char SensorsType; /* 传感器类型索引，大于 0*/ u_char SensorsType; /* 传感器类型索引，大于 0*/
int devaddr; /* 装置(传感器)使用的地址*/ int devaddr; /* 装置(传感器)使用的地址*/
@ -225,8 +242,8 @@ typedef struct
//******************** Poll Cmd **************************** //******************** Poll Cmd ****************************
u_char Retry; /* 重试命令次数 */ u_char Retry; /* 重试命令次数 */
u_char RetryCnt; /* 重试命令计数*/ u_char RetryCnt; /* 重试命令计数*/
u_long RetryTime; /* 重试命令时间 */ long RetryTime; /* 重试命令时间 */
u_long RetryTimeCnt; /* 重试命令时间计数*/ long RetryTimeCnt; /* 重试命令时间计数*/
u_long WaitTime; /* 命令间隔时间 */ u_long WaitTime; /* 命令间隔时间 */
u_long WaitTimeCnt; /* 命令间隔时间计数*/ u_long WaitTimeCnt; /* 命令间隔时间计数*/
u_char ForceWaitFlag; /* 强制等待标志*/ u_char ForceWaitFlag; /* 强制等待标志*/
@ -343,7 +360,7 @@ static void setCam3V3Enable(bool enabled);
// 串口相关的所有函数定义 // 串口相关的所有函数定义
/* 打开串口电源*/ /* 打开串口电源*/
void Gm_OpenSerialPower(void); void Gm_OpenSerialPower();
// 打开传感器电源 // 打开传感器电源
void Gm_OpenSensorsPower(); void Gm_OpenSensorsPower();
@ -354,27 +371,26 @@ void Gm_CloseSensorsPower(int port);
void Gm_OpenSerialPort(int devidx); void Gm_OpenSerialPort(int devidx);
// 关闭串口通讯 // 关闭串口通讯
void Gm_CloseSerialPort(void); void Gm_CloseSerialPort();
// 功能说明:串口发送数据 返回实际发送的字节数 // 功能说明:串口发送数据 返回实际发送的字节数
int GM_SerialComSend(const unsigned char * cSendBuf, unsigned long nSendLen, int commid); int GM_SerialComSend(const unsigned char * cSendBuf, unsigned long nSendLen, int commid);
void Gm_InitSerialComm(); void Gm_InitSerialComm();
void Collect_sensor_data(SENSOR_PARAM *sensorParam);
// 启动串口通讯 // 启动串口通讯
void GM_StartSerialComm(void); void GM_StartSerialComm();
// 启动使用串口拍照 // 启动使用串口拍照
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx); void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx);
// 串口轮询通讯定时器 // 串口轮询通讯定时器
int GM_SerialTimer(void); int GM_SerialTimer();
//轮询所有串口和传感器是否需要生成下发命令 //轮询所有串口和传感器是否需要生成下发命令
void Gm_FindAllSensorsCommand(void); void Gm_FindAllSensorsCommand();
//检查所有传感器是否采集完毕，采集完毕的关闭传感器电源 //检查所有传感器是否采集完毕，采集完毕的关闭传感器电源
void GM_IsCloseSensors(void); void GM_IsCloseSensors();
//检查所有串口是否有数据接收，有则启动接收 //检查所有串口是否有数据接收，有则启动接收
void GM_AllSerialComRecv(void); void GM_AllSerialComRecv();
//判断是否需要关闭定时器 //判断是否需要关闭定时器
int GM_CloseTimer(void); int GM_CloseTimer();
// 串口接收数据处理 // 串口接收数据处理
void SerialDataProcess(int devidx, u_char *buf, int len); void SerialDataProcess(int devidx, u_char *buf, int len);
@ -402,7 +418,7 @@ void ClearCmdFormPollCmdBuf(int port);
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd); int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd);
// 发送转动摄像机云台命令定时器 // 发送转动摄像机云台命令定时器
int Gm_Camera_Timer(void); int Gm_Camera_Timer();
// 生成 PELCO_P 命令 * // 生成 PELCO_P 命令 *
void Gm_SendPelco_pCommand( DWORD cmdtype); void Gm_SendPelco_pCommand( DWORD cmdtype);
@ -418,10 +434,10 @@ BYTE Gm_Pelco_DCheck( BYTE *msg, int len );
char Gm_GetSensorsPowerState(int port); char Gm_GetSensorsPowerState(int port);
// 通过传感器使用的航空头查找传感器使用的串口序号 // 通过传感器使用的航空头查找传感器使用的串口序号
void FindDevUseSerialCommNo(void); void FindDevUseSerialCommNo();
// 初始化所有串口及所接传感器的配置 // 初始化所有串口及所接传感器的配置
void Gm_InitSerialComm(void); void Gm_InitSerialComm();
// 寻找并生成下一条倾角命令 // 寻找并生成下一条倾角命令
int FindNextShxyProtocolCommand( int devidx ); int FindNextShxyProtocolCommand( int devidx );
@ -443,13 +459,35 @@ void ShxyProtocolDataProcess( int commid);
//void Gm_CtrlCloseSensorsPower(int devidx); //void Gm_CtrlCloseSensorsPower(int devidx);
// 检查传感器电源是否应该关闭或打开 // 检查传感器电源是否应该关闭或打开
//void Gm_CheckSensorsPower(void); //void Gm_CheckSensorsPower(void);
int Gm_SetSerialPortBaud(int commid); int SaveImageDataTofile(int devno);
// 得到串口波特率 void Collect_sensor_data(SENSOR_PARAM *sensorParam);
//T_baudrate Gm_GetSerialPortBaud(UART_baudrate Baudrate);
void Gm_CloseSerialCamera();
void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_char bImageSize, u_char presetno); void CameraPhotoCmd(SENSOR_PARAM *sensorParam, u_char channel, int cmdidx, u_char bImageSize, u_char presetno);
int SaveImageDataTofile(int devno);
/* 数据和图片采集数据返回函数 开始*/
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(); int GeneratingRandomNumber();

Write Preview
Loading…
Cancel
Save