|
|
#include <jni.h>
|
|
|
#include <string>
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
#include <unistd.h>
|
|
|
#include <sys/ioctl.h>
|
|
|
#include <linux/spi/spidev.h>
|
|
|
#include <android/log.h>
|
|
|
#include <stdio.h>
|
|
|
#include <dirent.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <unistd.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <string.h>
|
|
|
#include <termios.h>
|
|
|
#include <time.h>
|
|
|
#include "GPIOControl.h"
|
|
|
#include "serialComm.h"
|
|
|
#include "SensorsProtocol.h"
|
|
|
#include <sys/time.h>
|
|
|
#include "SensorsProtocol.h"
|
|
|
//#include "Eint.h"
|
|
|
|
|
|
SIO_PARAM_SERIAL_DEF serialport[MAX_SERIAL_PORT_NUM];
|
|
|
SERIAL_PARAM devparam[MAX_SERIAL_DEV_NUM];
|
|
|
|
|
|
//float weatherpntmsg[10];
|
|
|
|
|
|
static void setInt(int cmd, int value)
|
|
|
{
|
|
|
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
|
|
|
IOT_PARAM param;
|
|
|
param.cmd = cmd;
|
|
|
param.value = value;
|
|
|
// LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
|
|
|
if( fd > 0 )
|
|
|
{
|
|
|
ioctl(fd, IOT_PARAM_WRITE, ¶m);
|
|
|
// LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
|
|
|
close(fd);
|
|
|
}
|
|
|
//return;
|
|
|
}
|
|
|
|
|
|
int getInt(int cmd)
|
|
|
{
|
|
|
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
|
|
|
// LOGE("get_int fd=%d,cmd=%d\r\n",fd, cmd);
|
|
|
if( fd > 0 )
|
|
|
{
|
|
|
IOT_PARAM param;
|
|
|
param.cmd = cmd;
|
|
|
ioctl(fd, IOT_PARAM_READ, ¶m);
|
|
|
#ifdef _DEBUG
|
|
|
ALOGI("getInt cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
|
|
|
#endif
|
|
|
close(fd);
|
|
|
return param.value;
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
static void setRS485Enable(bool z) {
|
|
|
setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
static void set485WriteMode() {
|
|
|
setInt(CMD_SET_485_STATE, 1);
|
|
|
}
|
|
|
|
|
|
static void set485ReadMode() {
|
|
|
setInt(CMD_SET_485_STATE, 0);
|
|
|
}
|
|
|
static void set12VEnable(bool z) {
|
|
|
setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
static void setCam3V3Enable(bool enabled)
|
|
|
{
|
|
|
setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
/*********************************************************************************
|
|
|
* 气象数据处理 *
|
|
|
**********************************************************************************/
|
|
|
static void PortDataProcess( void )
|
|
|
{
|
|
|
float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
|
|
|
//WORD uDevAddr;
|
|
|
unsigned char cmdidx;
|
|
|
int i, j, aipnt, datanum;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
char szbuf[64];
|
|
|
|
|
|
pPortParam = &serialport;
|
|
|
//取出装置地址,开始处理地址+++
|
|
|
if(0x02 == pPortParam->m_au8RecvBuf[5])
|
|
|
{
|
|
|
//pPortParam->devaddr = pPortParam->m_au8RecvBuf[4];
|
|
|
return;
|
|
|
}
|
|
|
cmdidx = pPortParam->m_au8RecvBuf[5];
|
|
|
#if 0
|
|
|
aipnt = pPortParam->SameTypeDevIdx;
|
|
|
uDevAddr = serialport->m_au8RecvBuf[4];
|
|
|
if(0 == srdt.IsReadWireTem)
|
|
|
{
|
|
|
if(uDevAddr != pPortParam->devaddr)
|
|
|
return;
|
|
|
}
|
|
|
#endif
|
|
|
fvalua = &fvalue;
|
|
|
datanum = pPortParam->m_au8RecvBuf[6];
|
|
|
if((0x08 != cmdidx) && (0x09 != cmdidx))
|
|
|
return;
|
|
|
|
|
|
for(i = 0, j=7; (i<datanum) && (j<6+pPortParam->m_au8RecvBuf[1]); i++, j+=5 )
|
|
|
{
|
|
|
if(0x08 == cmdidx)
|
|
|
fvalue = (pPortParam->m_au8RecvBuf[j+1]<<24)+(pPortParam->m_au8RecvBuf[j+2]<<16)
|
|
|
+(pPortParam->m_au8RecvBuf[j+3]<<8)+pPortParam->m_au8RecvBuf[j+4];
|
|
|
else
|
|
|
{
|
|
|
*(u_char *)fvalua = pPortParam->m_au8RecvBuf[j+4];
|
|
|
*((u_char *)fvalua+1) = pPortParam->m_au8RecvBuf[j+3];
|
|
|
*((u_char *)fvalua+2) = pPortParam->m_au8RecvBuf[j+2];
|
|
|
*((u_char *)fvalua+3) = pPortParam->m_au8RecvBuf[j+1];
|
|
|
}
|
|
|
switch(pPortParam->m_au8RecvBuf[j])
|
|
|
{
|
|
|
case 1: /*温度*/
|
|
|
weatherpntmsg[0] = fvalue;
|
|
|
LOGE("温度:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 2: /*气压*/
|
|
|
weatherpntmsg[5] = fvalue;
|
|
|
LOGE("气压:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 3: /*湿度*/
|
|
|
weatherpntmsg[1] = fvalue;
|
|
|
LOGE("湿度:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 4: /*雨量*/
|
|
|
break;
|
|
|
case 5: /*日照*/
|
|
|
break;
|
|
|
case 6: /*风速*/
|
|
|
weatherpntmsg[2] = fvalue;
|
|
|
LOGE("风速:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 7: /*风向*/
|
|
|
weatherpntmsg[3] = fvalue;
|
|
|
LOGE("风向:%0.3f ", fvalue);
|
|
|
break;
|
|
|
case 8: /*拉力*/
|
|
|
case 9: /*倾角传感器X轴倾角*/
|
|
|
case 10: /*倾角传感器Y轴倾角*/
|
|
|
case 11: /*测温球导线温度*/
|
|
|
case 12: /*测温球内部温度*/
|
|
|
break;
|
|
|
case 13: /*测温球导线X轴倾角*/
|
|
|
break;
|
|
|
case 14: /*测温球导线Y轴倾角*/
|
|
|
break;
|
|
|
case 15: /*测温球导线电流*/
|
|
|
break;
|
|
|
case 16: /*测温球电池电压*/
|
|
|
break;
|
|
|
case 17: /*A相泄漏电流平均值；*/
|
|
|
break;
|
|
|
case 18: /*A相泄漏电流最大值；*/
|
|
|
break;
|
|
|
case 19: /*A相超过3mA的脉冲频次*/
|
|
|
break;
|
|
|
case 20: /*A相超过10mA的脉冲频次*/
|
|
|
break;
|
|
|
case 21: /*B相泄漏电流平均值；*/
|
|
|
break;
|
|
|
case 22: /*B相泄漏电流最大值；*/
|
|
|
break;
|
|
|
case 23: /*B相超过3mA的脉冲频次*/
|
|
|
break;
|
|
|
case 24: /*B相超过10mA的脉冲频次*/
|
|
|
case 25: /*C相泄漏电流平均值；*/
|
|
|
case 26: /*C相泄漏电流最大值；*/
|
|
|
case 27: /*C相超过3mA的脉冲频次*/
|
|
|
case 28: /*C相超过10mA的脉冲频次*/
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/***************************************************************
|
|
|
* 按照协议格式化接收数据 *
|
|
|
***************************************************************/
|
|
|
static void RecvData(u_char *buf, int len)// 规约读数据处理
|
|
|
{
|
|
|
int i, ictime;
|
|
|
//WORD crc, check;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
|
|
|
pPortParam = &serialport;
|
|
|
ictime = (int)time(NULL);
|
|
|
|
|
|
if(pPortParam->m_iRecvLen == 0)
|
|
|
{
|
|
|
pPortParam->iRecvTime = ictime;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if((ictime-pPortParam->iRecvTime > 6) || (ictime - pPortParam->iRecvTime < 0))
|
|
|
pPortParam->iRecvTime = ictime;
|
|
|
else if(ictime - pPortParam->iRecvTime > 2)
|
|
|
{
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for(i=0; i<len; i++)
|
|
|
{
|
|
|
switch(pPortParam->m_iRevStatus)
|
|
|
{
|
|
|
case 0: // 0x68
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 1: // len1
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
break;
|
|
|
case 2: // len2
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
|
|
|
{
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
pPortParam->m_iNeedRevLength = buf[i]+5;
|
|
|
}
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 3: // 0x68
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 4: // 正确接收数据
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iNeedRevLength > 0)
|
|
|
break;
|
|
|
if(buf[i] != 0x16)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus=18;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
//if(CheckLpcError(serialport->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
|
|
|
{
|
|
|
PortDataProcess();
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->RevCmdFlag = 1;
|
|
|
}
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
break;
|
|
|
case 255:// 错误接收数据
|
|
|
default:
|
|
|
if(buf[i] == 0x68)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus = 1;
|
|
|
pPortParam->m_iRecvLen = 1;
|
|
|
pPortParam->m_au8RecvBuf[0] = buf[i];
|
|
|
}
|
|
|
else if(buf[i] == 0x16)
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iRecvLen > 200)
|
|
|
{
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static long get_msec(void )
|
|
|
{
|
|
|
struct timeval tv;
|
|
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
long time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000;
|
|
|
|
|
|
return time_in_msec;
|
|
|
}
|
|
|
//int inum =0;
|
|
|
//int itimecnt=0;
|
|
|
static int weather_comm(SERIAL_PARAM weatherport)
|
|
|
{
|
|
|
int fd = -1;
|
|
|
int len, i,ret, icnt=0;
|
|
|
long ictime, iruntime, isendtime, irecvtime;
|
|
|
unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16};
|
|
|
char recvbuf[256], szbuf[512];
|
|
|
//char serial_description[] = "/dev/ttyS0";
|
|
|
|
|
|
#if 0
|
|
|
DIR *dir = opendir("/dev");
|
|
|
if (dir == NULL) {
|
|
|
LOGE("_test_ opendir");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 读取目录项
|
|
|
struct dirent *entry;
|
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
|
// 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
|
|
|
if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
|
|
|
(strncmp(entry->d_name, "ttyS0", 5) == 0)) {
|
|
|
LOGE("_test_ Found serial port: %s\n", entry->d_name);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 关闭目录
|
|
|
closedir(dir);
|
|
|
#endif
|
|
|
serialport.RevCmdFlag = 1;
|
|
|
serialport.m_iRecvLen = 0;
|
|
|
serialport.m_iRevStatus = 0;
|
|
|
|
|
|
set12VEnable(true);
|
|
|
setCam3V3Enable(true);
|
|
|
setRS485Enable(true);
|
|
|
sleep(2);
|
|
|
//ictime = (int)time(NULL);
|
|
|
ictime = get_msec();
|
|
|
for(;;)
|
|
|
{
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
fd = open(weatherport.pathname, O_RDWR | O_NDELAY);
|
|
|
//fd = open(weatherport.pathname, O_RDWR | O_NOCTTY);
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
LOGE("_test_ open serial error \n");
|
|
|
perror(weatherport.pathname);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
ret= set_port_attr (fd, weatherport.baudrate,weatherport.databit,weatherport.stopbit,weatherport.parity,0,0 );/*9600 8n1 */
|
|
|
if(ret < 0)
|
|
|
{
|
|
|
LOGE("_test_ set uart arrt faile \n");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
usleep(10000);
|
|
|
//iruntime = (int)time(NULL);
|
|
|
iruntime = get_msec();
|
|
|
if((iruntime - ictime > 120000) || (iruntime - ictime < 0))
|
|
|
ictime = iruntime;
|
|
|
if(iruntime - ictime > 20000)
|
|
|
{
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "气象采样时间=%0.3f秒,停止采样!", (iruntime-ictime)/1000.0);
|
|
|
LOGE("%s", szbuf);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if(1 == serialport.RevCmdFlag)
|
|
|
{
|
|
|
set485WriteMode();
|
|
|
|
|
|
len = write(fd, sendbuf, sizeof(sendbuf));/* 向串囗发送字符串 */
|
|
|
serialport.RevCmdFlag = 0;
|
|
|
LOGE("发送命令时间差%ld毫秒", get_msec()-isendtime);
|
|
|
//isendtime = time(NULL);
|
|
|
isendtime = get_msec();
|
|
|
if (len < 0) {
|
|
|
LOGE("write data error \n");
|
|
|
return -1;
|
|
|
} else {
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "Send：");
|
|
|
for (i = 0; i < len; i++) {
|
|
|
sprintf(szbuf, "%s %02X", szbuf, sendbuf[i]);
|
|
|
}
|
|
|
LOGE("%s", szbuf);
|
|
|
//icnt = 0;
|
|
|
//inum++;
|
|
|
}
|
|
|
tcdrain(fd);
|
|
|
//usleep(50000);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//irecvtime = time(NULL);
|
|
|
irecvtime = get_msec();
|
|
|
if((irecvtime-isendtime > 6000) ||(irecvtime - isendtime < 0))
|
|
|
isendtime = irecvtime;
|
|
|
if (irecvtime-isendtime > 300)
|
|
|
{
|
|
|
LOGE("传感器超过%ld毫秒未应答", irecvtime-isendtime);
|
|
|
serialport.RevCmdFlag = 1;
|
|
|
serialport.m_iRecvLen = 0;
|
|
|
serialport.m_iRevStatus = 0;
|
|
|
close(fd);
|
|
|
fd = -1;
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
set485ReadMode();
|
|
|
memset(recvbuf, 0, sizeof(recvbuf));
|
|
|
len = read(fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
|
|
|
if (len < 0) {
|
|
|
LOGE("serial read error \n");
|
|
|
continue;
|
|
|
}
|
|
|
if(0 == len)
|
|
|
{
|
|
|
//icnt++;
|
|
|
continue;
|
|
|
}
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
sprintf(szbuf, "Recv：");
|
|
|
for (i = 0; i < len; i++) {
|
|
|
sprintf(szbuf, "%s %02X", szbuf, recvbuf[i]);
|
|
|
}
|
|
|
__android_log_print(ANDROID_LOG_INFO, "serial", "%s", szbuf);
|
|
|
RecvData((u_char*)recvbuf, len);
|
|
|
//LOGE("一周期空循环次数%d, 读取次数%d, 时间：%d %d", icnt, inum, (int)time(NULL), itimecnt);
|
|
|
icnt = 0;
|
|
|
//serialport.RevCmdFlag =1;
|
|
|
}
|
|
|
|
|
|
close(fd);
|
|
|
set12VEnable(false);
|
|
|
setCam3V3Enable(false);
|
|
|
setRS485Enable(false);
|
|
|
|
|
|
//exit(-1);
|
|
|
return(0);
|
|
|
}
|
|
|
|
|
|
int serial_port_comm()
|
|
|
{
|
|
|
SERIAL_PARAM portparm;
|
|
|
|
|
|
//struct timeval tv;
|
|
|
|
|
|
//gettimeofday(&tv, NULL);
|
|
|
//long time_in_microseconds = tv.tv_sec * 1000000 + tv.tv_usec;
|
|
|
|
|
|
//LOGE("Current time in microseconds: %ld\n", time_in_microseconds);
|
|
|
|
|
|
#if 1
|
|
|
memset(portparm.pathname, 0, sizeof(portparm.pathname));
|
|
|
sprintf(portparm.pathname, "/dev/ttyS0");
|
|
|
portparm.parity = 'N';
|
|
|
portparm.databit = 8;
|
|
|
portparm.baudrate = B9600;
|
|
|
memset(portparm.stopbit, 0, sizeof(portparm.stopbit));
|
|
|
sprintf(portparm.stopbit, "1");
|
|
|
#endif
|
|
|
//itimecnt = (int)time(NULL);
|
|
|
|
|
|
//for(;;)
|
|
|
weather_comm(portparm);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
static speed_t getBaudrate(int baudrate)
|
|
|
{
|
|
|
switch(baudrate) {
|
|
|
case 0: return B0;
|
|
|
case 50: return B50;
|
|
|
case 75: return B75;
|
|
|
case 110: return B110;
|
|
|
case 134: return B134;
|
|
|
case 150: return B150;
|
|
|
case 200: return B200;
|
|
|
case 300: return B300;
|
|
|
case 600: return B600;
|
|
|
case 1200: return B1200;
|
|
|
case 1800: return B1800;
|
|
|
case 2400: return B2400;
|
|
|
case 4800: return B4800;
|
|
|
case 9600: return B9600;
|
|
|
case 19200: return B19200;
|
|
|
case 38400: return B38400;
|
|
|
case 57600: return B57600;
|
|
|
case 115200: return B115200;
|
|
|
case 230400: return B230400;
|
|
|
case 460800: return B460800;
|
|
|
case 500000: return B500000;
|
|
|
case 576000: return B576000;
|
|
|
case 921600: return B921600;
|
|
|
case 1000000: return B1000000;
|
|
|
case 1152000: return B1152000;
|
|
|
case 1500000: return B1500000;
|
|
|
case 2000000: return B2000000;
|
|
|
case 2500000: return B2500000;
|
|
|
case 3000000: return B3000000;
|
|
|
case 3500000: return B3500000;
|
|
|
case 4000000: return B4000000;
|
|
|
default: return -1;
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
//u_char serialstatus[MAX_SERIAL_PORT_NUM];
|
|
|
SRDT_DEF srdt;
|
|
|
AI_DEF weatherpntmsg[WEATHER_DATA_NUM];
|
|
|
AI_DEF rallypntmsg[6][RALLY_DATA_NUM];
|
|
|
AI_DEF slantpntmsg[6][SLANTANGLE_DATA_NUM];
|
|
|
|
|
|
//extern void * memset(void *m, int c, unsigned int n);
|
|
|
//extern int atoi(const char *s);
|
|
|
//extern int Gm_GetSamplingTimeSec(void);
|
|
|
//extern void Delayms(kal_uint32 time);
|
|
|
//extern void srand( unsigned int seed );
|
|
|
//extern int rand( void );
|
|
|
|
|
|
static long get_msec()
|
|
|
{
|
|
|
struct timeval tv;
|
|
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
long time_in_msec = tv.tv_sec * 1000 + tv.tv_usec/1000;
|
|
|
|
|
|
return time_in_msec;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
打开串口电源
|
|
|
*/
|
|
|
void Gm_OpenSerialPower()
|
|
|
{
|
|
|
/*由传送的主站的地方来控制串口电源，这里不实现*/;
|
|
|
}
|
|
|
|
|
|
// 关闭串口电源
|
|
|
void Gm_CloseSerialPower()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
// 关闭传感器电源
|
|
|
void Gm_CloseSensorsPower(int port)
|
|
|
{
|
|
|
//char iIoNo;
|
|
|
char szbuf[128];
|
|
|
|
|
|
sprintf(szbuf, "Close Sensors port %d Power!", port);
|
|
|
|
|
|
/* 关闭电源*/
|
|
|
//switch(port)
|
|
|
/* 根据硬件具体布置最后调整，目前是微拍板子的来控制*/
|
|
|
set12VEnable(false);
|
|
|
setCam3V3Enable(false);
|
|
|
setRS485Enable(false);
|
|
|
|
|
|
}
|
|
|
|
|
|
// 打开传感器电源
|
|
|
void Gm_OpenSensorsPower(int port)
|
|
|
{
|
|
|
//char iIoNo;
|
|
|
char szbuf[128];
|
|
|
|
|
|
if(0 == port)
|
|
|
return;
|
|
|
sprintf(szbuf, "Open Sensors port %d Power!", port);
|
|
|
|
|
|
set12VEnable(true);
|
|
|
setCam3V3Enable(true);
|
|
|
setRS485Enable(true);
|
|
|
|
|
|
/* 打开电源*/
|
|
|
//switch(port)
|
|
|
|
|
|
}
|
|
|
|
|
|
// 查询传感器电源状态
|
|
|
char Gm_GetSensorsPowerState(int port)
|
|
|
{
|
|
|
char iIoNo, cstate=0;
|
|
|
//char szbuf[128];
|
|
|
|
|
|
/* 查询电源状态*/
|
|
|
//switch(port)
|
|
|
|
|
|
|
|
|
return cstate;
|
|
|
}
|
|
|
|
|
|
void BytestreamLOG(char* describe, u_char* buf, int len, char flag)
|
|
|
{
|
|
|
int i;
|
|
|
char szbuf[4096];
|
|
|
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
if(NULL != describe)
|
|
|
strncpy(szbuf, describe, strlen(describe));
|
|
|
for (i = 0; i < len; i++)
|
|
|
{
|
|
|
sprintf(szbuf, "%s %02X", szbuf, buf[i]);
|
|
|
}
|
|
|
switch (flag)
|
|
|
{
|
|
|
case 'E':
|
|
|
LOGE("%s", szbuf);
|
|
|
break;
|
|
|
case 'I':
|
|
|
LOGI("%s", szbuf);
|
|
|
break;
|
|
|
case 'D':
|
|
|
LOGD("%s", szbuf);
|
|
|
break;
|
|
|
case 'V':
|
|
|
LOGV("%s", szbuf);
|
|
|
break;
|
|
|
case 'W':
|
|
|
LOGW("%s", szbuf);
|
|
|
break;
|
|
|
default:
|
|
|
LOGI("%s", szbuf);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 打开串口通讯
|
|
|
void Gm_OpenSerialPort(int devidx)
|
|
|
{
|
|
|
int fd = -1;
|
|
|
|
|
|
if((devidx < 0) || (devidx >= MAX_SERIAL_DEV_NUM))
|
|
|
return;
|
|
|
if(serialport[devparam[devidx].commid].fd < 0)
|
|
|
{
|
|
|
fd = open(devparam[devidx].pathname, O_RDWR | O_NDELAY);
|
|
|
if(fd < 0)
|
|
|
{
|
|
|
LOGE("装置%d 打开串口%d失败！fd=%d\n", devidx+1, devparam[devidx].commid+1, fd);
|
|
|
return;
|
|
|
}
|
|
|
LOGI("装置%d 打开串口%d成功！fd=%d\n", devidx+1, devparam[devidx].commid+1, fd);
|
|
|
serialport[devparam[devidx].commid].fd = fd;
|
|
|
return;
|
|
|
}
|
|
|
LOGI("装置%d 串口%d已经打开！fd=%d\n", devidx+1, devparam[devidx].commid+1, serialport[devparam[devidx].commid].fd);
|
|
|
}
|
|
|
|
|
|
// 关闭串口通讯
|
|
|
void Gm_CloseSerialPort()
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
|
|
|
{
|
|
|
if(serialport[i].fd > 0)
|
|
|
{
|
|
|
close(serialport[i].fd);
|
|
|
serialport[i].fd = -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
|
函数名称: int GM_SerialComSend(const BYTE * cSendBuf, DWORD nSendLen, int commid)
|
|
|
功能说明:串口发送数据 返回实际发送的字节数
|
|
|
输入参数:
|
|
|
输出参数:
|
|
|
其它说明:
|
|
|
*********************************************************************************/
|
|
|
int GM_SerialComSend(unsigned char * cSendBuf, unsigned long nSendLen, int commid)
|
|
|
{
|
|
|
int i, len;
|
|
|
char szbuf[512];
|
|
|
|
|
|
len = write(serialport[commid].fd, cSendBuf, nSendLen);/* 向串囗发送字符串 */
|
|
|
//serialport[commid].RevCmdFlag = 0;
|
|
|
//LOGE("发送命令时间差%ld毫秒", get_msec() - isendtime);
|
|
|
//isendtime = time(NULL);
|
|
|
//isendtime = get_msec();
|
|
|
if (len < 0)
|
|
|
{
|
|
|
LOGE("write data error \n");
|
|
|
return -1;
|
|
|
}
|
|
|
else if(len > 0)
|
|
|
{
|
|
|
//memset(szbuf, 0, sizeof(szbuf));
|
|
|
//sprintf(szbuf, "串口%d发送%d字节：", commid+1, len);
|
|
|
//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;
|
|
|
}
|
|
|
|
|
|
int Gm_SetSerialPortParam(int commid)
|
|
|
{
|
|
|
int ret;
|
|
|
SERIAL_PARAM *pPortParam=NULL;
|
|
|
|
|
|
pPortParam = &devparam[srdt.curdevidx[commid]];
|
|
|
ret= set_port_attr (serialport[commid].fd, pPortParam->baudrate,pPortParam->databit,pPortParam->stopbit,pPortParam->parity,0,0 );/*9600 8n1 */
|
|
|
if(ret < 0)
|
|
|
{
|
|
|
LOGE("串口%d 波特率等参数设置错误！", commid+1);
|
|
|
return -1;
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
void Gm_InitSerialComm_Test()
|
|
|
{
|
|
|
int i, j;
|
|
|
|
|
|
srdt.sampling = 0;
|
|
|
srdt.PtzCmdType = Cmd_Cancel; // 云台指令类型
|
|
|
for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
|
|
|
{
|
|
|
//***************** 串行端口信息 ************************
|
|
|
//g_serialparam[i].Baud = 1200;
|
|
|
//g_serialparam[i].dataBits = 8;
|
|
|
//g_serialparam[i].stopBits = 1;
|
|
|
//g_serialparam[i].parity = 0;
|
|
|
//******************** Poll Cmd ****************************
|
|
|
serialport[i].Retry = 0;
|
|
|
//serialport[i].RetryTime = 500/TIMER_CNT;
|
|
|
j = TIMER_CNT;
|
|
|
serialport[i].RetryTime = 300/TIMER_CNT;
|
|
|
j = 1500/TIMER_CNT;
|
|
|
serialport[i].WaitTime = 0;
|
|
|
memset(serialport[i].m_au8RecvBuf, 0, RECVDATA_MAXLENTH); // 接收数据缓存区
|
|
|
ClearCmdFormPollCmdBuf(i);
|
|
|
}
|
|
|
//g_serialparam[1].Baud = 1200;
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
devparam[i].IsNoInsta = 0;
|
|
|
devparam[0].ProtocolIdx = WEATHER_PROTOCOL;
|
|
|
devparam[0].baudrate = B9600;
|
|
|
devparam[0].databit = 8;
|
|
|
memset(devparam[0].stopbit, 0, sizeof(devparam[0].stopbit));
|
|
|
sprintf(devparam[0].stopbit, "1");
|
|
|
devparam[0].parity = 0;
|
|
|
devparam[0].IsNoInsta = 1;
|
|
|
//devparam[0].PowerPort = 2;
|
|
|
//devparam[0].devaddr = 4;
|
|
|
devparam[0].devaddr = 2;
|
|
|
|
|
|
devparam[1].ProtocolIdx = WEATHER_PROTOCOL;
|
|
|
devparam[1].baudrate = B9600;
|
|
|
devparam[1].databit = 8;
|
|
|
memset(devparam[1].stopbit, 0, sizeof(devparam[1].stopbit));
|
|
|
sprintf(devparam[1].stopbit, "1");
|
|
|
devparam[1].parity = 0;
|
|
|
devparam[1].IsNoInsta = 1;
|
|
|
//devparam[1].PowerPort = 14;
|
|
|
//devparam[1].devaddr = 1;
|
|
|
devparam[1].devaddr = 13;
|
|
|
|
|
|
devparam[2].ProtocolIdx = RALLY_PROTOCOL;
|
|
|
devparam[2].baudrate = B9600;
|
|
|
devparam[2].databit = 8;
|
|
|
memset(devparam[2].stopbit, 0, sizeof(devparam[2].stopbit));
|
|
|
sprintf(devparam[2].stopbit, "1");
|
|
|
devparam[2].parity = 0;
|
|
|
devparam[2].IsNoInsta = 1;
|
|
|
//devparam[2].PowerPort = 3;
|
|
|
//devparam[2].devaddr = 13;
|
|
|
devparam[2].devaddr = 13;
|
|
|
#if 0
|
|
|
devparam[3].ProtocolIdx = PELCO_P_PROTOCOL;
|
|
|
devparam[3].baudrate = 9600;
|
|
|
devparam[3].databit = 8;
|
|
|
devparam[3].stopbit = 1;
|
|
|
devparam[3].parity = 0;
|
|
|
devparam[3].IsNoInsta = 0;
|
|
|
//devparam[3].PowerPort = 15;
|
|
|
devparam[3].CameraChannel = 1;
|
|
|
devparam[3].devaddr = 0;
|
|
|
|
|
|
devparam[4].ProtocolIdx = WDIITEMP_PROTOCOL_NEW;
|
|
|
devparam[4].baudrate = 1200;
|
|
|
devparam[4].databit = 8;
|
|
|
devparam[4].stopbit = 1;
|
|
|
devparam[4].parity = 0;
|
|
|
devparam[4].IsNoInsta = 0;
|
|
|
//devparam[4].PowerPort = 17;
|
|
|
devparam[4].devaddr = 4;
|
|
|
|
|
|
devparam[5].ProtocolIdx = RALLY_PROTOCOL_NEW;
|
|
|
devparam[5].baudrate = 9600;
|
|
|
devparam[5].databit = 8;
|
|
|
devparam[5].stopbit = 1;
|
|
|
devparam[5].parity = 0;
|
|
|
devparam[5].IsNoInsta = 1;
|
|
|
//devparam[5].PowerPort = 6;
|
|
|
devparam[5].devaddr = 11;
|
|
|
|
|
|
devparam[6].ProtocolIdx = RALLY_PROTOCOL_NEW;
|
|
|
devparam[6].baudrate = 9600;
|
|
|
devparam[6].databit = 8;
|
|
|
devparam[6].stopbit = 1;
|
|
|
devparam[6].parity = 0;
|
|
|
devparam[6].IsNoInsta = 1;
|
|
|
//devparam[6].PowerPort = 6;
|
|
|
devparam[6].devaddr = 12;
|
|
|
|
|
|
devparam[7].ProtocolIdx = RALLY_PROTOCOL_NEW;
|
|
|
devparam[7].baudrate = 9600;
|
|
|
devparam[7].databit = 8;
|
|
|
devparam[7].stopbit = 1;
|
|
|
devparam[7].parity = 0;
|
|
|
devparam[7].IsNoInsta = 1;
|
|
|
//devparam[7].PowerPort = 6;
|
|
|
devparam[7].devaddr = 10;
|
|
|
|
|
|
devparam[8].ProtocolIdx = PELCO_P_PROTOCOL;
|
|
|
devparam[8].baudrate = 9600;
|
|
|
devparam[8].databit = 8;
|
|
|
devparam[8].stopbit = 1;
|
|
|
devparam[8].parity = 0;
|
|
|
devparam[8].IsNoInsta = 0;
|
|
|
//devparam[8].PowerPort = 10;
|
|
|
devparam[8].CameraChannel = 2;
|
|
|
devparam[8].devaddr = 0;
|
|
|
|
|
|
devparam[9].ProtocolIdx = WDIITEMP_PROTOCOL_NEW;
|
|
|
devparam[9].baudrate = 9600;
|
|
|
devparam[9].databit = 8;
|
|
|
devparam[9].stopbit = 1;
|
|
|
devparam[9].parity = 0;
|
|
|
devparam[9].IsNoInsta = 1;
|
|
|
//devparam[9].PowerPort = 17;
|
|
|
devparam[9].devaddr = 47;
|
|
|
|
|
|
devparam[10].ProtocolIdx = LCURRENT_PROTOCOL;
|
|
|
devparam[10].baudrate = 9600;
|
|
|
devparam[10].databit = 8;
|
|
|
devparam[10].stopbit = 1;
|
|
|
devparam[10].parity = 0;
|
|
|
devparam[10].IsNoInsta = 1;
|
|
|
//devparam[10].PowerPort = 5;
|
|
|
devparam[10].devaddr = 7;
|
|
|
|
|
|
devparam[11].ProtocolIdx = LCURRENT_PROTOCOL;
|
|
|
devparam[11].baudrate = 9600;
|
|
|
devparam[11].databit = 8;
|
|
|
devparam[11].stopbit = 1;
|
|
|
devparam[11].parity = 0;
|
|
|
devparam[11].IsNoInsta = 1;
|
|
|
//devparam[11].PowerPort = 6;
|
|
|
devparam[11].devaddr = 6;
|
|
|
|
|
|
devparam[12].ProtocolIdx = LCURRENT_PROTOCOL;
|
|
|
devparam[12].baudrate = 9600;
|
|
|
devparam[12].databit = 8;
|
|
|
devparam[12].stopbit = 1;
|
|
|
devparam[12].parity = 0;
|
|
|
devparam[12].IsNoInsta = 1;
|
|
|
//devparam[12].PowerPort = 8;
|
|
|
devparam[12].devaddr = 5;
|
|
|
#endif
|
|
|
|
|
|
devparam[13].ProtocolIdx = SLANT_PROTOCOL;
|
|
|
devparam[13].baudrate = B9600;
|
|
|
devparam[13].databit = 8;
|
|
|
memset(devparam[13].stopbit, 0, sizeof(devparam[13].stopbit));
|
|
|
sprintf(devparam[13].stopbit, "1");
|
|
|
devparam[13].parity = 0;
|
|
|
//devparam[13].PowerPort = 4;
|
|
|
devparam[13].IsNoInsta = 1;
|
|
|
devparam[13].devaddr = 2;
|
|
|
#if 0
|
|
|
devparam[14].ProtocolIdx = SLANT_PROTOCOL;
|
|
|
devparam[14].baudrate = 1200;
|
|
|
devparam[14].databit = 8;
|
|
|
devparam[14].stopbit = 1;
|
|
|
devparam[14].parity = 0;
|
|
|
devparam[14].IsNoInsta = 1;
|
|
|
//devparam[14].PowerPort = 2;
|
|
|
devparam[14].devaddr = 3;
|
|
|
#endif
|
|
|
#if 0
|
|
|
devparam[15].ProtocolIdx = LEIRALLY_PROTOCOL;
|
|
|
//#endif
|
|
|
devparam[15].ProtocolIdx = WIND_PROTOCOL;
|
|
|
devparam[15].baudrate = 9600;
|
|
|
devparam[15].databit = 8;
|
|
|
devparam[15].stopbit = 1;
|
|
|
devparam[15].parity = 0;
|
|
|
devparam[15].IsNoInsta = 1;
|
|
|
devparam[15].PowerPort = 14;
|
|
|
devparam[15].devaddr = 1;
|
|
|
|
|
|
// 6 气象
|
|
|
// 空气温度
|
|
|
weatherpntmsg[0].AiParam.fFactor = 1.0;
|
|
|
weatherpntmsg[0].AiParam.EuValueDelta = 50;
|
|
|
// 相对湿度
|
|
|
weatherpntmsg[1].AiParam.fFactor = 1.0;
|
|
|
weatherpntmsg[1].AiParam.EuValueDelta = 0;
|
|
|
// 风速
|
|
|
weatherpntmsg[2].AiParam.fFactor = 0.01;
|
|
|
weatherpntmsg[2].AiParam.EuValueDelta = 0;
|
|
|
// 风向
|
|
|
weatherpntmsg[3].AiParam.fFactor = 0.001;
|
|
|
weatherpntmsg[3].AiParam.EuValueDelta = 0;
|
|
|
// 降水强度
|
|
|
weatherpntmsg[4].AiParam.fFactor = 60;
|
|
|
weatherpntmsg[4].AiParam.EuValueDelta = 0;
|
|
|
// 相对空气压力
|
|
|
weatherpntmsg[5].AiParam.fFactor = 1.0;
|
|
|
weatherpntmsg[5].AiParam.EuValueDelta = 0;
|
|
|
// 备用
|
|
|
weatherpntmsg[6].AiParam.fFactor = 1.0;
|
|
|
weatherpntmsg[6].AiParam.EuValueDelta = 0;
|
|
|
// 备用
|
|
|
weatherpntmsg[7].AiParam.fFactor = 1.0;
|
|
|
weatherpntmsg[7].AiParam.EuValueDelta = 0;
|
|
|
|
|
|
smokepntmsg[0].AiParam.EuValueDelta = 0;
|
|
|
smokepntmsg[0].AiParam.fFactor = 0.1;
|
|
|
rizhaopntmsg[0].AiParam.fFactor = 1.0;
|
|
|
rizhaopntmsg[0].AiParam.EuValueDelta = 0;
|
|
|
rizhaopntmsg[1].AiParam.fFactor = 2.5;
|
|
|
rizhaopntmsg[1].AiParam.EuValueDelta = 0;
|
|
|
|
|
|
slantpntmsg[0][0].AiParam.fFactor = 100.0;
|
|
|
slantpntmsg[0][0].AiParam.EuValueDelta = 0;
|
|
|
slantpntmsg[0][1].AiParam.fFactor = 100.0;
|
|
|
slantpntmsg[0][1].AiParam.EuValueDelta = 0;
|
|
|
slantpntmsg[1][0].AiParam.fFactor = 100.0;
|
|
|
slantpntmsg[1][0].AiParam.EuValueDelta = 0;
|
|
|
slantpntmsg[1][1].AiParam.fFactor = 100.0;
|
|
|
slantpntmsg[1][1].AiParam.EuValueDelta = 0;
|
|
|
|
|
|
for(i=0; i<6; i++)
|
|
|
for(j=0; j<RALLY_DATA_NUM; j++)
|
|
|
{
|
|
|
rallypntmsg[i][j].AiParam.fFactor = 1.0;
|
|
|
rallypntmsg[i][j].AiParam.EuValueDelta = 0;
|
|
|
}
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
// 初始化所有串口及所接传感器的配置
|
|
|
void Gm_InitSerialComm()
|
|
|
{
|
|
|
int i;
|
|
|
char szbuf[128];
|
|
|
|
|
|
Gm_InitSerialComm_Test();
|
|
|
// srdt 配置
|
|
|
//srdt.sampling = 0;
|
|
|
//srdt.PtzCmdType = Cmd_Cancel; // 云台指令类型
|
|
|
//srdt.SendStopPtzCmdTimeCnt=-1; // 发送云台停止指令计数
|
|
|
//srdt.uRunMode = 0;
|
|
|
//srdt.CommMod = 0;
|
|
|
|
|
|
// 查找装置使用的串口序号
|
|
|
//FindDevUseSerialCommNo();
|
|
|
|
|
|
#if 0
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
srdt.ms_dev[i].uOpenPowerFlag = CLOSEPOWER;
|
|
|
#endif
|
|
|
|
|
|
#if 1
|
|
|
//******************** 端口基本信息 ************************
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
switch(devparam[i].ProtocolIdx)
|
|
|
{
|
|
|
case 0:
|
|
|
sprintf(szbuf, "传感器%d没有接!", i+1);
|
|
|
break;
|
|
|
case WEATHER_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是气象传感器!", i+1);
|
|
|
break;
|
|
|
case SERIALCAMERA_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是串口摄像机!", i+1);
|
|
|
break;
|
|
|
case PELCO_P_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是PELCO_P摄像机!", i+1);
|
|
|
break;
|
|
|
case SLANT_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是直川倾角!", i+1);
|
|
|
break;
|
|
|
case WIND_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是风速风向传感器", i+1);
|
|
|
break;
|
|
|
case RALLY_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是拉力!", i+1);
|
|
|
break;
|
|
|
case PELCO_D_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是PELCO_D摄像机!", i+1);
|
|
|
break;
|
|
|
case RESERVE5_PROTOCOL:
|
|
|
sprintf(szbuf, "传感器%d接的是加密芯片", i+1);
|
|
|
break;
|
|
|
default:
|
|
|
sprintf(szbuf, "传感器%d没有接!", i+1);
|
|
|
break;
|
|
|
}
|
|
|
LOGI("%s", szbuf);
|
|
|
|
|
|
sprintf(szbuf, "地址%d!；", devparam[i].devaddr);
|
|
|
LOGI("%s", szbuf);
|
|
|
if(0 == devparam[i].IsNoInsta)
|
|
|
sprintf(szbuf, "没有启用!；");
|
|
|
else
|
|
|
sprintf(szbuf, "已启用!；");
|
|
|
LOGI("%s", szbuf);
|
|
|
}
|
|
|
#endif
|
|
|
#if 0
|
|
|
//u_char UseSerialidx; // 使用的串口序号
|
|
|
|
|
|
// 数据参数配置
|
|
|
sprintf(szbuf, "气象数据参数:");
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
//weatherpntmsg[0].AiParam.EuValueDelta = 500;
|
|
|
sprintf(szbuf, "温度系数%4.2f, 偏移%4.2f", weatherpntmsg[0].AiParam.fFactor, weatherpntmsg[0].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "湿度系数%4.2f, 偏移%4.2f", weatherpntmsg[1].AiParam.fFactor, weatherpntmsg[1].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "风速系数%4.2f, 偏移%4.2f", weatherpntmsg[2].AiParam.fFactor, weatherpntmsg[2].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "风向系数%4.2f, 偏移%4.2f", weatherpntmsg[3].AiParam.fFactor, weatherpntmsg[3].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "雨量系数%4.2f, 偏移%4.2f", weatherpntmsg[4].AiParam.fFactor, weatherpntmsg[4].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "空气压力系数%4.2f, 偏移%4.2f", weatherpntmsg[5].AiParam.fFactor, weatherpntmsg[5].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
|
|
|
sprintf(szbuf, "烟雾数据参数:");
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "CO2浓度系数%4.2f, 偏移%4.2f", smokepntmsg[0].AiParam.fFactor, smokepntmsg[0].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
|
|
|
#if 0
|
|
|
sprintf(szbuf, "日照数据参数:");
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
sprintf(szbuf, "日照系数%4.2f, 偏移%4.2f", rizhaopntmsg[0].AiParam.fFactor, rizhaopntmsg[0].AiParam.EuValueDelta);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
#endif
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
// 通过传感器名称来确定使用的串口号
|
|
|
void FindDevUseSerialCommNo()
|
|
|
{
|
|
|
int i;
|
|
|
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if(0 == devparam[i].IsNoInsta)
|
|
|
continue;
|
|
|
switch(devparam[i].ProtocolIdx)
|
|
|
{
|
|
|
case WEATHER_PROTOCOL:
|
|
|
case WIND_PROTOCOL:
|
|
|
case SLANT_PROTOCOL:
|
|
|
case RALLY_PROTOCOL:
|
|
|
case SERIALCAMERA_PROTOCOL:
|
|
|
memset(devparam[i].pathname, 0, sizeof(devparam[i].pathname));
|
|
|
/* 目前还不确定具体串口分配，暂时默认使用串口1</dev/ttyS0>*/
|
|
|
sprintf(devparam[i].pathname, "/dev/ttyS0");
|
|
|
devparam[i].commid = 0;
|
|
|
break;
|
|
|
default:
|
|
|
devparam[i].IsNoInsta = 0;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void GM_StartSerialComm()
|
|
|
{
|
|
|
int i, j;
|
|
|
char szbuf[64];
|
|
|
long polltime=0;
|
|
|
|
|
|
// 测试使用初始化配置
|
|
|
Gm_InitSerialComm();
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
memset((void*)srdt.curdevidx, 0, sizeof(srdt.curdevidx));
|
|
|
//Gm_OpenSerialPower(); /* 不在这使用*/
|
|
|
FindDevUseSerialCommNo();
|
|
|
//Gm_InitSensorsIsUse();
|
|
|
// 初始化串口使用状态
|
|
|
for(i=0; i<MAX_SERIAL_PORT_NUM; i++)
|
|
|
{
|
|
|
serialport[i].m_iRevStatus = 0;
|
|
|
serialport[i].m_iRecvLen = 0;
|
|
|
serialport[i].m_iNeedRevLength = 0;
|
|
|
serialport[i].fd = -1;
|
|
|
ClearCmdAllFlag(i);
|
|
|
}
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
|
|
|
memset(szbuf, 0, sizeof(szbuf));
|
|
|
switch(devparam[i].ProtocolIdx)
|
|
|
{
|
|
|
case WEATHER_PROTOCOL: // 气象
|
|
|
sprintf(szbuf, "气象");
|
|
|
srdt.ms_dev[i].IsNeedSerial = 1;
|
|
|
break;
|
|
|
case RALLY_PROTOCOL: /* 拉力*/
|
|
|
sprintf(szbuf, "拉力");
|
|
|
srdt.ms_dev[i].IsNeedSerial = 1;
|
|
|
break;
|
|
|
case WIND_PROTOCOL: /* 风速风向*/
|
|
|
sprintf(szbuf, "风速风向");
|
|
|
srdt.ms_dev[i].IsNeedSerial = 1;
|
|
|
break;
|
|
|
case SLANT_PROTOCOL: /* 倾角*/
|
|
|
sprintf(szbuf, "倾角");
|
|
|
srdt.ms_dev[i].IsNeedSerial = 1;
|
|
|
break;
|
|
|
case PELCO_D_PROTOCOL: /* 摄像机协议*/
|
|
|
case PELCO_P_PROTOCOL: /* 摄像机协议*/
|
|
|
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
|
|
|
sprintf(szbuf, "摄像机");
|
|
|
break;
|
|
|
default:
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
sprintf(szbuf, "无效传感器");
|
|
|
break;
|
|
|
}
|
|
|
LOGI("装置%d, IsNoInsta=%d, 类型：%s", i+1, devparam[i].IsNoInsta, szbuf);
|
|
|
if(0 == devparam[i].IsNoInsta)
|
|
|
{
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
continue;
|
|
|
}
|
|
|
// 测试查询传感器电源状态
|
|
|
#if 0
|
|
|
LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
LOGE("3.3V state= %d", getInt(CMD_SET_CAM_3V3_EN_STATE));
|
|
|
LOGE("485 state=%d", getInt(CMD_SET_485_EN_STATE));
|
|
|
|
|
|
set12VEnable(true);
|
|
|
setCam3V3Enable(true);
|
|
|
setRS485Enable(true);
|
|
|
sleep(1);
|
|
|
LOGV("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
LOGV("3.3V state= %d", getInt(CMD_SET_CAM_3V3_EN_STATE));
|
|
|
LOGV("485 state=%d", getInt(CMD_SET_485_EN_STATE));
|
|
|
set12VEnable(false);
|
|
|
setCam3V3Enable(false);
|
|
|
setRS485Enable(false);
|
|
|
sleep(1);
|
|
|
LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
LOGE("3.3V state= %d", getInt(CMD_SET_CAM_3V3_EN_STATE));
|
|
|
LOGE("485 state=%d", getInt(CMD_SET_485_EN_STATE));
|
|
|
#endif
|
|
|
// 打开传感器电源
|
|
|
// 打开对应的485电源
|
|
|
// 打开串口通讯
|
|
|
if(1 == srdt.ms_dev[i].IsNeedSerial)
|
|
|
{
|
|
|
Gm_OpenSensorsPower(i);
|
|
|
Gm_OpenSerialPort(i);
|
|
|
}
|
|
|
//LOGV("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
|
|
|
}
|
|
|
|
|
|
LOGI("启动数据采样!");
|
|
|
/* 直接使用循环进行采样处理*/
|
|
|
polltime = get_msec();
|
|
|
for(;;)
|
|
|
{
|
|
|
usleep(10);
|
|
|
LOGW("polltime=%ldms", get_msec()-polltime);
|
|
|
polltime = get_msec();
|
|
|
if(GM_SerialTimer() < 0)
|
|
|
{
|
|
|
//LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
LOGV("退出采样流程！");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
#if 1
|
|
|
// 启动使用串口拍照
|
|
|
void GM_StartSerialCameraPhoto(BYTE channel, int cmdidx)
|
|
|
{
|
|
|
BYTE bCameratype=SPEED_DOME_CAMERA;
|
|
|
int i, flag=0;
|
|
|
char szbuf[64];
|
|
|
|
|
|
srdt.RephotographCnt = 0;
|
|
|
FindDevUseSerialCommNo();
|
|
|
//sprintf(szbuf, "sampling=%02X !", srdt.sampling);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
if(0 == srdt.selfflag)
|
|
|
srdt.selfflag = 1;
|
|
|
//Gm_OpenSerialPower();
|
|
|
//Gm_OpenSensorsPower();
|
|
|
//if(0x00 == srdt.sampling)
|
|
|
//{
|
|
|
// Gm_OpenSerialPort();
|
|
|
//}
|
|
|
if(0 == (srdt.sampling & 0x04))
|
|
|
{
|
|
|
srdt.sampling |= 4;
|
|
|
flag = 1;
|
|
|
}
|
|
|
if(0x01 == (srdt.sampling & 0x01))
|
|
|
flag = 0;
|
|
|
// 初始化串口使用状态
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
srdt.ms_dev[i].recvdatacnt = 0;
|
|
|
srdt.ms_dev[i].m_iRevStatus = 0;
|
|
|
srdt.ms_dev[i].m_iRecvLen = 0;
|
|
|
srdt.ms_dev[i].m_iNeedRevLength = 0;
|
|
|
//sprintf(szbuf, "装置%d, IsNoInsta=%d, 规约序号=%d", i+1, srdt.ms_dev[i].IsNoInsta, srdt.ms_dev[i].ProtocolIdx);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
if(0 == devparam[i].IsNoInsta)
|
|
|
{
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
continue;
|
|
|
}
|
|
|
switch(devparam[i].ProtocolIdx)
|
|
|
{
|
|
|
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
|
|
|
case PELCO_P_PROTOCOL: /* 摄像机协议*/
|
|
|
case PELCO_D_PROTOCOL: /* 摄像机协议*/
|
|
|
if((1>devparam[i].CameraChannel) || (devparam[i].CameraChannel >MAX_CHANNEL_NUM))
|
|
|
{
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
break;
|
|
|
}
|
|
|
if(channel == devparam[i].CameraChannel)
|
|
|
{
|
|
|
;
|
|
|
}
|
|
|
else
|
|
|
break;
|
|
|
if(SERIAL_CAMERA == bCameratype)
|
|
|
{
|
|
|
if(0 == srdt.ms_dev[i].IsNeedSerial)
|
|
|
srdt.iLastGetPhotoNo = -1;
|
|
|
else
|
|
|
srdt.iLastGetPhotoNo = srdt.ms_dev[i].SerialCmdidx;
|
|
|
srdt.ms_dev[i].IsNeedSerial = 1;
|
|
|
srdt.ms_dev[i].SerialCmdidx = cmdidx;
|
|
|
srdt.ms_dev[i].FirstCmdTimeCnt = -1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
break;
|
|
|
}
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
break;
|
|
|
default:
|
|
|
if(1 == srdt.ms_dev[i].IsNeedSerial)
|
|
|
break;
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(0x01 == flag)
|
|
|
{
|
|
|
sprintf(szbuf, "非数据采样期间，摄像机拍照启动串口定时器!");
|
|
|
LOGI("%s", szbuf);
|
|
|
//StartTimer(GM_SERIAL_START, TIMER_CNT, GM_SerialTimer);
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
int GM_SerialTimer(void)
|
|
|
{
|
|
|
int flag = -1;
|
|
|
|
|
|
GM_AllSerialComRecv();
|
|
|
GM_IsCloseSensors();
|
|
|
Gm_FindAllSensorsCommand();
|
|
|
GM_AllSerialComRecv();
|
|
|
flag = GM_CloseTimer();
|
|
|
//LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
return flag;
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
函数名称: void Gm_FindAllSensorsCommand()
|
|
|
功能说明:轮询所有串口和传感器是否需要生成下发命令
|
|
|
输入参数:
|
|
|
输出参数:
|
|
|
其它说明:
|
|
|
*********************************************************************************/
|
|
|
void Gm_FindAllSensorsCommand(void)
|
|
|
{
|
|
|
int i, j,curidx,flag;
|
|
|
|
|
|
//Gm_CheckSensorsPower(); /* 暂时不考虑电源控制*/
|
|
|
for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
|
|
|
{
|
|
|
// 发送缓冲区中命令 接收到了应答报文，紧接着进行缓冲区清理
|
|
|
SendCmdFormPollCmdBuf(j);
|
|
|
// 串口已经被占用则直接跳过
|
|
|
curidx = srdt.curdevidx[j];
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
curidx = (curidx+1)%MAX_SERIAL_DEV_NUM;
|
|
|
if(j != devparam[curidx].commid)
|
|
|
continue;
|
|
|
if(srdt.ms_dev[curidx].IsNeedSerial == 0)
|
|
|
continue;
|
|
|
if(serialport[devparam[curidx].commid].fd < 0)
|
|
|
Gm_OpenSerialPort(curidx);
|
|
|
if(serialport[devparam[curidx].commid].cmdlen > 0)
|
|
|
break;
|
|
|
//LOGE("12V state=%d", getInt(CMD_SET_12V_EN_STATE));
|
|
|
//LOGE("3.3V state= %d", getInt(CMD_SET_CAM_3V3_EN_STATE));
|
|
|
//LOGE("485 state=%d", getInt(CMD_SET_485_EN_STATE));
|
|
|
|
|
|
|
|
|
flag = -1;
|
|
|
switch(devparam[curidx].ProtocolIdx)
|
|
|
{
|
|
|
case WEATHER_PROTOCOL: /* 温湿度气压*/
|
|
|
case RALLY_PROTOCOL: /* 拉力*/
|
|
|
case WIND_PROTOCOL: /* 风速风向*/
|
|
|
case SLANT_PROTOCOL: /* 倾角*/
|
|
|
flag = FindNextShxyProtocolCommand(curidx);
|
|
|
break;
|
|
|
case RESERVE2_PROTOCOL:
|
|
|
break;
|
|
|
case RESERVE5_PROTOCOL:
|
|
|
break;
|
|
|
case PELCO_D_PROTOCOL: /* 摄像机协议*/
|
|
|
case PELCO_P_PROTOCOL: /* 摄像机协议*/
|
|
|
flag = FindNextCameraPhotoCommand(curidx);
|
|
|
break;
|
|
|
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
|
|
|
break;
|
|
|
}
|
|
|
if(flag == -1)
|
|
|
continue;
|
|
|
srdt.curdevidx[j] = curidx;
|
|
|
break;
|
|
|
}
|
|
|
// 发送缓冲区中命令 生成了命令之后紧接着进行命令发送
|
|
|
SendCmdFormPollCmdBuf(j);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
函数名称: void GM_IsCloseSensors()
|
|
|
功能说明:检查所有传感器是否采集完毕，采集完毕的关闭传感器电源
|
|
|
输入参数:
|
|
|
输出参数:
|
|
|
其它说明:
|
|
|
*********************************************************************************/
|
|
|
void GM_IsCloseSensors(void)
|
|
|
{
|
|
|
int i;
|
|
|
char buf[256];
|
|
|
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if(srdt.ms_dev[i].IsNeedSerial == 0)
|
|
|
continue;
|
|
|
switch(devparam[i].ProtocolIdx)
|
|
|
{
|
|
|
case WEATHER_PROTOCOL: /* 气象*/
|
|
|
case RALLY_PROTOCOL: /* 拉力*/
|
|
|
case WIND_PROTOCOL: /* 风速风向*/
|
|
|
case SLANT_PROTOCOL: /* 倾角*/
|
|
|
if((get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt > 50*1000) ||(get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt < 0))
|
|
|
{
|
|
|
srdt.ms_dev[i].FirstCmdTimeCnt = get_msec();
|
|
|
break;
|
|
|
}
|
|
|
if(get_msec()- srdt.ms_dev[i].FirstCmdTimeCnt > 15*1000)
|
|
|
{
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
// 关闭传感器电源
|
|
|
LOGI("读取装置%d数据%0.3f秒，关闭装置%d电源!", i+1, (get_msec()-srdt.ms_dev[i].FirstCmdTimeCnt)/1000.0,i+1);
|
|
|
//Gm_CtrlCloseSensorsPower(i);
|
|
|
}
|
|
|
break;
|
|
|
case PELCO_D_PROTOCOL: /* 摄像机类型*/
|
|
|
case PELCO_P_PROTOCOL: /* 摄像机类型*/
|
|
|
case SERIALCAMERA_PROTOCOL: /* 串口摄像机协议*/
|
|
|
if(-1 == srdt.ms_dev[i].SerialCmdidx)
|
|
|
{
|
|
|
if(srdt.ms_dev[i].FirstCmdTimeCnt > 6*1000/TIMER_CNT)
|
|
|
{
|
|
|
srdt.ms_dev[i].IsNeedSerial = 0;
|
|
|
srdt.sampling &= 0xFB;
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
LOGI("通道%d摄像机使用完毕!可以关闭摄像机电源!", devparam[i].CameraChannel);
|
|
|
//netportparam.SerialCameraPowerCtrl[srdt.ms_dev[i].CameraChannel-1] = 0;
|
|
|
//if(0 == netportparam.InitTimeFlag)
|
|
|
// Gm_CtrlCloseSensorsPower(i);
|
|
|
}
|
|
|
}
|
|
|
srdt.ms_dev[i].FirstCmdTimeCnt++;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
函数名称: void GM_AllSerialComRecv()
|
|
|
功能说明:检查所有串口是否有数据接收，有则启动接收
|
|
|
输入参数:
|
|
|
输出参数:
|
|
|
其它说明:
|
|
|
*********************************************************************************/
|
|
|
void GM_AllSerialComRecv(void)
|
|
|
{
|
|
|
int i, j, recvlen;
|
|
|
u_char recvbuf[RECVDATA_MAXLENTH];
|
|
|
char buf[256];
|
|
|
|
|
|
for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
|
|
|
{
|
|
|
memset(recvbuf, 0, sizeof(recvbuf));
|
|
|
if(serialport[j].fd < 0)
|
|
|
continue;
|
|
|
for(;;)
|
|
|
{
|
|
|
recvlen = read(serialport[j].fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
|
|
|
|
|
|
if(recvlen < 1)
|
|
|
break;
|
|
|
sprintf(buf, "收到串口%d, %d字节数据:", j+1, recvlen);
|
|
|
BytestreamLOG(buf, recvbuf, recvlen, 'I');
|
|
|
|
|
|
SerialDataProcess(srdt.curdevidx[j], recvbuf, recvlen);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
函数名称: int GM_CloseTimer()
|
|
|
功能说明:
|
|
|
输入参数:
|
|
|
输出参数:
|
|
|
其它说明:
|
|
|
*********************************************************************************/
|
|
|
int GM_CloseTimer(void)
|
|
|
{
|
|
|
int i, j, iretime;
|
|
|
char buf[256];
|
|
|
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if((srdt.ms_dev[i].IsNeedSerial == 1)
|
|
|
&& ((0<devparam[i].ProtocolIdx)&&(INVALID_PROTOCOL >devparam[i].ProtocolIdx)))
|
|
|
break;
|
|
|
}
|
|
|
if(i < MAX_SERIAL_DEV_NUM)
|
|
|
{
|
|
|
return 1; // 寻找
|
|
|
}
|
|
|
else // 关闭所有串口及电源
|
|
|
{
|
|
|
#if 0
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if((srdt.ms_dev[i].IsNeedSerial == 1) && (7 == devparam[i].ProtocolIdx))
|
|
|
break;
|
|
|
}
|
|
|
if(i<MAX_SERIAL_DEV_NUM)
|
|
|
{
|
|
|
if(-1 == srdt.tempsamplingstartime)
|
|
|
{
|
|
|
;
|
|
|
}
|
|
|
for(j=0; j<MAX_SERIAL_DEV_NUM; j++)
|
|
|
{
|
|
|
if(srdt.ms_dev[j].IsNeedSerial == 0)
|
|
|
continue;
|
|
|
switch(devparam[j].ProtocolIdx)
|
|
|
{
|
|
|
case 7: // 测温
|
|
|
Gm_SetSerialPortParam(srdt.ms_dev[j].UseSerialidx);
|
|
|
iretime = (int)get_msec()/1000-srdt.ms_dev[j].FirstCmdTimeCnt;
|
|
|
//if(iretime > 35)
|
|
|
//{
|
|
|
// if((devparam[j].PowerPort) == 0)
|
|
|
{
|
|
|
sprintf(buf, "打开无线模块电源!当前时间%d秒，起始时间%d秒",
|
|
|
(int)time(NULL), srdt.ms_dev[j].FirstCmdTimeCnt);
|
|
|
LOGI("%s", buf);
|
|
|
}
|
|
|
//}
|
|
|
|
|
|
#if 1
|
|
|
//samtime = (int)(Gm_GetSamplingTimeSec()-10);
|
|
|
//if(iretime > samtime)
|
|
|
if(iretime > 155)
|
|
|
{
|
|
|
srdt.ms_dev[j].IsNeedSerial = 0;
|
|
|
//srdt.tempsamplingstartime = -1;
|
|
|
srdt.tempsamplingsucctime = -1;
|
|
|
// 关闭传感器电源
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
sprintf(buf, "关闭无线模块电源!当前时间%d秒，起始时间%d秒，采样间隔时间10",
|
|
|
(int)time(NULL), srdt.ms_dev[j].FirstCmdTimeCnt/*, samtime*/);
|
|
|
LOGI("%s", buf);
|
|
|
//Gm_CtrlCloseSensorsPower(j);
|
|
|
}
|
|
|
#endif
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
//StartTimer(GM_SERIAL_START, TIMER_CNT, GM_SerialTimer);
|
|
|
}
|
|
|
else
|
|
|
|
|
|
{
|
|
|
#endif
|
|
|
#if 0
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if((srdt.ms_dev[i].IsNeedSerial == 1) && (RESERVE5_PROTOCOL == devparam[i].ProtocolIdx))
|
|
|
break;
|
|
|
}
|
|
|
if(i<MAX_SERIAL_DEV_NUM)
|
|
|
return;
|
|
|
else
|
|
|
{
|
|
|
#endif
|
|
|
Gm_CloseSerialPort();
|
|
|
for(j=0; j< MAX_SERIAL_DEV_NUM; j++)
|
|
|
Gm_CloseSensorsPower(j);
|
|
|
for(j=0; j<MAX_SERIAL_PORT_NUM; j++)
|
|
|
ClearCmdFormPollCmdBuf(j);
|
|
|
sprintf(buf, "关闭串口定时器!");
|
|
|
LOGI("%s", buf);
|
|
|
return -1;
|
|
|
#if 0
|
|
|
//g_usleep &= 0xFE;
|
|
|
//if(0 == g_usleep)
|
|
|
{
|
|
|
sprintf(buf, "采集数据结束模块休眠!");
|
|
|
LOGI("%s", buf);
|
|
|
//if(0 == srdt.uRunMode)
|
|
|
// L1SM_SleepEnable(l1handle);
|
|
|
}
|
|
|
//sprintf(buf, "usleep=%d", g_usleep);
|
|
|
//DebugStringPrintf(buf, strlen(buf), 1);
|
|
|
srdt.sampling &= 0xFA;
|
|
|
|
|
|
if(1 == srdt.uRunMode)
|
|
|
{
|
|
|
GM_StartSerialComm();
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
srdt.ms_dev[i].FirstCmdTimeCnt = 4*1000/TIMER_CNT;
|
|
|
}
|
|
|
}
|
|
|
srdt.tempsamplingstartime = -1;
|
|
|
}
|
|
|
#endif
|
|
|
#if 0
|
|
|
if(0 == srdt.selfflag)
|
|
|
;
|
|
|
else
|
|
|
;//Gm_CloseSerialPower();
|
|
|
//srdt.clcyesampling = 0;
|
|
|
//Gm_CloseAllSensorsPower();
|
|
|
|
|
|
//srdt.selfflag = 0;
|
|
|
//}
|
|
|
#endif
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SerialDataProcess(int devidx, u_char *buf, int len)
|
|
|
{
|
|
|
switch(devparam[devidx].ProtocolIdx)
|
|
|
{
|
|
|
|
|
|
case WEATHER_PROTOCOL: /* 气象*/
|
|
|
case RALLY_PROTOCOL: /* 拉力*/
|
|
|
case WIND_PROTOCOL: /* 风速风向*/
|
|
|
case SLANT_PROTOCOL: /* 倾角*/
|
|
|
ShxyProtocolRecvData(devidx, buf, len);
|
|
|
break;
|
|
|
case RESERVE2_PROTOCOL: /* 意科电池电量读取协议*/
|
|
|
break;
|
|
|
case RESERVE5_PROTOCOL: /* 网络安全加密协议*/
|
|
|
//EncryptRecvData(devidx, buf, len);
|
|
|
break;
|
|
|
case SERIALCAMERA_PROTOCOL: /* 青青子木串口摄像机协议*/
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
CameraPhoto 端口数据处理
|
|
|
**********************************************************************************/
|
|
|
void CameraPhotoPortDataProcess( int port)
|
|
|
{
|
|
|
RTUMSG rtumsg;
|
|
|
SERIAL_DEV_DEF *pPortParam;
|
|
|
SIO_PARAM_SERIAL_DEF *serialport;
|
|
|
int img_file_size, packetnum, iNo, packsize, i=0, presetno, iphototime;
|
|
|
char szbuf[128];
|
|
|
WORD uDevAddr;
|
|
|
BYTE cmdidx, recvend;
|
|
|
|
|
|
pPortParam = &srdt.ms_dev[port];
|
|
|
serialport = &serialport[pPortParam->UseSerialidx];
|
|
|
|
|
|
memset((void*)rtumsg.MsgData, 0, sizeof(rtumsg.MsgData));
|
|
|
memcpy((void*)rtumsg.MsgData, (void*)serialport->m_au8RecvBuf, pPortParam->m_iRecvLen);
|
|
|
rtumsg.MsgLen = pPortParam->m_iRecvLen;
|
|
|
rtumsg.PortIdx = port;
|
|
|
cmdidx = serialport->m_au8RecvBuf[5];
|
|
|
uDevAddr = serialport->m_au8RecvBuf[4];
|
|
|
|
|
|
//sprintf(szbuf, "摄像机地址%d,命令%02X!", uDevAddr, cmdidx);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
if(uDevAddr != devparam[port].devaddr)
|
|
|
return;
|
|
|
|
|
|
switch(cmdidx)
|
|
|
{
|
|
|
case 0x10: /* 拍照应答*/
|
|
|
if(0xFF == rtumsg.MsgData[6])
|
|
|
{
|
|
|
srdt.RephotographCnt++;
|
|
|
if(srdt.RephotographCnt > 2)
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "因摄像机重拍%d次均未成功!结束拍照!",srdt.RephotographCnt);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
i = 6;
|
|
|
iphototime = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
|
|
|
srdt.photographtime = iphototime;
|
|
|
i=10;
|
|
|
img_file_size = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
|
|
|
packetnum = rtumsg.MsgData[i+5]+(rtumsg.MsgData[i+4]<<8);
|
|
|
srdt.imagepacketnum = packetnum;
|
|
|
srdt.historyimagenum[devparam[port].CameraChannel-1] = rtumsg.MsgData[i+7]+(rtumsg.MsgData[i+6]<<8);
|
|
|
sprintf(szbuf, "有%d张历史图片!",srdt.historyimagenum[devparam[port].CameraChannel-1]);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
//presetno = (int)GetPhotoPresetNo(pPortParam->CameraChannel);
|
|
|
presetno = (int)rtumsg.MsgData[i+8];
|
|
|
//if(0 == netportparam.InitTimeFlag)
|
|
|
{
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
pPortParam->SerialCmdidx = 10001;
|
|
|
/* 保存图片*/
|
|
|
//break
|
|
|
}
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
pPortParam->SerialCmdidx = 1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
break;
|
|
|
case 0x11: /* 图片数据包*/
|
|
|
// if(0 == netportparam.InitTimeFlag)
|
|
|
{
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
pPortParam->SerialCmdidx = 10001;
|
|
|
/* 保存图片*/
|
|
|
//break;
|
|
|
}
|
|
|
i = 6;
|
|
|
iNo = rtumsg.MsgData[i+1]+rtumsg.MsgData[i]*256;
|
|
|
packsize = rtumsg.MsgData[i+3]+rtumsg.MsgData[i+2]*256;
|
|
|
sprintf(szbuf, "收到第%d(总%d包)", iNo, srdt.imagepacketnum);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
pPortParam->FirstCmdTimeCnt = 0;
|
|
|
if((iNo == pPortParam->SerialCmdidx) && (0xFF > rtumsg.MsgData[i+2]))
|
|
|
{
|
|
|
if(1 == recvend)
|
|
|
pPortParam->SerialCmdidx = 10002;/* 图片读取完成*/
|
|
|
else if(0xFF == recvend)
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if((iNo > srdt.imagepacketnum) || (0 >= srdt.imagepacketnum))
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
}
|
|
|
else
|
|
|
pPortParam->SerialCmdidx = iNo+1;
|
|
|
}
|
|
|
srdt.errorPhotoNoCnt = 0;
|
|
|
break;
|
|
|
}
|
|
|
srdt.errorPhotoNoCnt++;
|
|
|
sprintf(szbuf, "问询第%d包图片摄像机应答第%d包,连续错误%d次!",
|
|
|
pPortParam->SerialCmdidx, iNo, srdt.errorPhotoNoCnt);
|
|
|
if(srdt.errorPhotoNoCnt > 5)
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = 0;
|
|
|
srdt.RephotographCnt++;
|
|
|
if(srdt.RephotographCnt > 2)
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "因摄像机重拍%d次均未成功!结束拍照!",srdt.RephotographCnt);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case 0x03:
|
|
|
sprintf(szbuf, "设置波特率%d成功", devparam[port].baudrate);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
//pPortParam->Baud = serialport->Baud;
|
|
|
pPortParam->SerialCmdidx = srdt.iLastGetPhotoNo;
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
pPortParam->FirstCmdTimeCnt = 0;
|
|
|
break;
|
|
|
case 0x15:
|
|
|
if(0xFF == rtumsg.MsgData[6])
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "没有历史图片!结束读取图片!");
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
}
|
|
|
i = 6;
|
|
|
iphototime = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
|
|
|
srdt.photographtime = iphototime;
|
|
|
i=10;
|
|
|
img_file_size = rtumsg.MsgData[i+3]+ (rtumsg.MsgData[i+2]<<8)+(rtumsg.MsgData[i+1]<<16)+(rtumsg.MsgData[i]<<24);
|
|
|
packetnum = rtumsg.MsgData[i+5]+(rtumsg.MsgData[i+4]<<8);
|
|
|
srdt.imagepacketnum = packetnum;
|
|
|
srdt.historyimagenum[devparam[port].CameraChannel-1] = rtumsg.MsgData[i+7]+(rtumsg.MsgData[i+6]<<8);
|
|
|
//presetno = netportparam.CurPresetno[pPortParam->CameraChannel-1];
|
|
|
presetno = rtumsg.MsgData[i+8];
|
|
|
sprintf(szbuf, "读取历史图片,还有%d张历史图片!",srdt.historyimagenum[devparam[port].CameraChannel-1]);
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
//if(0 == netportparam.InitTimeFlag)
|
|
|
{
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
//netportparam.PhotosFlag = FALSE;
|
|
|
break;
|
|
|
}
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
pPortParam->SerialCmdidx = 1;
|
|
|
srdt.sendphotocmdcnt = 0;
|
|
|
break;
|
|
|
case 0x16:
|
|
|
if(0xFF == rtumsg.MsgData[10])
|
|
|
{
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "图片保存失败!");
|
|
|
//DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
}
|
|
|
if(0 == rtumsg.MsgData[10])
|
|
|
{
|
|
|
if(0 == srdt.historyimagenum[devparam[port].CameraChannel-1])
|
|
|
{
|
|
|
//netportparam.SerialCameraPowerCtrl[devparam[port].CameraChannel-1] = 0;
|
|
|
srdt.sampling &= 0xFB;
|
|
|
|
|
|
}
|
|
|
else
|
|
|
pPortParam->FirstCmdTimeCnt = -3*60*1000/TIMER_CNT;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
srdt.sampling &= 0xFB;
|
|
|
//netportparam.SerialCameraPowerCtrl[pPortParam->CameraChannel-1] = 0;
|
|
|
}
|
|
|
pPortParam->SerialCmdidx = -1;
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
//if(0 == netportparam.InitTimeFlag)
|
|
|
break;
|
|
|
default:
|
|
|
serialport->RevCmdFlag = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
long lsendtime=0;
|
|
|
/*********************************************************************************
|
|
|
发送命令
|
|
|
**********************************************************************************/
|
|
|
void SendCmdFormPollCmdBuf( int port )
|
|
|
{
|
|
|
char buf[64];
|
|
|
int len, idelay=0, ret;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
//int recvlen;
|
|
|
//u_char recvbuf[300];
|
|
|
|
|
|
pPortParam = &serialport[port];
|
|
|
if(pPortParam->ForceWaitFlag && pPortParam->ForceWaitCnt)
|
|
|
{
|
|
|
pPortParam->ForceWaitCnt--;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if(pPortParam->SendCmdFlag && (pPortParam->RevCmdFlag == 0))
|
|
|
{
|
|
|
pPortParam->RetryTimeCnt++;
|
|
|
//if(srdt.sendphotocmdcnt > 0)
|
|
|
// idelay = 10*1000/TIMER_CNT;
|
|
|
//LOGV("polltime:%ldms", get_msec()-srdt.ms_dev[0].FirstCmdTimeCnt);
|
|
|
if(pPortParam->RetryTimeCnt < (pPortParam->RetryTime+idelay))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
pPortParam->RetryTimeCnt = 0;
|
|
|
pPortParam->RetryCnt++;
|
|
|
if(pPortParam->RetryCnt > pPortParam->Retry)
|
|
|
{
|
|
|
ClearCmdFormPollCmdBuf(port);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pPortParam->SendCmdFlag = 0;
|
|
|
pPortParam->RevCmdFlag = 0;
|
|
|
pPortParam->ReSendCmdFlag = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if ( pPortParam->SendCmdFlag && pPortParam->RevCmdFlag )
|
|
|
{
|
|
|
// 清除当前命令
|
|
|
ClearCmdFormPollCmdBuf(port);
|
|
|
}
|
|
|
|
|
|
if(pPortParam->WaitTime)
|
|
|
{
|
|
|
pPortParam->WaitTimeCnt++;
|
|
|
if(pPortParam->WaitTimeCnt < pPortParam->WaitTime)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
pPortParam->WaitTimeCnt = 0;
|
|
|
|
|
|
if ( pPortParam->ReSendCmdFlag )
|
|
|
len = pPortParam->cmdlen;
|
|
|
else
|
|
|
{
|
|
|
len = pPortParam->cmdlen;
|
|
|
pPortParam->RetryCnt = 0;
|
|
|
}
|
|
|
if ( len == 0 )
|
|
|
return;
|
|
|
|
|
|
serialport[devparam[srdt.curdevidx[port]].commid].m_iRecvLen = 0; // 当发送一条新指令时，清除接收状态
|
|
|
serialport[devparam[srdt.curdevidx[port]].commid].m_iRevStatus = 0;
|
|
|
ret = Gm_SetSerialPortParam(port);
|
|
|
if(ret < 0)
|
|
|
return;
|
|
|
len = GM_SerialComSend(&pPortParam->PollCmd[2], pPortParam->cmdlen-2, port);
|
|
|
if(len < 1)
|
|
|
{
|
|
|
LOGE("串口%d, 发送命令失败!", port+1);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
|
|
|
sprintf(buf, "发送串口%d 装置%d命令:", port+1, srdt.curdevidx[port]+1);
|
|
|
BytestreamLOG(buf, &pPortParam->PollCmd[2], len, 'D');
|
|
|
LOGW("sendtimeconst= %ld", get_msec()-lsendtime);
|
|
|
lsendtime = get_msec();
|
|
|
}
|
|
|
pPortParam->SendCmdFlag = 1;
|
|
|
pPortParam->ReSendCmdFlag = 0;
|
|
|
pPortParam->RevCmdFlag = 0;
|
|
|
pPortParam->RetryTimeCnt = 0;
|
|
|
|
|
|
pPortParam->ForceWaitCnt = pPortParam->PollCmd[0]*256+pPortParam->PollCmd[1]+TIMER_CNT-1;
|
|
|
pPortParam->ForceWaitCnt /= TIMER_CNT;
|
|
|
if(pPortParam->ForceWaitCnt)
|
|
|
{
|
|
|
pPortParam->ForceWaitFlag = 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ClearCmdAllFlag(int commid)
|
|
|
{
|
|
|
if((commid < 0) || (commid >= MAX_SERIAL_PORT_NUM))
|
|
|
return;
|
|
|
|
|
|
serialport[commid].RetryCnt = 0;
|
|
|
serialport[commid].RetryTimeCnt = 0;
|
|
|
serialport[commid].WaitTimeCnt = 0;
|
|
|
serialport[commid].ForceWaitFlag = 0;
|
|
|
serialport[commid].ForceWaitCnt = 0;
|
|
|
serialport[commid].SendCmdFlag = 0;
|
|
|
serialport[commid].RevCmdFlag = 0;
|
|
|
serialport[commid].ReSendCmdFlag = 0;
|
|
|
}
|
|
|
|
|
|
void ClearCmdFormPollCmdBuf(int port)
|
|
|
{
|
|
|
//int len, idx;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
|
|
|
if((port < 0) || (port >= MAX_SERIAL_PORT_NUM))
|
|
|
return;
|
|
|
pPortParam = &serialport[port];
|
|
|
|
|
|
pPortParam->cmdlen = 0;
|
|
|
memset(pPortParam->PollCmd, 0, sizeof(pPortParam->PollCmd));
|
|
|
srdt.serialstatus[port] = 0;
|
|
|
// 清除指令下发标识
|
|
|
ClearCmdAllFlag(port);
|
|
|
}
|
|
|
|
|
|
// 下发串口拍照指令控制
|
|
|
int FindNextCameraPhotoCommand(int devidx)
|
|
|
{
|
|
|
int imagesize=3, cmdno;
|
|
|
BYTE channel, imagequality=50;
|
|
|
WORD packetsize;
|
|
|
BYTE cmdidx=0x10;
|
|
|
char szbuf[128];
|
|
|
|
|
|
//如果命令缓冲区仍有命令，则退出本函数
|
|
|
if((srdt.ms_dev[devidx].UseSerialidx < 1) || (srdt.ms_dev[devidx].UseSerialidx >= MAX_SERIAL_PORT_NUM))
|
|
|
return -1;
|
|
|
if(-1 == srdt.ms_dev[devidx].SerialCmdidx)/* 下发拍照指令*/
|
|
|
return -1;
|
|
|
cmdno = srdt.ms_dev[devidx].SerialCmdidx;
|
|
|
if(0 == cmdno)/* 下发拍照指令*/
|
|
|
{
|
|
|
if(srdt.ms_dev[devidx].FirstCmdTimeCnt < 4*1000/TIMER_CNT)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 35*1000/TIMER_CNT)
|
|
|
{
|
|
|
srdt.ms_dev[devidx].SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "串口摄像机未接或故障!结束拍照!");
|
|
|
LOGI("%s", szbuf);
|
|
|
return -1;
|
|
|
}
|
|
|
channel = devparam[devidx].CameraChannel;
|
|
|
if((1>channel) || (channel >MAX_CHANNEL_NUM))
|
|
|
{
|
|
|
/* 通道号错误退出拍照流程*/;
|
|
|
srdt.ms_dev[devidx].SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "装置配置中，通道号配置错误!结束拍照!");
|
|
|
LOGI("%s", szbuf);
|
|
|
}
|
|
|
packetsize = (WORD)MAX_PHOTO_FRAME_LEN;
|
|
|
srdt.sendphotocmdcnt++;
|
|
|
srdt.imagepacketnum = 0;
|
|
|
srdt.errorPhotoNoCnt = 0;
|
|
|
cmdidx = 0x10;
|
|
|
srdt.sendphototime=(int)time(NULL);
|
|
|
}
|
|
|
else if(10000 == cmdno)/* 下发设置串口波特率命令*/
|
|
|
{
|
|
|
switch(devparam[devidx].baudrate)
|
|
|
{
|
|
|
case 9600:
|
|
|
imagesize = 0x07;
|
|
|
break;
|
|
|
case 14400:
|
|
|
imagesize = 0x08;
|
|
|
break;
|
|
|
case 19200:
|
|
|
imagesize = 0x08;
|
|
|
break;
|
|
|
case 38400:
|
|
|
imagesize = 0x09;
|
|
|
break;
|
|
|
case 57600:
|
|
|
imagesize = 0x09;
|
|
|
break;
|
|
|
case 115200:
|
|
|
imagesize = 0x09;
|
|
|
break;
|
|
|
default:
|
|
|
sprintf(szbuf, "设置串口摄像机参数时，配置参数错误!退出设置!");
|
|
|
LOGI("%s", szbuf);
|
|
|
srdt.ms_dev[devidx].SerialCmdidx = srdt.iLastGetPhotoNo;
|
|
|
return -1;
|
|
|
}
|
|
|
if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 15*1000/TIMER_CNT)
|
|
|
{
|
|
|
srdt.ms_dev[devidx].SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "设置串口摄像机参数时，15秒未收到摄像机应答!退出设置!");
|
|
|
LOGI("%s", szbuf);
|
|
|
return -1;
|
|
|
}
|
|
|
cmdidx = 0x03;
|
|
|
packetsize = 0xFFFF;
|
|
|
}
|
|
|
else if((10001 == cmdno)||(10002 == cmdno))/* 通知摄像机图片读取完成或存储（16H）*/
|
|
|
{
|
|
|
cmdidx = 0x16;
|
|
|
if(10001 == cmdno)
|
|
|
packetsize = 1;
|
|
|
else
|
|
|
packetsize = 0;
|
|
|
imagesize = srdt.photographtime; /* 需要保存或删除的图片拍摄时间*/
|
|
|
}
|
|
|
else if(10003 == cmdno) /* 读取历史图片（15H）*/
|
|
|
{
|
|
|
cmdidx = 0x15;
|
|
|
packetsize = (WORD)MAX_PHOTO_FRAME_LEN;
|
|
|
srdt.sendphototime=(int)time(NULL);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
imagesize = 0xFF;
|
|
|
packetsize = (WORD)srdt.ms_dev[devidx].SerialCmdidx;
|
|
|
cmdidx = 0x11;
|
|
|
if(srdt.ms_dev[devidx].FirstCmdTimeCnt > 35*1000/TIMER_CNT)
|
|
|
{
|
|
|
srdt.ms_dev[devidx].SerialCmdidx = -1;
|
|
|
sprintf(szbuf, "读取第%d包图片数据35秒未收到!结束拍照!",packetsize);
|
|
|
LOGI("%s", szbuf);
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
MakeCameraPhotoCommand(devidx, cmdidx, imagesize, packetsize, imagequality);
|
|
|
srdt.curdevidx[srdt.ms_dev[devidx].UseSerialidx] = devidx;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
生成 CameraPhoto命令
|
|
|
**********************************************************************************/
|
|
|
void MakeCameraPhotoCommand( int portno, BYTE cmdidx, int OneParam, WORD TwoParam, BYTE Threep )
|
|
|
{
|
|
|
int i, icurtime;
|
|
|
u_char *sendbuf;
|
|
|
//char szbuf[128];
|
|
|
|
|
|
sendbuf = serialport[srdt.ms_dev[portno].UseSerialidx].PollCmd;
|
|
|
|
|
|
icurtime = (int)time(NULL);
|
|
|
i = 0;
|
|
|
sendbuf[i++] = 0x00; /* 强制等待时间*/
|
|
|
sendbuf[i++] = 0x00; /* 强制等待时间*/
|
|
|
sendbuf[i++] = 0x68; /* 起始字符*/
|
|
|
sendbuf[i++] = (BYTE)0x00; /* length */
|
|
|
sendbuf[i++] = (BYTE)0x00; /* length */
|
|
|
sendbuf[i++] = 0x68; /* 起始字符*/
|
|
|
sendbuf[i++] = (BYTE)devparam[portno].devaddr;/* 传感器地址*/
|
|
|
sendbuf[i++] = cmdidx; /* 命令字*/
|
|
|
switch(cmdidx)
|
|
|
{
|
|
|
case 0x03: /*设置传感器通讯参数（03H）*/
|
|
|
sendbuf[i++] = 0x00; /* 波特率*/
|
|
|
sendbuf[i++] = 0x00;
|
|
|
sendbuf[i++] = 0x00;
|
|
|
sendbuf[i++] = (BYTE)OneParam;
|
|
|
sendbuf[i++] = 0x08; /* 数据位*/
|
|
|
sendbuf[i++] = 0x00; /* 校验位*/
|
|
|
sendbuf[i++] = 0x01; /* 停止位*/
|
|
|
break;
|
|
|
case 0x010: /* 拍摄图片并指定大小分包（10H）*/
|
|
|
sendbuf[i++] = OneParam; /* 图片大小（Resolution）*/
|
|
|
sendbuf[i++] = HIBYTE(TwoParam);/*包大小（PackageSize）*/
|
|
|
sendbuf[i++] = LOBYTE(TwoParam);
|
|
|
sendbuf[i++] = HIBYTE(HIWORD(icurtime+8*60*60));/* 请求拍摄图片时间（PhotoTime）*/
|
|
|
sendbuf[i++] = LOBYTE(HIWORD(icurtime+8*60*60));
|
|
|
sendbuf[i++] = HIBYTE(LOWORD(icurtime+8*60*60));
|
|
|
sendbuf[i++] = LOBYTE(LOWORD(icurtime+8*60*60));
|
|
|
sendbuf[i++] = Threep;/*图像质量（ImageQuality）*/
|
|
|
//sendbuf[i++] = netportparam.CurPresetno[srdt.ms_dev[portno].CameraChannel-1];/*拍照预置点（PresetNo）*/
|
|
|
break;
|
|
|
case 0x11: /* 获取指定包数据（11H）*/
|
|
|
sendbuf[i++] = HIBYTE(TwoParam);/*图片包号：（PackageNo）*/
|
|
|
sendbuf[i++] = LOBYTE(TwoParam);
|
|
|
break;
|
|
|
case 0x15: /* 读取历史图片（15H）*/
|
|
|
sendbuf[i++] = HIBYTE(TwoParam);/*包大小（PackageSize）*/
|
|
|
sendbuf[i++] = LOBYTE(TwoParam);
|
|
|
break;
|
|
|
case 0x16: /* 通知摄像机图片读取完成或存储（16H）*/
|
|
|
sendbuf[i++] = HIBYTE(HIWORD(OneParam));/* 需要保存或删除的图片拍摄时间*/
|
|
|
sendbuf[i++] = LOBYTE(HIWORD(OneParam));
|
|
|
sendbuf[i++] = HIBYTE(LOWORD(OneParam));
|
|
|
sendbuf[i++] = LOBYTE(LOWORD(OneParam));
|
|
|
sendbuf[i++] = (BYTE)TwoParam; /* 是否需要保存*/
|
|
|
break;
|
|
|
}
|
|
|
sendbuf[i] = CalLpc((u_char *)&sendbuf[6],i-6);
|
|
|
i+= 1;
|
|
|
sendbuf[i++] = 0x16; /* 信息尾*/
|
|
|
sendbuf[3] = (BYTE)((i-10)>>8);
|
|
|
sendbuf[4] = (BYTE)(i-10);
|
|
|
serialport[srdt.ms_dev[portno].UseSerialidx].cmdlen = i;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 准备发送云台指令
|
|
|
int Gm_CtrlPtzCmd(u_char channel, DWORD ptzcmd)
|
|
|
{
|
|
|
int i;
|
|
|
char szbuf[64];
|
|
|
|
|
|
srdt.PtzCmdType = ptzcmd;
|
|
|
// 查找装置序号
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM; i++)
|
|
|
{
|
|
|
if((channel == devparam[i].CameraChannel) && ((devparam[i].ProtocolIdx ==PELCO_P_PROTOCOL)
|
|
|
|| (devparam[i].ProtocolIdx ==PELCO_D_PROTOCOL)))
|
|
|
break;
|
|
|
}
|
|
|
if(i == MAX_SERIAL_DEV_NUM)
|
|
|
{
|
|
|
sprintf(szbuf, "没有找到摄像机使用的通道和串口通讯协议");
|
|
|
LOGI("%s", szbuf);
|
|
|
return 1;
|
|
|
}
|
|
|
if((2 > srdt.ms_dev[i].UseSerialidx+1) ||(MAX_SERIAL_PORT_NUM < srdt.ms_dev[i].UseSerialidx+1))
|
|
|
{
|
|
|
sprintf(szbuf, "通道%d摄像机错误的使用了串口%d", channel, srdt.ms_dev[i].UseSerialidx+1);
|
|
|
LOGI("%s", szbuf);
|
|
|
return 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(szbuf, "摄像机通道%d 使用串口%d", channel, srdt.ms_dev[i].UseSerialidx+1);
|
|
|
LOGI("%s", szbuf);
|
|
|
}
|
|
|
srdt.usecameradevidx = i;
|
|
|
// 查找串口序号
|
|
|
srdt.camerauseserial = srdt.ms_dev[i].UseSerialidx;
|
|
|
//if(0 == srdt.sampling)
|
|
|
//{
|
|
|
// 1.打开串口电源
|
|
|
Gm_OpenSerialPower();
|
|
|
// 2.打开串口通讯
|
|
|
Gm_OpenSerialPort(i);
|
|
|
//}
|
|
|
srdt.sampling |= 2;
|
|
|
srdt.SendStopPtzCmdTimeCnt = -1;
|
|
|
//return 1;
|
|
|
return Gm_Camera_Timer();
|
|
|
//return 1;
|
|
|
}
|
|
|
|
|
|
// 发送转动摄像机云台命令定时器
|
|
|
int Gm_Camera_Timer(void)
|
|
|
{
|
|
|
char szbuf[128];
|
|
|
|
|
|
if((2 > srdt.camerauseserial+1) ||(MAX_SERIAL_PORT_NUM < srdt.camerauseserial+1))
|
|
|
{
|
|
|
sprintf(szbuf, "摄像机错误的使用了串口%d", srdt.camerauseserial+1);
|
|
|
LOGI("%s", szbuf);
|
|
|
return 1;
|
|
|
}
|
|
|
if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
|
|
|
{
|
|
|
switch(srdt.PtzCmdType)
|
|
|
{
|
|
|
case P_Auto_Scan:
|
|
|
srdt.PtzCmdType = D_Auto_Scan;
|
|
|
break;
|
|
|
case P_IRIS_CLOSE:
|
|
|
srdt.PtzCmdType = D_IRIS_CLOSE;
|
|
|
break;
|
|
|
case P_IRIS_OPEN:
|
|
|
srdt.PtzCmdType = D_IRIS_OPEN;
|
|
|
break;
|
|
|
case P_FOCUS_NEAR:
|
|
|
srdt.PtzCmdType = D_FOCUS_NEAR;
|
|
|
break;
|
|
|
case P_FOCUS_FAR:
|
|
|
srdt.PtzCmdType = D_FOCUS_FAR;
|
|
|
break;
|
|
|
case P_ZOOM_WIDE:
|
|
|
srdt.PtzCmdType = D_ZOOM_WIDE;
|
|
|
break;
|
|
|
case P_ZOOM_TELE:
|
|
|
srdt.PtzCmdType = D_ZOOM_TELE;
|
|
|
break;
|
|
|
case P_MOVE_DOWN:
|
|
|
srdt.PtzCmdType = D_MOVE_DOWN;
|
|
|
break;
|
|
|
case P_MOVE_UP:
|
|
|
srdt.PtzCmdType = D_MOVE_UP;
|
|
|
break;
|
|
|
case P_MOVE_LEFT:
|
|
|
srdt.PtzCmdType = D_MOVE_LEFT;
|
|
|
break;
|
|
|
case P_MOVE_RIGHT:
|
|
|
srdt.PtzCmdType = D_MOVE_RIGHT;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(srdt.SendStopPtzCmdTimeCnt == -1)
|
|
|
{
|
|
|
if(serialport[srdt.camerauseserial].cmdlen > 0)
|
|
|
return -1;
|
|
|
if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
|
|
|
Gm_SendPelco_DCommand(srdt.PtzCmdType);
|
|
|
else
|
|
|
Gm_SendPelco_pCommand(srdt.PtzCmdType);
|
|
|
|
|
|
if((SET_PRESETNO == (srdt.PtzCmdType & 0xFFFF0000))
|
|
|
|| (MOVE_TO_PRESETNO == (srdt.PtzCmdType & 0xFFFF0000)))
|
|
|
{
|
|
|
srdt.sampling &= 0xFD;
|
|
|
return 1;
|
|
|
}
|
|
|
srdt.PtzCmdType = Cmd_Cancel;
|
|
|
srdt.SendStopPtzCmdTimeCnt = 0;
|
|
|
}
|
|
|
|
|
|
if(srdt.SendStopPtzCmdTimeCnt > PTZ_MOVETIME*1000)
|
|
|
{
|
|
|
if(serialport[srdt.camerauseserial].cmdlen > 0)
|
|
|
return -1;
|
|
|
if(PELCO_D_PROTOCOL == devparam[srdt.usecameradevidx].ProtocolIdx)
|
|
|
Gm_SendPelco_DCommand(srdt.PtzCmdType);
|
|
|
else
|
|
|
Gm_SendPelco_pCommand(srdt.PtzCmdType);
|
|
|
srdt.SendStopPtzCmdTimeCnt = -1;
|
|
|
srdt.sampling &= 0xFD;
|
|
|
return 1;
|
|
|
}
|
|
|
else
|
|
|
srdt.SendStopPtzCmdTimeCnt ++;
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
* 生成 PELCO_P 命令 *
|
|
|
*********************************************************************************/
|
|
|
void Gm_SendPelco_pCommand( DWORD cmdtype)
|
|
|
{
|
|
|
int len;
|
|
|
BYTE commandbuf[32];
|
|
|
char buf[128];
|
|
|
|
|
|
len = 0;
|
|
|
commandbuf[len++] = (BYTE)0xA0;
|
|
|
commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr;
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>24);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>16);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>8);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype);
|
|
|
commandbuf[len++] = (BYTE)0xAF;
|
|
|
commandbuf[len] = (BYTE)Gm_Pelco_pXORCheck(commandbuf, len);
|
|
|
len++;
|
|
|
serialport[srdt.camerauseserial].cmdlen = len;
|
|
|
Gm_SetSerialPortParam(srdt.camerauseserial);
|
|
|
len = GM_SerialComSend(commandbuf, len, srdt.camerauseserial);
|
|
|
if(len < 1)
|
|
|
{
|
|
|
LOGE("发送Pelco_p命令失败");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(buf, "发送串口%d 像机通道%d Pelco_P命令:",
|
|
|
srdt.camerauseserial+1, devparam[srdt.usecameradevidx].CameraChannel);
|
|
|
BytestreamLOG(buf, commandbuf, len, 'D');
|
|
|
}
|
|
|
ClearCmdFormPollCmdBuf(srdt.camerauseserial);
|
|
|
serialport[srdt.camerauseserial].ForceWaitCnt = 100;
|
|
|
serialport[srdt.camerauseserial].ForceWaitFlag = 1;
|
|
|
}
|
|
|
|
|
|
BYTE Gm_Pelco_pXORCheck( BYTE *msg, int len )
|
|
|
{
|
|
|
int i;
|
|
|
BYTE checkvalue=0;
|
|
|
|
|
|
if(len <= 0)
|
|
|
return checkvalue;
|
|
|
checkvalue = msg[0];
|
|
|
for(i=1; i<len; i++)
|
|
|
checkvalue ^= msg[i];
|
|
|
return checkvalue;
|
|
|
}
|
|
|
|
|
|
/********************************************************************************
|
|
|
* 生成 PELCO_D 命令 *
|
|
|
*********************************************************************************/
|
|
|
void Gm_SendPelco_DCommand( DWORD cmdtype)
|
|
|
{
|
|
|
int len;
|
|
|
BYTE commandbuf[32];
|
|
|
char buf[128];
|
|
|
|
|
|
len = 0;
|
|
|
#if 1 /* Pelco_D*/
|
|
|
commandbuf[len++] = (BYTE)0xFF;
|
|
|
commandbuf[len++] = (BYTE)devparam[srdt.usecameradevidx].devaddr;
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>24);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>16);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype>>8);
|
|
|
commandbuf[len++] = (BYTE)(cmdtype);
|
|
|
commandbuf[len] = (BYTE)Gm_Pelco_DCheck(commandbuf, len);
|
|
|
#endif
|
|
|
len++;
|
|
|
serialport[srdt.camerauseserial].cmdlen = len;
|
|
|
Gm_SetSerialPortParam(srdt.camerauseserial);
|
|
|
len = GM_SerialComSend(commandbuf, len, srdt.camerauseserial);
|
|
|
if(len < 1)
|
|
|
{
|
|
|
LOGE("发送Pelco_D命令失败");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
sprintf(buf, "发送串口%d 像机通道%d Pelco_D命令:",
|
|
|
srdt.camerauseserial+1, devparam[srdt.usecameradevidx].CameraChannel);
|
|
|
BytestreamLOG(buf, commandbuf, len, 'D');
|
|
|
}
|
|
|
ClearCmdFormPollCmdBuf(srdt.camerauseserial);
|
|
|
serialport[srdt.camerauseserial].ForceWaitCnt = 10;
|
|
|
serialport[srdt.camerauseserial].ForceWaitFlag = 1;
|
|
|
}
|
|
|
|
|
|
// 计算Pelco_D校验
|
|
|
BYTE Gm_Pelco_DCheck( BYTE *msg, int len )
|
|
|
{
|
|
|
int i;
|
|
|
BYTE checkvalue=0;
|
|
|
|
|
|
if(len <= 0)
|
|
|
return checkvalue;
|
|
|
checkvalue = 0;
|
|
|
for(i=1; i<len; i++)
|
|
|
checkvalue += msg[i];
|
|
|
return checkvalue;
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
寻找并生成下一条倾角命令
|
|
|
**********************************************************************************/
|
|
|
int FindNextShxyProtocolCommand( int devidx )
|
|
|
{
|
|
|
//如果命令缓冲区仍有命令，则退出本函数
|
|
|
if((devparam[devidx].commid+1 < 1) || (devparam[devidx].commid+1 >= MAX_SERIAL_PORT_NUM))
|
|
|
return -1;
|
|
|
//if(srdt.ms_dev[devidx].SerialCmdidx == 0)
|
|
|
{
|
|
|
if(get_msec()-srdt.ms_dev[devidx].FirstCmdTimeCnt < 3*1000)
|
|
|
{
|
|
|
//srdt.ms_dev[devidx].FirstCmdTimeCnt++;
|
|
|
return -1;
|
|
|
}
|
|
|
#if 0
|
|
|
if(SLANT_PROTOCOL == devparam[devidx].ProtocolIdx)
|
|
|
{
|
|
|
devparam[devidx].devaddr = 0xFF;
|
|
|
MakeShxyProtocolPollCommand(devidx, 0x02);
|
|
|
}
|
|
|
|
|
|
//else if(WEATHER_PROTOCOL== devparam[devidx].ProtocolIdx)
|
|
|
// MakeShxyProtocolPollCommand(devidx, 0x09);
|
|
|
else
|
|
|
#endif
|
|
|
MakeShxyProtocolPollCommand(devidx, 0x09);
|
|
|
srdt.curdevidx[srdt.ms_dev[devidx].UseSerialidx] = devidx;
|
|
|
return 1;
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
生成下发命令
|
|
|
**********************************************************************************/
|
|
|
void MakeShxyProtocolPollCommand(int portno, BYTE cmdidx)
|
|
|
{
|
|
|
int i/*, sendWaitTime = 100, y*/;
|
|
|
//char buf[128];
|
|
|
u_char *sendbuf;
|
|
|
|
|
|
sendbuf = serialport[srdt.ms_dev[portno].UseSerialidx].PollCmd;
|
|
|
|
|
|
i = 0;
|
|
|
sendbuf[i++] = 0x00; // 强制等待时间
|
|
|
sendbuf[i++] = 0x00; //
|
|
|
sendbuf[i++] = 0x68; // 起始字符
|
|
|
sendbuf[i++] = (BYTE)0x00; // length
|
|
|
sendbuf[i++] = (BYTE)0x00; // length
|
|
|
sendbuf[i++] = 0x68;
|
|
|
sendbuf[i++] = (BYTE)devparam[portno].devaddr; // 传感器地址
|
|
|
sendbuf[i++] = cmdidx; // 命令信息0x06
|
|
|
sendbuf[i] = CalLpc((u_char *)&sendbuf[6],i-6);
|
|
|
i+= 1;
|
|
|
sendbuf[i++] = 0x16; // 信息尾
|
|
|
serialport[srdt.ms_dev[portno].UseSerialidx].cmdlen = i;
|
|
|
//sprintf((char*)buf, "生成串口%d 装置%d倾角命令:", srdt.ms_dev[portno].UseSerialidx+1, portno+1);
|
|
|
//Gm_OMC_UART_DebugHex(buf, i-2, (char*)&sendbuf[2]);
|
|
|
}
|
|
|
|
|
|
|
|
|
unsigned char CalLpc(unsigned char *msg, int len)
|
|
|
{
|
|
|
int i;
|
|
|
u_char retval = 0;
|
|
|
|
|
|
for (i = 0 ; i < len; i++)
|
|
|
retval += msg[i];
|
|
|
return retval;
|
|
|
}
|
|
|
|
|
|
/***************************************************************
|
|
|
* 读上海欣影传感器协议数据 *
|
|
|
***************************************************************/
|
|
|
void ShxyProtocolRecvData(int commid, u_char *buf, int len)// 规约读数据处理
|
|
|
{
|
|
|
int i, ictime;
|
|
|
//WORD crc, check;
|
|
|
//SERIAL_DEV_DEF *pPortParam;
|
|
|
SIO_PARAM_SERIAL_DEF *pPortParam;
|
|
|
|
|
|
if((commid<0) || (commid > MAX_SERIAL_DEV_NUM))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
pPortParam = &serialport[devparam[commid].commid];
|
|
|
|
|
|
for(i=0; i<len; i++)
|
|
|
{
|
|
|
switch(pPortParam->m_iRevStatus)
|
|
|
{
|
|
|
case 0: // 0x68
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 1: // len1
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
break;
|
|
|
case 2: // len2
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
|
|
|
{
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
pPortParam->m_iNeedRevLength = buf[i]+5;
|
|
|
}
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 3: // 0x68
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
if(0x68 == buf[i])
|
|
|
pPortParam->m_iRevStatus++;
|
|
|
else
|
|
|
pPortParam->m_iRevStatus = 18;
|
|
|
break;
|
|
|
case 4: // 正确接收数据
|
|
|
pPortParam->m_iNeedRevLength--;
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iNeedRevLength > 0)
|
|
|
break;
|
|
|
if(buf[i] != 0x16)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus=18;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if(CheckShxyProtocolLpcError(pPortParam->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
|
|
|
{
|
|
|
ShxyProtocolDataProcess(commid);
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->RevCmdFlag = 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
}
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
break;
|
|
|
case 255:// 错误接收数据
|
|
|
default:
|
|
|
if(buf[i] == 0x68)
|
|
|
{
|
|
|
pPortParam->m_iRevStatus = 1;
|
|
|
pPortParam->m_iRecvLen = 1;
|
|
|
pPortParam->m_au8RecvBuf[0] = buf[i];
|
|
|
}
|
|
|
else if(buf[i] == 0x16)
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
pPortParam->m_iRevStatus = 0;
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
|
|
|
if(pPortParam->m_iRecvLen > 200)
|
|
|
{
|
|
|
pPortParam->m_iRecvLen = 0;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//********************************************************************************
|
|
|
// 检查检验和是否正确
|
|
|
//********************************************************************************
|
|
|
int CheckShxyProtocolLpcError( u_char* msg, int len )
|
|
|
{
|
|
|
int bRetval = FALSE;
|
|
|
int iCheckLen;
|
|
|
|
|
|
if(0x68 == msg[0])
|
|
|
{
|
|
|
if ( msg[0] != msg[3] )
|
|
|
return bRetval;
|
|
|
if ( msg[len-1] != 0x16 )
|
|
|
return bRetval;
|
|
|
if ( msg[1] != msg[2] )
|
|
|
return bRetval;
|
|
|
iCheckLen = msg[1];
|
|
|
if ( CalLpc( &msg[4], iCheckLen+2 ) != msg[len-2] )
|
|
|
return bRetval;
|
|
|
bRetval = TRUE;
|
|
|
}
|
|
|
return bRetval;
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
上海欣影传感器协议数据处理
|
|
|
**********************************************************************************/
|
|
|
void ShxyProtocolDataProcess( int commid)
|
|
|
{
|
|
|
float fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
|
|
|
WORD uDevAddr;
|
|
|
BYTE cmdidx;
|
|
|
int i, j, aipnt, datanum;
|
|
|
SERIAL_DEV_DEF *pPortParam;
|
|
|
SIO_PARAM_SERIAL_DEF *curserial;
|
|
|
char szbuf[64];
|
|
|
|
|
|
pPortParam = &srdt.ms_dev[commid];
|
|
|
curserial = &serialport[devparam[commid].commid];
|
|
|
|
|
|
//取出装置地址,开始处理地址+++
|
|
|
if(0x02 == curserial->m_au8RecvBuf[5])
|
|
|
{
|
|
|
devparam[commid].devaddr = curserial->m_au8RecvBuf[4];
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
cmdidx = curserial->m_au8RecvBuf[5];
|
|
|
aipnt = pPortParam->SameTypeDevIdx;
|
|
|
uDevAddr = curserial->m_au8RecvBuf[4];
|
|
|
|
|
|
fvalua = &fvalue;
|
|
|
if(0x06 == cmdidx)
|
|
|
{
|
|
|
if(0x08 !=curserial->m_au8RecvBuf[1])
|
|
|
return;
|
|
|
pPortParam->recvdatacnt++;
|
|
|
if(pPortParam->recvdatacnt < 2)
|
|
|
return;
|
|
|
// ++++++++++++++++++++++++++++
|
|
|
//g_SelfTest.SensorsFault |= (0x800<<aipnt);
|
|
|
|
|
|
*(BYTE*)fvalua = curserial->m_au8RecvBuf[9];
|
|
|
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[8];
|
|
|
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[7];
|
|
|
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[6];
|
|
|
if((fvalue < -59) ||(fvalue > 59))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%101-50)/1000.0;
|
|
|
slantpntmsg[aipnt][0].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
|
|
|
+slantpntmsg[aipnt][0].AiParam.EuValueDelta;
|
|
|
slantpntmsg[aipnt][0].AiState = 1;
|
|
|
//if ((gDisSunRain & 0x20) == 0x20)
|
|
|
{
|
|
|
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[commid].devaddr, fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
//XslantSec[aipnt][srdt.SectimesamplingCnt[0]] = (short)slantpntmsg[aipnt][0].EuValue;
|
|
|
//srdt.SectimesamplingCnt[0] += 1;
|
|
|
|
|
|
*(BYTE*)fvalua = curserial->m_au8RecvBuf[13];
|
|
|
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[12];
|
|
|
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[11];
|
|
|
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[10];
|
|
|
//if ((gDisSunRain & 0x20) == 0x20)
|
|
|
{
|
|
|
sprintf(szbuf, "Y =%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
if((fvalue < -59) ||(fvalue > 59))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%101-50)/1000.0;
|
|
|
slantpntmsg[aipnt][1].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
|
|
|
+slantpntmsg[aipnt][1].AiParam.EuValueDelta;
|
|
|
slantpntmsg[aipnt][1].AiState = 1;
|
|
|
//YslantSec[aipnt][srdt.SectimesamplingCnt[1]] = (short)slantpntmsg[aipnt][1].EuValue;
|
|
|
srdt.SectimesamplingCnt[1] += 1;
|
|
|
}
|
|
|
datanum = curserial->m_au8RecvBuf[6];
|
|
|
if((0x08 != cmdidx) && (0x09 != cmdidx))
|
|
|
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 )
|
|
|
{
|
|
|
if(0x08 == cmdidx)
|
|
|
fvalue = (curserial->m_au8RecvBuf[j+1]<<24)+(curserial->m_au8RecvBuf[j+2]<<16)
|
|
|
+(curserial->m_au8RecvBuf[j+3]<<8)+curserial->m_au8RecvBuf[j+4];
|
|
|
else
|
|
|
{
|
|
|
*(BYTE*)fvalua = curserial->m_au8RecvBuf[j+4];
|
|
|
*((BYTE*)fvalua+1) = curserial->m_au8RecvBuf[j+3];
|
|
|
*((BYTE*)fvalua+2) = curserial->m_au8RecvBuf[j+2];
|
|
|
*((BYTE*)fvalua+3) = curserial->m_au8RecvBuf[j+1];
|
|
|
}
|
|
|
switch(curserial->m_au8RecvBuf[j])
|
|
|
{
|
|
|
case 1: /*温度*/
|
|
|
if((fvalue < -40) ||(fvalue > 85))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%101-50)/1000.0;
|
|
|
weatherpntmsg[0].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
weatherpntmsg[0].EuValue = fvalue*weatherpntmsg[0].AiParam.fFactor + weatherpntmsg[0].AiParam.EuValueDelta;
|
|
|
weatherpntmsg[0].AiState = 1;
|
|
|
//g_SelfTest.SensorsFault |= (0x01);
|
|
|
//if ((gDisSunRain & 0x80) == 0x80)
|
|
|
{
|
|
|
sprintf(szbuf, "温度:%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 2: /*气压*/
|
|
|
if((fvalue < 550) ||(fvalue > 1060))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%41-20)/10000.0;
|
|
|
weatherpntmsg[5].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
weatherpntmsg[5].EuValue = fvalue*weatherpntmsg[5].AiParam.fFactor + weatherpntmsg[5].AiParam.EuValueDelta;
|
|
|
weatherpntmsg[5].AiState = 1;
|
|
|
//g_SelfTest.SensorsFault |= (0x10);
|
|
|
//if ((gDisSunRain & 0x80) == 0x80)
|
|
|
{
|
|
|
sprintf(szbuf, "气压:%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 3: /*湿度*/
|
|
|
if((fvalue < 0) ||(fvalue > 100))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%41-20)/1000.0;
|
|
|
weatherpntmsg[1].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
weatherpntmsg[1].EuValue = fvalue*weatherpntmsg[1].AiParam.fFactor + weatherpntmsg[1].AiParam.EuValueDelta;
|
|
|
weatherpntmsg[1].AiState = 1;
|
|
|
//g_SelfTest.SensorsFault |= (0x02);
|
|
|
//if ((gDisSunRain & 0x80) == 0x80)
|
|
|
{
|
|
|
sprintf(szbuf, "湿度:%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 4: /*雨量*/
|
|
|
break;
|
|
|
case 5: /*日照*/
|
|
|
break;
|
|
|
case 6: /*风速*/
|
|
|
if((fvalue/1000 < 0) ||(fvalue/1000 > 80))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%41-20)/1000.0;
|
|
|
weatherpntmsg[2].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
weatherpntmsg[2].EuValue = fvalue*weatherpntmsg[2].AiParam.fFactor + weatherpntmsg[2].AiParam.EuValueDelta;
|
|
|
weatherpntmsg[2].AiState = 1;
|
|
|
//g_SelfTest.SensorsFault |= (0x04);
|
|
|
//if ((gDisSunRain & 0x10) == 0x10)
|
|
|
{
|
|
|
//fwind = fvalue/1000*0.95;
|
|
|
//if(fvalue/1000 > 25)
|
|
|
// fwind -= 1.2;
|
|
|
//sprintf(szbuf, "风速:%0.3f ", fwind);
|
|
|
sprintf(szbuf, "风速:%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 7: /*风向*/
|
|
|
if((fvalue/1000 < 0) ||(fvalue/1000 > 359.99))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%41-20)/1000.0;
|
|
|
weatherpntmsg[3].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
weatherpntmsg[3].EuValue = fvalue*weatherpntmsg[3].AiParam.fFactor + weatherpntmsg[3].AiParam.EuValueDelta;
|
|
|
weatherpntmsg[3].AiState = 1;
|
|
|
//g_SelfTest.SensorsFault |= (0x08);
|
|
|
//if ((gDisSunRain & 0x10) == 0x10)
|
|
|
{
|
|
|
sprintf(szbuf, "风向:%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 8: /*拉力*/
|
|
|
#if 0
|
|
|
if(RESERVE1_PROTOCOL == pPortParam->ProtocolIdx)
|
|
|
{
|
|
|
leirallypntmsg[0].EuValue = fvalue*leirallypntmsg[0].AiParam.fFactor\
|
|
|
+leirallypntmsg[0].AiParam.EuValueDelta;
|
|
|
leirallypntmsg[0].AiState = 1;
|
|
|
g_SelfTest.SensorsFault |= (0x800000);
|
|
|
if ((gDisSunRain & 0x10) == 0x10)
|
|
|
{
|
|
|
sprintf(szbuf, "地址%d模拟导线拉力:%0.3fKg ", pPortParam->devaddr, fvalue/1000.0);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
#endif
|
|
|
pPortParam->recvdatacnt++;
|
|
|
if(pPortParam->recvdatacnt < 2)
|
|
|
break;
|
|
|
//g_SelfTest.SensorsFault |= (0x040<<aipnt);
|
|
|
//if(fvalue/1000.0 < rallypntmsg[aipnt][1].AiParam.EuValueDelta)
|
|
|
// rallypntmsg[aipnt][0].EuValue = 0;
|
|
|
//else
|
|
|
rallypntmsg[aipnt][0].EuValue = fvalue*rallypntmsg[aipnt][0].AiParam.fFactor\
|
|
|
+rallypntmsg[aipnt][0].AiParam.EuValueDelta;
|
|
|
rallypntmsg[aipnt][0].AiState = 1;
|
|
|
//if ((gDisSunRain & 0x10) == 0x10)
|
|
|
{
|
|
|
sprintf(szbuf, "地址%d拉力:%0.3fKg ", devparam[commid].devaddr, fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
// yizhonghu 20110629
|
|
|
//rallyd[aipnt][srdt.SectimesamplingCnt[2]] = (short)slantpntmsg[aipnt][0].EuValue;
|
|
|
srdt.SectimesamplingCnt[2] += 1;
|
|
|
//}
|
|
|
break;
|
|
|
case 9: /*倾角传感器X轴倾角*/
|
|
|
if((fvalue < -59) ||(fvalue > 59))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%101-50)/1000.0;
|
|
|
slantpntmsg[aipnt][0].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
slantpntmsg[aipnt][0].EuValue = fvalue*slantpntmsg[aipnt][0].AiParam.fFactor\
|
|
|
+slantpntmsg[aipnt][0].AiParam.EuValueDelta;
|
|
|
slantpntmsg[aipnt][0].AiState = 1;
|
|
|
//if ((gDisSunRain & 0x20) == 0x20)
|
|
|
{
|
|
|
sprintf(szbuf, "倾角ID:%d slantangle X=%0.3f ", devparam[commid].devaddr, fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
break;
|
|
|
case 10: /*倾角传感器Y轴倾角*/
|
|
|
{
|
|
|
sprintf(szbuf, "Y =%0.3f ", fvalue);
|
|
|
LOGV("%s", szbuf);
|
|
|
}
|
|
|
if((fvalue < -59) ||(fvalue > 59))
|
|
|
{
|
|
|
frnb = (GeneratingRandomNumber()%101-50)/1000.0;
|
|
|
slantpntmsg[aipnt][1].EuValue *= (1+frnb);
|
|
|
}
|
|
|
else
|
|
|
slantpntmsg[aipnt][1].EuValue = fvalue*slantpntmsg[aipnt][1].AiParam.fFactor\
|
|
|
+slantpntmsg[aipnt][1].AiParam.EuValueDelta;
|
|
|
slantpntmsg[aipnt][1].AiState = 1;
|
|
|
break;
|
|
|
#if 0
|
|
|
case 11: /*测温球导线温度*/
|
|
|
|
|
|
fcorvalue = WireTemperatureCorrection(fvalue/100, (WORD)pPortParam->devaddr);
|
|
|
|
|
|
wdiitemppntmsg[aipnt][0].EuValue = fvalue*wdiitemppntmsg[aipnt][0].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][0].AiParam.EuValueDelta;
|
|
|
//#else
|
|
|
wdiitemppntmsg[aipnt][0].EuValue = fcorvalue*100*wdiitemppntmsg[aipnt][0].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][0].AiParam.EuValueDelta;
|
|
|
|
|
|
wdiitemppntmsg[aipnt][0].AiState = 1;
|
|
|
g_SelfTest.SensorsFault |= (0x100000);
|
|
|
sprintf(szbuf, "地址%d导线温度:%0.3f ", pPortParam->devaddr, fcorvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 12: /*测温球内部温度*/
|
|
|
wdiitemppntmsg[aipnt][1].EuValue = fvalue*wdiitemppntmsg[aipnt][1].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][1].AiParam.EuValueDelta;
|
|
|
wdiitemppntmsg[aipnt][1].AiState = 1;
|
|
|
sprintf(szbuf, "地址%d内部温度:%0.3f ", pPortParam->devaddr, fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
case 13: /*测温球导线X轴倾角*/
|
|
|
wdiitemppntmsg[aipnt][3].EuValue = fvalue*wdiitemppntmsg[aipnt][3].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][3].AiParam.EuValueDelta;
|
|
|
wdiitemppntmsg[aipnt][3].AiState = 1;
|
|
|
sprintf(szbuf, "地址%d导线X轴倾角:%0.3f ", pPortParam->devaddr, fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 14: /*测温球导线Y轴倾角*/
|
|
|
wdiitemppntmsg[aipnt][4].EuValue = fvalue*wdiitemppntmsg[aipnt][4].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][4].AiParam.EuValueDelta;
|
|
|
wdiitemppntmsg[aipnt][4].AiState = 1;
|
|
|
sprintf(szbuf, "地址%d导线Y轴倾角:%0.3f ", pPortParam->devaddr, fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
case 15: /*测温球导线电流*/
|
|
|
wdiitemppntmsg[aipnt][5].EuValue = fvalue*wdiitemppntmsg[aipnt][5].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][5].AiParam.EuValueDelta;
|
|
|
wdiitemppntmsg[aipnt][5].AiState = 1;
|
|
|
sprintf(szbuf, "地址%d导线电流:%0.3f ", pPortParam->devaddr, fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 16: /*测温球电池电压*/
|
|
|
wdiitemppntmsg[aipnt][2].EuValue = fvalue*wdiitemppntmsg[aipnt][2].AiParam.fFactor\
|
|
|
+wdiitemppntmsg[aipnt][2].AiParam.EuValueDelta;
|
|
|
wdiitemppntmsg[aipnt][2].AiState = 1;
|
|
|
sprintf(szbuf, "地址%d测温球电池电压:%0.3fV ", pPortParam->devaddr, fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
case 17: /*A相泄漏电流平均值；*/
|
|
|
LCpntmsg[0].EuValue = fvalue*LCpntmsg[0].AiParam.fFactor + LCpntmsg[0].AiParam.EuValueDelta;
|
|
|
LCpntmsg[0].AiState = 1;
|
|
|
sprintf(szbuf, "A相泄漏电流平均值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 18: /*A相泄漏电流最大值；*/
|
|
|
LCpntmsg[1].EuValue = fvalue*LCpntmsg[1].AiParam.fFactor + LCpntmsg[1].AiParam.EuValueDelta;
|
|
|
LCpntmsg[1].AiState = 1;
|
|
|
sprintf(szbuf, "A相泄漏电流最大值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 19: /*A相超过3mA的脉冲频次*/
|
|
|
LCpntmsg[2].EuValue = fvalue*LCpntmsg[2].AiParam.fFactor + LCpntmsg[2].AiParam.EuValueDelta;
|
|
|
LCpntmsg[2].AiState = 1;
|
|
|
sprintf(szbuf, "A相超过3mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 20: /*A相超过10mA的脉冲频次*/
|
|
|
LCpntmsg[3].EuValue = fvalue*LCpntmsg[3].AiParam.fFactor + LCpntmsg[3].AiParam.EuValueDelta;
|
|
|
LCpntmsg[3].AiState = 1;
|
|
|
sprintf(szbuf, "A相超过10mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
case 21: /*B相泄漏电流平均值；*/
|
|
|
LCpntmsg[4].EuValue = fvalue*LCpntmsg[4].AiParam.fFactor + LCpntmsg[4].AiParam.EuValueDelta;
|
|
|
LCpntmsg[4].AiState = 1;
|
|
|
sprintf(szbuf, "B相泄漏电流平均值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 22: /*B相泄漏电流最大值；*/
|
|
|
LCpntmsg[5].EuValue = fvalue*LCpntmsg[5].AiParam.fFactor + LCpntmsg[5].AiParam.EuValueDelta;
|
|
|
LCpntmsg[5].AiState = 1;
|
|
|
sprintf(szbuf, "B相泄漏电流最大值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 23: /*B相超过3mA的脉冲频次*/
|
|
|
LCpntmsg[6].EuValue = fvalue*LCpntmsg[6].AiParam.fFactor + LCpntmsg[6].AiParam.EuValueDelta;
|
|
|
LCpntmsg[6].AiState = 1;
|
|
|
sprintf(szbuf, "B相超过3mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 24: /*B相超过10mA的脉冲频次*/
|
|
|
LCpntmsg[7].EuValue = fvalue*LCpntmsg[7].AiParam.fFactor + LCpntmsg[7].AiParam.EuValueDelta;
|
|
|
LCpntmsg[7].AiState = 1;
|
|
|
sprintf(szbuf, "B相超过10mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
case 25: /*C相泄漏电流平均值；*/
|
|
|
LCpntmsg[8].EuValue = fvalue*LCpntmsg[8].AiParam.fFactor + LCpntmsg[8].AiParam.EuValueDelta;
|
|
|
LCpntmsg[8].AiState = 1;
|
|
|
sprintf(szbuf, "C相泄漏电流平均值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 26: /*C相泄漏电流最大值；*/
|
|
|
LCpntmsg[9].EuValue = fvalue*LCpntmsg[9].AiParam.fFactor + LCpntmsg[9].AiParam.EuValueDelta;
|
|
|
LCpntmsg[9].AiState = 1;
|
|
|
sprintf(szbuf, "C相泄漏电流最大值:%0.3f ", fvalue/100);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 27: /*C相超过3mA的脉冲频次*/
|
|
|
LCpntmsg[10].EuValue = fvalue*LCpntmsg[10].AiParam.fFactor + LCpntmsg[10].AiParam.EuValueDelta;
|
|
|
LCpntmsg[10].AiState = 1;
|
|
|
sprintf(szbuf, "C相超过3mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 0);
|
|
|
break;
|
|
|
case 28: /*C相超过10mA的脉冲频次*/
|
|
|
LCpntmsg[11].EuValue = fvalue*LCpntmsg[11].AiParam.fFactor + LCpntmsg[11].AiParam.EuValueDelta;
|
|
|
LCpntmsg[11].AiState = 1;
|
|
|
sprintf(szbuf, "C相超过10mA的脉冲频次:%0.3f ", fvalue);
|
|
|
DebugStringPrintf(szbuf, strlen(szbuf), 1);
|
|
|
break;
|
|
|
#endif
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*********************************************************************************
|
|
|
把16进制和10进制ASCII字符串转换成int整数
|
|
|
*********************************************************************************/
|
|
|
int ATOI(char *buf)
|
|
|
{
|
|
|
int i, ilen, iRetVal;
|
|
|
|
|
|
if(NULL == buf)
|
|
|
return 0;
|
|
|
ilen = strlen(buf);
|
|
|
if(ilen > 2)
|
|
|
{
|
|
|
if((buf[0]=='0') && ((buf[1]=='x') || (buf[1]=='X')))
|
|
|
{
|
|
|
iRetVal = 0;
|
|
|
for(i=2; i<ilen; i++)
|
|
|
{
|
|
|
iRetVal = (iRetVal << 4) + HexCharToInt(buf[i]);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
iRetVal = atoi(buf);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
iRetVal = atoi(buf);
|
|
|
}
|
|
|
return iRetVal;
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
// 控制关闭传感器电源
|
|
|
void Gm_CtrlCloseSensorsPower(int devidx)
|
|
|
{
|
|
|
if((devidx<0) || (devidx > MAX_SERIAL_DEV_NUM-1))
|
|
|
return;
|
|
|
srdt.ms_dev[devidx].uOpenPowerFlag = CLOSEPOWER;
|
|
|
}
|
|
|
|
|
|
|
|
|
// 检查传感器电源是否应该关闭或打开
|
|
|
void Gm_CheckSensorsPower(void)
|
|
|
{
|
|
|
int i, j;
|
|
|
|
|
|
for(i=0; i<MAX_SERIAL_DEV_NUM-2; i++)
|
|
|
{
|
|
|
if((1 > srdt.ms_dev[i].ProtocolIdx) ||(INVALID_PROTOCOL<=srdt.ms_dev[i].ProtocolIdx))
|
|
|
continue;
|
|
|
if((PELCO_P_PROTOCOL == srdt.ms_dev[i].ProtocolIdx) ||(PELCO_D_PROTOCOL == srdt.ms_dev[i].ProtocolIdx)
|
|
|
||( SERIALCAMERA_PROTOCOL == srdt.ms_dev[i].ProtocolIdx))
|
|
|
continue;
|
|
|
// 需要传感器处于上电状态
|
|
|
for(j=0; j<MAX_SERIAL_DEV_NUM-2; j++)
|
|
|
{
|
|
|
if((srdt.ms_dev[i].PowerPort == srdt.ms_dev[j].PowerPort) && (srdt.ms_dev[j].uOpenPowerFlag == OPENPOWER))
|
|
|
break;
|
|
|
}
|
|
|
if(j <MAX_SERIAL_DEV_NUM-2)
|
|
|
continue;
|
|
|
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
int GeneratingRandomNumber(void)
|
|
|
{
|
|
|
int ictime, randomdate;
|
|
|
/* 生成随机数n-m -> rand()%(m-n+1)+n*/
|
|
|
ictime = (int)time(NULL);
|
|
|
srand((DWORD)ictime);
|
|
|
randomdate = rand();
|
|
|
return randomdate;
|
|
|
}
|
|
|
|
|
|
|