2662 lines
79 KiB
C++
2662 lines
79 KiB
C++
#include <time.h>
|
||
#include <sys/time.h>
|
||
#include "SH_global.h"
|
||
#include "SH_CommonFunc.hpp"
|
||
#include <boost/xpressive/xpressive_dynamic.hpp>
|
||
#include <unistd.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/select.h>
|
||
#include <sys/types.h>
|
||
#include <fcntl.h>
|
||
#include <limits.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <unistd.h>
|
||
#include <linux/sockios.h>
|
||
#include <linux/rtc.h>
|
||
#include <linux/rtc.h>
|
||
#include "../dbaccess/SH_SqlDB.hpp"
|
||
|
||
#define ETHTOOL_GLINK 0x0000000a /* Get link status (ethtool_value) */
|
||
#define MAX_WAIT_TIME 1
|
||
#define MAX_NO_PACKETS 1
|
||
#define ICMP_HEADSIZE 8
|
||
#define PACKET_SIZE 4096
|
||
struct timeval tvsend,tvrecv;
|
||
struct sockaddr_in dest_addr,recv_addr;
|
||
int sockfd;
|
||
pid_t pid;
|
||
char sendpacket[PACKET_SIZE];
|
||
char recvpacket[PACKET_SIZE];
|
||
|
||
static boost::mutex s_config_mu;
|
||
Mutex g_tDbMutex;
|
||
string GetLocalTimeWithMs(void)
|
||
{
|
||
string defaultTime = "19700101000000000";
|
||
try
|
||
{
|
||
struct timeval curTime;
|
||
gettimeofday(&curTime, NULL);
|
||
int milli = curTime.tv_usec / 1000;
|
||
|
||
char buffer[80] = {0};
|
||
struct tm nowTime;
|
||
localtime_r(&curTime.tv_sec, &nowTime);//把得到的值存入临时分配的内存中，线程安全
|
||
strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", &nowTime);
|
||
|
||
char currentTime[84] = {0};
|
||
snprintf(currentTime, sizeof(currentTime), "%s%03d", buffer, milli);
|
||
|
||
return currentTime;
|
||
}
|
||
catch(const std::exception& e)
|
||
{
|
||
return defaultTime;
|
||
}
|
||
catch (...)
|
||
{
|
||
return defaultTime;
|
||
}
|
||
}
|
||
int code_convert(const char *from_charset, const char *to_charset, char *inbuf, size_t inlen,
|
||
char *outbuf, size_t outlen) {
|
||
iconv_t cd;
|
||
char **pin = &inbuf;
|
||
char **pout = &outbuf;
|
||
|
||
cd = iconv_open(to_charset, from_charset);
|
||
if (cd == 0)
|
||
return -1;
|
||
|
||
memset(outbuf, 0, outlen);
|
||
|
||
if ((int)iconv(cd, pin, &inlen, pout, &outlen) == -1)
|
||
{
|
||
iconv_close(cd);
|
||
return -1;
|
||
}
|
||
iconv_close(cd);
|
||
*pout = '\0';
|
||
|
||
return 0;
|
||
}
|
||
|
||
int u2g(char *inbuf, size_t inlen, char *outbuf, size_t outlen) {
|
||
return code_convert("utf-8", "gb2312", inbuf, inlen, outbuf, outlen);
|
||
}
|
||
|
||
int g2u(char *inbuf, size_t inlen, char *outbuf, size_t outlen) {
|
||
return code_convert("gb2312", "utf-8", inbuf, inlen, outbuf, outlen);
|
||
}
|
||
|
||
std::string GBKToUTF8(const std::string& strGBK)
|
||
{
|
||
int length = strGBK.size()*2+1;
|
||
|
||
char *temp = (char*)malloc(sizeof(char)*length);
|
||
|
||
if(g2u((char*)strGBK.c_str(),strGBK.size(),temp,length) >= 0)
|
||
{
|
||
std::string str_result;
|
||
str_result.append(temp);
|
||
free(temp);
|
||
return str_result;
|
||
}else
|
||
{
|
||
free(temp);
|
||
return "";
|
||
}
|
||
}
|
||
|
||
std::string UTFtoGBK(const char* utf8)
|
||
{
|
||
int length = strlen(utf8);
|
||
|
||
char *temp = (char*)malloc(sizeof(char)*length);
|
||
|
||
if(u2g((char*)utf8,length,temp,length) >= 0)
|
||
{
|
||
std::string str_result;
|
||
str_result.append(temp);
|
||
free(temp);
|
||
|
||
return str_result;
|
||
}else
|
||
{
|
||
free(temp);
|
||
return "";
|
||
}
|
||
}
|
||
std::string convertEncoding(const std::string& input, const char* fromEncoding, const char* toEncoding) {
|
||
iconv_t conv = iconv_open(toEncoding, fromEncoding);
|
||
if (conv == (iconv_t)-1) {
|
||
throw std::runtime_error("iconv_open failed");
|
||
}
|
||
|
||
size_t inBytesLeft = input.size();
|
||
size_t outBytesLeft = inBytesLeft * 2; // GBK may require up to twice the space of UTF-8
|
||
char* inBuf = const_cast<char*>(input.c_str());
|
||
char* outBuf = new char[outBytesLeft];
|
||
char* outPtr = outBuf;
|
||
|
||
if (iconv(conv, &inBuf, &inBytesLeft, &outPtr, &outBytesLeft) == (size_t)-1) {
|
||
delete[] outBuf;
|
||
iconv_close(conv);
|
||
throw std::runtime_error("iconv failed");
|
||
}
|
||
|
||
std::string result(outBuf, outPtr);
|
||
delete[] outBuf;
|
||
iconv_close(conv);
|
||
return result;
|
||
}
|
||
|
||
void InitGpio(unsigned int gpioN,unsigned int inout)
|
||
{
|
||
int fd = 0;
|
||
char tmp[100] = {0};
|
||
//打开gpio设备文件
|
||
fd = open("/sys/class/gpio/export", O_WRONLY);
|
||
if(-1 == fd)
|
||
{
|
||
printf("[%s]:[%d] open gpio export file error\r\n", __FUNCTION__, __LINE__);
|
||
}
|
||
//申请gpio
|
||
sprintf(tmp,"%d",gpioN);
|
||
if(write(fd, tmp, strlen(tmp)) < 0)
|
||
{
|
||
printf("write file operation error %s\r\n",tmp);
|
||
|
||
}
|
||
close(fd);
|
||
sleep(1);
|
||
//配置gpio方向
|
||
#ifdef G2UL_GATEWAY
|
||
char tmp2[100] = {0};
|
||
if(gpioN == 507)
|
||
memcpy(tmp2,"P18_3",5);
|
||
else if(gpioN == 499)
|
||
memcpy(tmp2,"P17_3",5);
|
||
else if(gpioN == 496)
|
||
memcpy(tmp2,"P17_0",5);
|
||
else if(gpioN == 130)
|
||
memcpy(tmp2,"P9_0",4);
|
||
else if(gpioN == 408)
|
||
memcpy(tmp2,"P6_0",4);
|
||
else if(gpioN == 363)
|
||
memcpy(tmp2,"P0_3",4);
|
||
else if(gpioN == 498)
|
||
memcpy(tmp2,"P17_2",5);
|
||
else if(gpioN == 466)
|
||
memcpy(tmp2,"P13_2",5);
|
||
else if(gpioN == 488)
|
||
memcpy(tmp2,"P16_0",5);
|
||
else if(gpioN == 474)
|
||
memcpy(tmp2,"P14_2",5);
|
||
else if(gpioN == 497)
|
||
memcpy(tmp2,"P17_1",5);
|
||
else if(gpioN == 409)
|
||
memcpy(tmp2,"P6_1",4);
|
||
else if(gpioN == 410)
|
||
memcpy(tmp2,"P6_2",4);
|
||
else if(gpioN == 449)
|
||
memcpy(tmp2,"P11_1",5);
|
||
else if(gpioN == 489)
|
||
memcpy(tmp2,"P16_1",5);
|
||
sprintf(tmp,"/sys/class/gpio/%s/direction",tmp2);
|
||
#else if IMX6UL_GATEWAY
|
||
sprintf(tmp,"/sys/class/gpio/gpio%d/direction",gpioN);
|
||
#endif
|
||
|
||
print_info("open GPIO = %s\n",tmp);
|
||
fd = open(tmp, O_WRONLY);
|
||
if(-1 == fd)
|
||
{
|
||
printf("[%s]:[%d] open gpio direction file error\r\n", __FUNCTION__, __LINE__);
|
||
close(fd);
|
||
}
|
||
|
||
if(inout == 0)
|
||
{
|
||
print_info("=====InitGpio=====in\n");
|
||
if(-1 == write(fd, "in", sizeof("in")))
|
||
{
|
||
print_info("[%s]:[%d] [%d]write operation direction error\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
close(fd);
|
||
}
|
||
}
|
||
else if( inout == 1)
|
||
{
|
||
print_info("=====InitGpio=====out\n");
|
||
if(-1 == write(fd, "out", sizeof("out")))
|
||
{
|
||
print_info("[%s]:[%d] [%d]write operation direction error\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
close(fd);
|
||
}
|
||
}
|
||
close(fd);
|
||
// printf("gpio%d init %d\r\n",gpioN,inout);
|
||
}
|
||
int gpio_set(unsigned int gpioN,char x)
|
||
{
|
||
int fd = 0;
|
||
char tmp[100] = {0};
|
||
#ifdef G2UL_GATEWAY
|
||
char tmp2[100] = {0};
|
||
if(gpioN == 507)
|
||
memcpy(tmp2,"P18_3",5);
|
||
else if(gpioN == 499)
|
||
memcpy(tmp2,"P17_3",5);
|
||
else if(gpioN == 496)
|
||
memcpy(tmp2,"P17_0",5);
|
||
else if(gpioN == 130)
|
||
memcpy(tmp2,"P9_0",4);
|
||
else if(gpioN == 408)
|
||
memcpy(tmp2,"P6_0",4);
|
||
else if(gpioN == 363)
|
||
memcpy(tmp2,"P0_3",4);
|
||
else if(gpioN == 498)
|
||
memcpy(tmp2,"P17_2",5);
|
||
else if(gpioN == 466)
|
||
memcpy(tmp2,"P13_2",5);
|
||
else if(gpioN == 488)
|
||
memcpy(tmp2,"P16_0",5);
|
||
else if(gpioN == 474)
|
||
memcpy(tmp2,"P14_2",5);
|
||
else if(gpioN == 497)
|
||
memcpy(tmp2,"P17_1",5);
|
||
else if(gpioN == 409)
|
||
memcpy(tmp2,"P6_1",4);
|
||
else if(gpioN == 410)
|
||
memcpy(tmp2,"P6_2",4);
|
||
else if(gpioN == 449)
|
||
memcpy(tmp2,"P11_1",5);
|
||
else if(gpioN == 489)
|
||
memcpy(tmp2,"P16_1",5);
|
||
sprintf(tmp,"/sys/class/gpio/%s/value",tmp2);
|
||
#else if IMX6UL_GATEWAY
|
||
sprintf(tmp,"/sys/class/gpio/gpio%d/value",gpioN);
|
||
#endif
|
||
// printf("%s\r\n",tmp);
|
||
//print_info("set GPIO = %s\n",tmp);
|
||
//打开gpio value文件
|
||
fd = open(tmp, O_WRONLY);
|
||
if(-1 == fd)
|
||
{
|
||
print_red("[%s]:[%d][%s] open gpio export file error\r\n", __FUNCTION__, __LINE__,tmp);
|
||
close(fd);
|
||
return (-1);//exit(1);
|
||
}
|
||
//设置电平
|
||
if(x)
|
||
{
|
||
if(-1 == write(fd, "1", sizeof("1")))
|
||
{
|
||
print_red("[%s]:[%d] %d write operation value error\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
close(fd);
|
||
return (-1);//exit(1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(-1 == write(fd, "0", sizeof("0")))
|
||
{
|
||
print_red("[%s]:[%d] %d write operation value error\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
close(fd);
|
||
return (-1);//exit(1);
|
||
}
|
||
}
|
||
// printf("gpio%d set %d ok\r\n",gpioN,x);
|
||
close(fd);
|
||
return 0;
|
||
}
|
||
int gpio_read(unsigned int gpioN)
|
||
{
|
||
int fd = 0;
|
||
char value;
|
||
|
||
char tmp[100] = {0};
|
||
|
||
#ifdef G2UL_GATEWAY
|
||
char tmp2[100] = {0};
|
||
if(gpioN == 507)
|
||
memcpy(tmp2,"P18_3",5);
|
||
else if(gpioN == 499)
|
||
memcpy(tmp2,"P17_3",5);
|
||
else if(gpioN == 496)
|
||
memcpy(tmp2,"P17_0",5);
|
||
else if(gpioN == 130)
|
||
memcpy(tmp2,"P9_0",4);
|
||
else if(gpioN == 408)
|
||
memcpy(tmp2,"P6_0",4);
|
||
else if(gpioN == 363)
|
||
memcpy(tmp2,"P0_3",4);
|
||
else if(gpioN == 498)
|
||
memcpy(tmp2,"P17_2",5);
|
||
else if(gpioN == 466)
|
||
memcpy(tmp2,"P13_2",5);
|
||
else if(gpioN == 488)
|
||
memcpy(tmp2,"P16_0",5);
|
||
else if(gpioN == 474)
|
||
memcpy(tmp2,"P14_2",5);
|
||
else if(gpioN == 497)
|
||
memcpy(tmp2,"P17_1",5);
|
||
else if(gpioN == 409)
|
||
memcpy(tmp2,"P6_1",4);
|
||
else if(gpioN == 410)
|
||
memcpy(tmp2,"P6_2",4);
|
||
else if(gpioN == 449)
|
||
memcpy(tmp2,"P11_1",5);
|
||
else if(gpioN == 489)
|
||
memcpy(tmp2,"P16_1",5);
|
||
sprintf(tmp,"/sys/class/gpio/%s/value",tmp2);
|
||
#else if IMX6UL_GATEWAY
|
||
sprintf(tmp,"/sys/class/gpio/gpio%d/value",gpioN);
|
||
#endif
|
||
//打开gpio value文件
|
||
fd = open(tmp, O_RDONLY);
|
||
if(-1 == fd)
|
||
{
|
||
print_red("[%s]:[%d] %d open gpio export file error\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
return (-1);//exit(1);
|
||
}
|
||
//读取 value文件
|
||
if(-1 == read(fd, &value, sizeof(value)))
|
||
{
|
||
print_red("[%s]:[%d] %d read gpiovalue is fail\r\n", __FUNCTION__, __LINE__,gpioN);
|
||
close(fd);
|
||
return (-1);//exit(1);
|
||
}
|
||
close(fd);
|
||
//printf("gpio%d get %d\r\n",gpioN,value);
|
||
return value;
|
||
}
|
||
|
||
int CheckFileVersion(int argc, char** argv)
|
||
{
|
||
std::string strVersion = GlobalConfig::Version;
|
||
int optionchar; /*选项字<E9A1B9>??*/
|
||
if (argc >= 2) {
|
||
if (strcmp(argv[1], "--debugmode") == 0){
|
||
GlobalConfig::RUN_MODE = 1;
|
||
return 0;
|
||
}
|
||
optionchar = getopt(argc, argv, "vVhH?");
|
||
switch (optionchar) {
|
||
case 'v':
|
||
case 'V':
|
||
GlobalConfig::RUN_MODE = 1;
|
||
print_debug("Compile time:%s %s\n", __DATE__, __TIME__);
|
||
print_debug("The internal version is:%s.\n", strVersion.c_str());
|
||
break;
|
||
case 'h':
|
||
case 'H':
|
||
case '?':
|
||
printf("Please input -v or -V to get the file version.\n");
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
int config_uart(const char* Port,speed_t speed)
|
||
{
|
||
int iFd = open(Port,O_RDWR | O_NOCTTY);
|
||
if(iFd < 0) {
|
||
return -1;
|
||
}
|
||
struct termios opt;
|
||
tcgetattr(iFd, &opt);
|
||
cfsetispeed(&opt, speed);
|
||
cfsetospeed(&opt, speed);
|
||
if (tcgetattr(iFd, &opt)<0) {
|
||
return -1;
|
||
}
|
||
opt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
|
||
opt.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
|
||
opt.c_oflag &= ~(OPOST);
|
||
opt.c_cflag &= ~(CSIZE | PARENB | CBAUD);
|
||
opt.c_cflag |= (CS8 | speed);
|
||
opt.c_cc[VMIN] = 255;
|
||
opt.c_cc[VTIME] = 5;
|
||
if (tcsetattr(iFd, TCSANOW, &opt)<0) {
|
||
return -1;
|
||
}
|
||
tcflush(iFd,TCIOFLUSH);
|
||
|
||
return iFd;
|
||
}
|
||
|
||
int write_data(int fd, char *buff, int len)
|
||
{
|
||
int ret;
|
||
char buf[100];
|
||
ret = write(fd, buff, len);
|
||
if (ret < 0) {
|
||
return -1;
|
||
}
|
||
return ret;
|
||
}
|
||
int read_data(int fd, char *buff, int len, int timeout)
|
||
{
|
||
int ret;
|
||
struct timeval to;
|
||
fd_set rdfds;
|
||
|
||
to.tv_sec = 0;
|
||
to.tv_usec = timeout;
|
||
|
||
FD_ZERO(&rdfds);
|
||
FD_SET(fd, &rdfds);
|
||
|
||
if (timeout > 0) {
|
||
ret = select(fd+1, &rdfds, NULL, NULL, &to);
|
||
if (ret <= 0) {
|
||
// printf("zigbee doesn't respond!\n");
|
||
return ret;
|
||
}
|
||
}
|
||
// if (ioctl(fd, FIONREAD, &len) == -1) {
|
||
// return -1;
|
||
// }
|
||
|
||
ret = read(fd,buff,len);
|
||
if(ret < 0) {
|
||
perror("read_data");
|
||
return -1;
|
||
}
|
||
buff[ret] = '\0';
|
||
return ret;
|
||
}
|
||
int ModifyMac(char* buff)
|
||
{
|
||
FILE *fp = fopen("/opt/system/mac", "w");
|
||
fprintf(fp, buff);
|
||
fprintf(fp, "\n");
|
||
fclose(fp);
|
||
system("cp /opt/system/mac /opt/system/macbak");
|
||
system("/opt/Cidn/init.sh");
|
||
}
|
||
void mssleep(unsigned long microseconds)
|
||
{
|
||
|
||
struct timespec req;
|
||
struct timespec rem;
|
||
|
||
req.tv_sec = microseconds / 1000000;
|
||
req.tv_nsec = (microseconds % 1000000) * 1000;
|
||
|
||
nanosleep(&req, &rem);
|
||
}
|
||
std::string GetCurrentTime()
|
||
{
|
||
struct tm nowtime;
|
||
struct timeval tv;
|
||
char time_now[128];
|
||
gettimeofday(&tv, NULL);
|
||
localtime_r(&tv.tv_sec,&nowtime);
|
||
|
||
sprintf(time_now,"%d-%d-%d %d:%d:%d.%03d ",
|
||
nowtime.tm_year+1900,
|
||
nowtime.tm_mon+1,
|
||
nowtime.tm_mday,
|
||
nowtime.tm_hour,
|
||
nowtime.tm_min,
|
||
nowtime.tm_sec,
|
||
(int)(tv.tv_usec/1000)
|
||
);
|
||
|
||
std::string strtime_now = std::string((char*)time_now);
|
||
return strtime_now;
|
||
}
|
||
tm *get_current_date( )
|
||
{
|
||
time_t t = time(NULL);
|
||
struct tm *tm_info = localtime(&t);
|
||
int iyear = 0;int imonth = 0;int day = 0;int hour = 0;
|
||
iyear = tm_info->tm_year + 1900;
|
||
imonth = tm_info->tm_mon + 1;
|
||
day = tm_info->tm_mday;
|
||
hour = tm_info->tm_hour;
|
||
print_info("year = %d,month = %d,day = %d\n",iyear,imonth,day);
|
||
return tm_info;
|
||
}
|
||
int system_custom(const char *cmd, char *buf)
|
||
{
|
||
FILE * fp;
|
||
int res;
|
||
char temp[1024] = {0};
|
||
if (cmd == NULL) {
|
||
return -1;
|
||
}
|
||
|
||
if ((fp = popen(cmd, "r") ) == NULL) {
|
||
print_error("popen error\n");
|
||
return -1;
|
||
} else {
|
||
buf[0] = '\0';
|
||
while (fgets(temp, sizeof(temp), fp)) {
|
||
strcat(buf, temp);
|
||
}
|
||
res = pclose(fp);
|
||
}
|
||
|
||
char *p;
|
||
int pos = 0;
|
||
p = strstr(buf, "\n");
|
||
if(p != NULL){
|
||
pos = p - buf;
|
||
buf[pos] = '\0';
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
|
||
std::string GetDayDate()
|
||
{
|
||
time_t t = time(0);
|
||
char tmp[64];
|
||
strftime(tmp, sizeof(tmp), "%Y-%m-%d",localtime(&t));
|
||
std::string data = std::string((char*)tmp);
|
||
return data;
|
||
}
|
||
|
||
|
||
void GetTimeNet(char* timebuf,int type)
|
||
{
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
int millisecond = tv.tv_usec / 1000;
|
||
if(type == 0){
|
||
sprintf(timebuf, "%ld%03d", tv.tv_sec, millisecond);
|
||
} else {
|
||
sprintf(timebuf, "%ld", tv.tv_sec);
|
||
}
|
||
|
||
}
|
||
// 获取RTC时间
|
||
std::string GetRTC(char* timestamp,int& millisecond)
|
||
{
|
||
time_t rtc_timestamp;
|
||
struct tm tm;
|
||
struct timespec ts;
|
||
char rtcTime[100]={0x00};
|
||
int fd = open("/dev/rtc0", O_RDONLY);
|
||
if (fd < 0) {
|
||
perror("open /dev/rtc0");
|
||
} else {
|
||
struct rtc_time rtc_tm;
|
||
if (ioctl(fd, RTC_RD_TIME, &rtc_tm) < 0) {
|
||
perror("ioctl RTC_RD_TIME");
|
||
} else {
|
||
clock_gettime(CLOCK_REALTIME, &ts);
|
||
millisecond = (int)(ts.tv_nsec / 1000000);
|
||
printf("RTC date/time is %d-%d-%d, %02d:%02d:%02d\n",
|
||
rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, rtc_tm.tm_mday,
|
||
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
|
||
sprintf(rtcTime,"%d-%d-%d, %02d:%02d:%02d",rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, rtc_tm.tm_mday,
|
||
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
|
||
|
||
// 将rtc_time结构体转换为time_t时间戳
|
||
tm.tm_year = rtc_tm.tm_year;
|
||
tm.tm_mon = rtc_tm.tm_mon;
|
||
tm.tm_mday = rtc_tm.tm_mday;
|
||
tm.tm_hour = rtc_tm.tm_hour;
|
||
tm.tm_min = rtc_tm.tm_min;
|
||
tm.tm_sec = rtc_tm.tm_sec;
|
||
tm.tm_isdst = -1; // 不使用夏令时
|
||
|
||
rtc_timestamp = mktime(&tm);
|
||
|
||
if (rtc_timestamp == -1) {
|
||
perror("mktime");
|
||
}
|
||
printf("RTC timestamp is %ld,millisecond = %d\n", rtc_timestamp,millisecond);
|
||
sprintf(timestamp,"%ld",rtc_timestamp);
|
||
}
|
||
}
|
||
close(fd);
|
||
return std::string(rtcTime);
|
||
}
|
||
void GetTime_(char time_buff[],TIME_SIZE len)
|
||
{
|
||
int i = sizeof(time_buff);
|
||
memset(time_buff, 0, i);
|
||
time_t timep;
|
||
time(&timep);
|
||
strcpy(time_buff, ctime(&timep));
|
||
std::string strtemp = time_buff;
|
||
strtemp = strtemp.substr(11, len);
|
||
memset(time_buff, 0, strlen(time_buff));
|
||
strcpy(time_buff, strtemp.c_str());
|
||
}
|
||
|
||
std::string ReadStrByOpt(std::string filename, std::string config, std::string option)
|
||
{
|
||
boost::mutex::scoped_lock lock(s_config_mu);
|
||
Json::Value root;
|
||
Json::Reader reader;
|
||
std::string value;
|
||
std::fstream is;
|
||
is.open(filename.c_str(), std::ios::in);
|
||
if (reader.parse(is, root)) {
|
||
value = root[config]["option"][option].asString();
|
||
}
|
||
is.close();
|
||
return value;
|
||
}
|
||
std::vector <DataNodeUpdate> ReadStrUpdate(std::string filename)
|
||
{
|
||
boost::mutex::scoped_lock lock(s_config_mu);
|
||
Json::Value root,hwVersion;
|
||
Json::Reader reader;
|
||
std::vector <std::string> value;
|
||
std::vector<DataNodeUpdate> vecDataNodeUpdate;
|
||
DataNodeUpdate datanodeUpdate;
|
||
std::fstream is;
|
||
is.open(filename.c_str(), std::ios::in);
|
||
if (reader.parse(is, root)) {
|
||
print_info("root = %d\n",root.size());
|
||
for(int i = 0; i < root.size();i++){
|
||
hwVersion = root[i]["hw_vesion"];
|
||
for(int i = 0; i < hwVersion.size();i++){
|
||
datanodeUpdate.hwVersion.push_back(hwVersion[i].asString());
|
||
}
|
||
datanodeUpdate.strUpdataFileName = root[i]["fw_name"].asString();
|
||
datanodeUpdate.strSoftVersion = root[i]["sf_vesion"].asString();
|
||
print_info("strUpdataFileName = %s,strSoftVersion = %s\n",datanodeUpdate.strUpdataFileName.c_str(),\
|
||
datanodeUpdate.strSoftVersion.c_str());
|
||
vecDataNodeUpdate.push_back(datanodeUpdate);
|
||
}
|
||
|
||
}
|
||
is.close();
|
||
|
||
return vecDataNodeUpdate;
|
||
}
|
||
void ReadStrConfig(std::string filename)
|
||
{
|
||
Json::Value root,gateWay,dataNode;
|
||
std::fstream is;
|
||
Json::Reader reader;
|
||
is.open(filename.c_str(), std::ios::in);
|
||
string zigbeeChannel;
|
||
if (reader.parse(is, root)) {
|
||
gateWay = root["gateWay"];
|
||
dataNode = root["dataNodeArray"];
|
||
print_info("dataNode = %d\n",dataNode.size());
|
||
for(int i = 0; i < dataNode.size();i++){
|
||
string softVersion = dataNode[i]["softVersion"].asString();
|
||
string bpNo = dataNode[i]["bpNo"].asString();
|
||
print_info("bpNo = %s\n",bpNo.c_str());
|
||
string wakeupTime = dataNode[i]["wakeupTime"].asString();
|
||
int viff = dataNode[i]["viff"].asInt();
|
||
string StaticTime = dataNode[i]["StaticTime"].asString();
|
||
int configFlag = dataNode[i]["configFlag"].asInt();
|
||
int rangeValue = dataNode[i]["range"].asInt();
|
||
int updateValue = dataNode[i]["update"].asInt();
|
||
string zigbeeLongAddr = dataNode[i]["zigbeeLongAddr"].asString();
|
||
int accFlag = dataNode[i]["accFlag"].asInt();
|
||
print_info("accFlag = %d\n",accFlag);
|
||
int temTopFlag = dataNode[i]["temTopFlag"].asInt();
|
||
string startBrands = dataNode[i]["startBrands"].asString();
|
||
int waveInterVal = dataNode[i]["waveInterVal"].asInt();
|
||
string zigbeePanId = dataNode[i]["zigbeePanId"].asString();
|
||
int waveTime = dataNode[i]["waveTime"].asInt();
|
||
int zigbeePower = dataNode[i]["zigbeePower"].asInt();
|
||
int zigbeeRetry = dataNode[i]["zigbeeRetry"].asInt();
|
||
string stopBrands = dataNode[i]["stopBrands"].asString();
|
||
int featureInterVal = dataNode[i]["featureInterVal"].asInt();
|
||
int zigbeeFlag = dataNode[i]["zigbeeFlag"].asInt();
|
||
string zigbeeDesAddr = dataNode[i]["zigbeeDesAddr"].asString();
|
||
print_info("zigbeeDesAddr = %s\n",zigbeeDesAddr.c_str());
|
||
int ZigbeeRetryGap = dataNode[i]["zigbeeRetryGap"].asInt();
|
||
string dataNodeNo = dataNode[i]["dataNodeNo"].asString();
|
||
int initFlag = dataNode[i]["initFlag"].asInt();
|
||
string faultFrequency = dataNode[i]["faultFrequency"].asString();
|
||
int temBotFlag = dataNode[i]["temBotFlag"].asInt();
|
||
string bateryV = dataNode[i]["bateryV"].asString();
|
||
int ACCSampleTime = dataNode[i]["ACCSampleTime"].asInt();
|
||
print_info("ACCSampleTime = %d\n",ACCSampleTime);
|
||
string firstPowerTime = dataNode[i]["firstPowerTime"].asString();
|
||
string serialNo = dataNode[i]["serialNo"].asString();
|
||
string zigbeeAddr = dataNode[i]["zigbeeAddr"].asString();
|
||
string productNo = dataNode[i]["productNo"].asString();
|
||
string timeStamp = dataNode[i]["timeStamp"].asString();
|
||
zigbeeChannel = dataNode[i]["zigbeeChannel"].asString();
|
||
int RSSI = dataNode[i]["RSSI"].asInt();
|
||
print_info("RSSI = %d\n",RSSI);
|
||
string hardVersion = dataNode[i]["hardVersion"].asString();
|
||
string envelopeBandPass = dataNode[i]["envelopeBandPass"].asString();
|
||
int samplingRate = dataNode[i]["samplingRate"].asInt();
|
||
string dataNodeName = dataNode[i]["dataNodeName"].asString();
|
||
int status = dataNode[i]["status"].asInt();
|
||
int EquipSta = dataNode[i]["equipSta"].asInt();
|
||
char insertSql[1024] = { 0 };
|
||
char whereCon[100]={0x00};
|
||
sprintf(whereCon,"dataNodeNo = '%s'",dataNodeNo.c_str());
|
||
int rows = sql_ctl->GetTableRows(T_SENSOR_INFO(TNAME), whereCon);
|
||
if(rows > 0)
|
||
continue;
|
||
sprintf(insertSql, "'%s','%s','%d','%d','%d','%d','%d','%d',\
|
||
'%s','%s','%s','%s','%s','%d',\
|
||
'%d','%d','%d','%s','%d','%s',\
|
||
'%s','%d','%d','%d','%s','%d','%s','%s',\
|
||
'%s','%d','%s','%s','%s',\
|
||
'%d','%d','%d','%d','%d','%s','%d','%d','%d','0','0,0'",
|
||
dataNodeNo.c_str(), dataNodeName.c_str(), initFlag, accFlag, zigbeeFlag, temTopFlag, temBotFlag,EquipSta,\
|
||
hardVersion.c_str(), softVersion.c_str(), bpNo.c_str(), serialNo.c_str(), firstPowerTime.c_str(), atoi(wakeupTime.c_str()),\
|
||
atoi(StaticTime.c_str()),waveTime,atoi(bateryV.c_str()),productNo.c_str(),configFlag, startBrands.c_str(), \
|
||
stopBrands.c_str(), featureInterVal, waveInterVal, samplingRate,"",rangeValue, envelopeBandPass.c_str(), faultFrequency.c_str(),\
|
||
zigbeePanId.c_str(), atoi(zigbeeChannel.c_str()), zigbeeAddr.c_str(), zigbeeLongAddr.c_str(), zigbeeDesAddr.c_str(), \
|
||
zigbeePower,zigbeeRetry,ZigbeeRetryGap,ACCSampleTime,status, timeStamp.c_str(),viff,RSSI,updateValue);
|
||
sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
|
||
}
|
||
|
||
/*WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", gateWay["Server"]["localServerIpAddress"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "localServerPort", gateWay["Server"]["localServerPort"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "CommMode", gateWay["Server"]["CommMode"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "UserName", gateWay["Server"]["UserName"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "Password", gateWay["Server"]["Password"].asString());
|
||
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "dnsName", gateWay["Net"]["dnsName"].asString());
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "networkPortStatus", gateWay["Net"]["networkPortStatus"].asString());
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "gateway", gateWay["Net"]["gateway"].asString());
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "subnetMask", gateWay["Net"]["subnetMask"].asString());
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "ipAddress", gateWay["Net"]["ipAddress"].asString());
|
||
WriteStr2Config(NETWORKCONFIG, "Net", "hostName", gateWay["Net"]["hostName"].asString());
|
||
|
||
WriteStr2Config(ZIGBEECONFIG, "Zigbee", "channel", zigbeeChannel);*/
|
||
}else{
|
||
print_info("parse error\n");
|
||
}
|
||
is.close();
|
||
}
|
||
void ImportConfig(std::string filename)
|
||
{
|
||
Json::Value root,gateWay,dataNode;
|
||
std::fstream is;
|
||
Json::Reader reader;
|
||
is.open(filename.c_str(), std::ios::in);
|
||
string zigbeeChannel;
|
||
print_info("filename = %s\n",filename.c_str());
|
||
Json::Value jsSystemSetting,jsonValnet,jsonValnet1,jsSystemInfo,jsonValZigbee,jsondataNodeArray;
|
||
if (reader.parse(is, root)) {
|
||
jsSystemInfo = root["SystemInfo"];
|
||
jsonValZigbee = root["zigbee"];
|
||
jsonValnet1 = root["eth1"];
|
||
jsonValnet = root["eth0"];
|
||
jsSystemSetting = root["ServerConfig"];
|
||
jsondataNodeArray = root["dataNodeArray"];
|
||
char insertSql[1024] = { 0 };
|
||
for(int i = 0; i < jsondataNodeArray.size();i++){
|
||
Json::Value valNode = jsondataNodeArray[i];
|
||
vector<string> vecDataNode;
|
||
for (size_t j = 0; j < valNode.size(); j++)
|
||
{
|
||
vecDataNode.push_back(string(valNode[j].asString()));
|
||
}
|
||
char dataNodeName[100]={0x00};
|
||
hexToAscii(vecDataNode[1].c_str(),dataNodeName);
|
||
sprintf(insertSql, "'%s','%s','%s','%s','%s','%s','%s','%s',\
|
||
'%s','%s','%s','%s','%s','%s',\
|
||
'%s','%s','%s','%s','%s','%s',\
|
||
'%s','%s','%s','%s','%s','%s','%s','%s',\
|
||
'%s','%s','%s','%s','%s',\
|
||
'%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','0,0,0'",
|
||
vecDataNode[0].c_str(),dataNodeName,vecDataNode[2].c_str(),vecDataNode[3].c_str(),vecDataNode[4].c_str(),\
|
||
vecDataNode[5].c_str(),vecDataNode[6].c_str(),vecDataNode[7].c_str(),vecDataNode[8].c_str(),vecDataNode[9].c_str(),\
|
||
vecDataNode[10].c_str(),vecDataNode[11].c_str(),vecDataNode[12].c_str(),vecDataNode[13].c_str(),vecDataNode[14].c_str(),\
|
||
vecDataNode[15].c_str(),vecDataNode[16].c_str(),vecDataNode[17].c_str(),vecDataNode[18].c_str(),vecDataNode[19].c_str(),\
|
||
vecDataNode[20].c_str(),vecDataNode[21].c_str(),vecDataNode[22].c_str(),vecDataNode[23].c_str(),vecDataNode[24].c_str(),\
|
||
vecDataNode[25].c_str(),vecDataNode[26].c_str(),vecDataNode[27].c_str(),vecDataNode[28].c_str(),vecDataNode[29].c_str(),\
|
||
vecDataNode[30].c_str(),vecDataNode[31].c_str(),vecDataNode[32].c_str(),vecDataNode[33].c_str(),vecDataNode[34].c_str(),\
|
||
vecDataNode[35].c_str(),vecDataNode[36].c_str(),vecDataNode[37].c_str(),vecDataNode[38].c_str(),vecDataNode[39].c_str(),\
|
||
vecDataNode[40].c_str(),vecDataNode[41].c_str(),vecDataNode[42].c_str(),vecDataNode[43].c_str(),vecDataNode[44].c_str());
|
||
sql_ctl->InsertData(T_SENSOR_INFO(TNAME), insertSql);
|
||
}
|
||
|
||
WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", jsSystemSetting["ServerIpAddress"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "localServerPort", jsSystemSetting["ServerPort"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "CommMode", /*param.mCommMode*/"2");
|
||
WriteStr2Config(SERVERCONFIG, "Server", "UserName", jsSystemSetting["UserName"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "Password", jsSystemSetting["Password"].asString());
|
||
WriteStr2Config(SERVERCONFIG, "Server", "APN", jsSystemSetting["APN"].asString());
|
||
char APN[100]={0x00};
|
||
string apn = jsSystemSetting["APN"].asString();
|
||
sprintf(APN,"sed -i '15c \t\t\t\t/opt/quectel-CM/quectel-CM -s %s > /dev/null &' /etc/init.d/S95check5G",apn.c_str());
|
||
system(APN);
|
||
|
||
WriteStr2Config(ZIGBEECONFIG, "Zigbee", "channel", jsonValZigbee["channel"].asString());
|
||
WriteStr2Config(ZIGBEECONFIG, "Zigbee", "PanID", jsonValZigbee["PanID"].asString());
|
||
|
||
|
||
WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayVersion", jsSystemInfo["GateWayVersion"].asString());
|
||
WriteStr2Config(SYSTEMINFOFILE, "Version", "SystemVersion", jsSystemInfo["SystemVersion"].asString());
|
||
WriteStr2Config(SYSTEMINFOFILE, "Version", "WebVersion", jsSystemInfo["WebVersion"].asString());
|
||
WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayHwVesion", jsSystemInfo["GateWayHwVesion"].asString());
|
||
WriteStr2Config(SYSTEMINFOFILE, "Version", "GateWayProduct", jsSystemInfo["GateWayProduct"].asString());
|
||
char whereCon[1024] = {0};
|
||
char updateSql[1024] = { 0 };
|
||
sprintf(updateSql, "zigbeePanID = '%s',zigbeeChannel = '%s'",\
|
||
jsonValZigbee["PanID"].asString().c_str(),jsonValZigbee["channel"].asString().c_str());
|
||
sprintf(whereCon, "gatewayMAC='%s'", GlobalConfig::MacAddr_G.c_str());
|
||
sql_ctl->UpdateTableData(T_GATEWAY_INFO(TNAME), updateSql, whereCon);
|
||
}
|
||
system("reboot");
|
||
}
|
||
int UpdataDataNodeConfig(std::string filename)
|
||
{
|
||
vector<DataNodeInfo> vecDataNode; //声明一个字符串向量
|
||
//以读入方式打开文件
|
||
ifstream csv_data(filename, ios::in);
|
||
int iRet = 0;
|
||
if (!csv_data.is_open())
|
||
{
|
||
cout << "Error: opening file fail" << endl;
|
||
return -1;
|
||
}
|
||
else {
|
||
string line;
|
||
|
||
vector<string> words; //声明一个字符串向量
|
||
string word;
|
||
|
||
DataNodeInfo dataNode;
|
||
// ------------读取数据-----------------
|
||
// 读取标题行
|
||
getline(csv_data, line);
|
||
|
||
|
||
istringstream sin;
|
||
// 按行读取数据
|
||
while (getline(csv_data, line))
|
||
{
|
||
words.clear();
|
||
sin.clear();
|
||
sin.str(line);
|
||
while (getline(sin, word, ','))
|
||
{
|
||
cout << word << endl;
|
||
words.push_back(word);
|
||
|
||
}
|
||
string mac = words[1];
|
||
if(mac != GlobalConfig::MacAddr_G){
|
||
iRet = -2;
|
||
break;
|
||
}
|
||
dataNode.ZigbeeLongAddr = words[7];
|
||
dataNode.FeatureInterVal = atoi(words[16].c_str());
|
||
dataNode.WaveInterVal = atoi(words[17].c_str());
|
||
dataNode.SamplingRate = atoi(words[18].c_str());
|
||
print_info("words[17] = %s\n",words[19].c_str());
|
||
|
||
if(words[19].find("8g") != string::npos){
|
||
dataNode.Range = 0;
|
||
}else if(words[19].find("16g") != string::npos){
|
||
dataNode.Range = 1;
|
||
}else if(words[19].find("32g") != string::npos){
|
||
dataNode.Range = 2;
|
||
}else if(words[19].find("64g") != string::npos){
|
||
dataNode.Range = 3;
|
||
}else if(words[19].find("50g") != string::npos){
|
||
dataNode.Range = 0;
|
||
}
|
||
|
||
dataNode.ACCSampleTime = atoi(words[20].c_str());
|
||
dataNode.VIntegralFilterFrequency = atoi(words[21].c_str());
|
||
dataNode.ZigbeePower = atoi(words[22].c_str());
|
||
dataNode.ZigbeeRetry = atoi(words[23].c_str());
|
||
int update = atoi(words[24].c_str());
|
||
if(update == 1)
|
||
vecDataNode.push_back(dataNode);
|
||
}
|
||
csv_data.close();
|
||
}
|
||
|
||
char whereCon[1024] = {0};
|
||
char updateSql[1024] = { 0 };
|
||
if(vecDataNode.size() > 0){
|
||
for(int i = 0; i < vecDataNode.size();i++){
|
||
sprintf(updateSql, "featureInterVal='%d',waveInterVal='%d',range='%d',samplingRate='%d',AccSampleTime = '%d',viff ='%d' ,ZigbeePower = '%d',ZigbeeRetry = '%d',UpdateFlag = 0",
|
||
vecDataNode[i].FeatureInterVal, vecDataNode[i].WaveInterVal,vecDataNode[i].Range,\
|
||
vecDataNode[i].SamplingRate,vecDataNode[i].ACCSampleTime,vecDataNode[i].VIntegralFilterFrequency,\
|
||
vecDataNode[i].ZigbeePower,vecDataNode[i].ZigbeeRetry);
|
||
sprintf(whereCon, "dataNodeNo='%s'", vecDataNode[i].ZigbeeLongAddr.c_str());
|
||
|
||
int iRet = sql_ctl->UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
|
||
memset(whereCon,0x00,sizeof(whereCon));
|
||
memset(updateSql,0x00,sizeof(updateSql));
|
||
}
|
||
iRet = vecDataNode.size() ;
|
||
}else{
|
||
iRet = -3;
|
||
}
|
||
return iRet;
|
||
}
|
||
int WriteStr2Config(std::string filename, std::string config, std::string option, std::string value, bool listable)
|
||
{
|
||
boost::mutex::scoped_lock lock(s_config_mu);
|
||
Json::Value root;
|
||
Json::Value subroot;
|
||
Json::Value list;
|
||
Json::Value op;
|
||
Json::Reader reader;
|
||
std::fstream is;
|
||
is.open(filename.c_str(), std::ios::in);
|
||
if (reader.parse(is, root)) {
|
||
subroot = root[config];
|
||
if (listable)
|
||
list = root[config]["list"];
|
||
else
|
||
op = root[config]["option"];
|
||
}
|
||
is.close();
|
||
|
||
if (listable) {
|
||
list[option].append(Json::Value(value));
|
||
subroot["list"] = list;
|
||
} else {
|
||
op[option] = Json::Value(value);
|
||
subroot["option"] = op;
|
||
}
|
||
root[config] = subroot;
|
||
Json::StyledWriter sw;
|
||
std::ofstream os;
|
||
os.open(filename.c_str());
|
||
os << sw.write(root);
|
||
os.close();
|
||
return 0;
|
||
}
|
||
|
||
|
||
std::string GetLocalMac(const char* net)
|
||
{
|
||
int sock_mac;
|
||
struct ifreq ifr_mac;
|
||
char mac_addr[30];
|
||
sock_mac = socket( AF_INET, SOCK_STREAM, 0 );
|
||
if( sock_mac == -1) {
|
||
perror("create socket falise...mac/n");
|
||
return "";
|
||
}
|
||
memset(&ifr_mac,0,sizeof(ifr_mac));
|
||
strncpy(ifr_mac.ifr_name, net, sizeof(ifr_mac.ifr_name)-1);
|
||
if( (ioctl( sock_mac, SIOCGIFHWADDR, &ifr_mac)) < 0) {
|
||
printf("mac ioctl error/n");
|
||
return "";
|
||
}
|
||
sprintf(mac_addr,"%02x%02x%02x%02x%02x%02x",
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[0],
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[1],
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[2],
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[3],
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[4],
|
||
(unsigned char)ifr_mac.ifr_hwaddr.sa_data[5]);
|
||
printf("local mac:%s /n",mac_addr);
|
||
close( sock_mac );
|
||
LOG_INFO("net : %s,mac:%s\n",net,mac_addr);
|
||
return std::string( mac_addr );
|
||
}
|
||
|
||
std::string GetGwIp_(const char *eth_name)
|
||
{
|
||
int sockfd;
|
||
char gwip_[16] = {0};
|
||
if (-1 == (sockfd = socket(PF_INET, SOCK_STREAM, 0))) {
|
||
perror_info("socket");
|
||
return "";
|
||
}
|
||
struct ifreq req;
|
||
struct sockaddr_in *host;
|
||
|
||
bzero(&req, sizeof(struct ifreq));
|
||
strcpy(req.ifr_name, eth_name);
|
||
//print_info("eth_name = %s\n",eth_name);
|
||
ioctl(sockfd, SIOCGIFADDR, &req);
|
||
host = (struct sockaddr_in*) &req.ifr_addr;
|
||
close(sockfd);
|
||
if (host) {
|
||
strcpy(gwip_, inet_ntoa(host->sin_addr));
|
||
}
|
||
return std::string(gwip_);
|
||
}
|
||
|
||
std::string IpAddrInit()
|
||
{
|
||
const char *WLAN2 = "wlan2";
|
||
const char *WLAN0 = "wlan0";
|
||
const char *ETH0 = "eth0";
|
||
const char *USB0 = "usb0";
|
||
const char *WWAN0 = "wwan0";
|
||
const char *ETH1 = "eth1";
|
||
const char *ETH2 = "eth2";
|
||
std::string strip = "";
|
||
strip = GetGwIp_(WLAN0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(WLAN2);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(ETH1);
|
||
if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(ETH2);
|
||
if (strip.compare("0.0.0.0") != 0 && strip.compare("192.168.188.188") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(ETH0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(USB0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return strip;
|
||
}
|
||
strip = GetGwIp_(WWAN0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return strip;
|
||
}
|
||
//return strip;
|
||
}
|
||
|
||
std::string GetWorkNic()
|
||
{
|
||
const char *WLAN0 = "wlan0";
|
||
const char *ETH0 = "eth0";
|
||
std::string strip;
|
||
strip = GetGwIp_(WLAN0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return std::string(WLAN0);
|
||
}
|
||
strip = GetGwIp_(ETH0);
|
||
if (strip.compare("0.0.0.0") != 0) {
|
||
return std::string(ETH0);
|
||
}
|
||
return std::string(ETH0);
|
||
}
|
||
|
||
std::string& ClearAllSpace(std::string &str)
|
||
{
|
||
int index = 0;
|
||
if( !str.empty()) {
|
||
while( (index = str.find(' ',index)) != string::npos) {
|
||
str.erase(index,1);
|
||
}
|
||
}return str;
|
||
}
|
||
|
||
std::string GetSysInfo()
|
||
{
|
||
const char * getCpuUse = "top -b -n 1 |grep Cpu | cut -d \",\" -f 1 | cut -d \":\" -f 2 |tr -d ' us'";
|
||
char chRes[100] = {0};
|
||
system_custom(getCpuUse, chRes);
|
||
std::string CpuUse = std::string(chRes);
|
||
|
||
const char * getCpuSys = "top -b -n 1 |grep Cpu | cut -d \",\" -f 2 |tr -d ' sy'";
|
||
memset(chRes, 0, 100);
|
||
system_custom(getCpuSys, chRes);
|
||
std::string CpuSys = std::string(chRes);
|
||
|
||
const char * getMemtotal = "cat /proc/meminfo | grep MemTotal | awk -F"":"" '{print $2}' |tr -d ' kB'";
|
||
memset(chRes, 0, 100);
|
||
system_custom(getMemtotal, chRes);
|
||
std::string MemTotal = std::string(chRes);
|
||
|
||
const char * getMemFree = "cat /proc/meminfo | grep MemFree | awk -F"":"" '{print $2}' |tr -d ' kB'";
|
||
memset(chRes, 0, 100);
|
||
system_custom(getMemFree, chRes);
|
||
std::string MemFree = std::string(chRes);
|
||
|
||
float a = atof(MemFree.c_str());
|
||
float b = atof(MemTotal.c_str());
|
||
float c = (1 - a/b)*100;
|
||
|
||
const char * getEmmcInfo = "df -h | grep /dev/root";
|
||
memset(chRes, 0, 100);
|
||
system_custom(getEmmcInfo, chRes);
|
||
std::string Emmcinfo = std::string(chRes);
|
||
std::size_t found = Emmcinfo.find("%");
|
||
if (found != std::string::npos) {
|
||
Emmcinfo = Emmcinfo.substr(found-3, 3);
|
||
}
|
||
Emmcinfo = ClearAllSpace(Emmcinfo);
|
||
|
||
char sysinfo[128] = {0};
|
||
sprintf(sysinfo, "%-13s%-13s%-13s%-13s ", to_string(c).substr(0,4).c_str(), CpuSys.c_str(), CpuUse.c_str(), Emmcinfo.c_str());
|
||
return std::string(sysinfo);
|
||
}
|
||
|
||
void StartWriteToDat()
|
||
{
|
||
print_info("start writetoDat\n");
|
||
}
|
||
|
||
|
||
float * ReSample(int WaveDataLength, int N, int *NewWaveDataLength, std::vector<float> & WaveData)
|
||
{
|
||
if (N <= 0)
|
||
return NULL;
|
||
int NewLength = (int)WaveDataLength / N;
|
||
float * _OutputData = new float[NewLength];
|
||
for(int i = 0; i < NewLength; i++) {
|
||
_OutputData[i] = WaveData[i * N];
|
||
}
|
||
*NewWaveDataLength = NewLength;
|
||
return _OutputData;
|
||
}
|
||
|
||
|
||
int SetTime(unsigned long seconds, int milliseconds)
|
||
{
|
||
struct timeval tv;
|
||
time_t timep = (time_t)seconds;
|
||
tv.tv_sec = timep;
|
||
tv.tv_usec = milliseconds*1000;
|
||
return settimeofday(&tv, NULL);
|
||
}
|
||
|
||
void RemoveConfig()
|
||
{
|
||
char cmd[32] = { 0 };
|
||
sprintf(cmd, "rm /CIDW/config/*");
|
||
system(cmd);
|
||
exit(0);
|
||
}
|
||
|
||
extern void ZoneConfig(std::string zoneid)
|
||
{
|
||
int a = 0;
|
||
std::string zonelists[] = {"UTC+12","UTC+11","UTC+10","UTC+9","UTC+8","UTC+7","UTC+6","UTC+5","UTC+4","UTC+3","UTC+2","UTC+1","UTC+0","UTC-1","UTC-2","UTC-3","UTC-4","UTC-5","UTC-6","UTC-7","UTC-8","UTC-9","UTC-10","UTC-11"};
|
||
for (int i = 0;i < sizeof(zonelists);i++)
|
||
{
|
||
if (zoneid.compare(zonelists[i]) == 0) {
|
||
a = i;
|
||
cout << "a = " << a << endl;
|
||
break;
|
||
}
|
||
}
|
||
switch(a){
|
||
case 0:zoneid = "GMT-12";break;
|
||
case 1:zoneid = "GMT-11";break;
|
||
case 2:zoneid = "GMT-10";break;
|
||
case 3:zoneid = "GMT-9";break;
|
||
case 4:zoneid = "GMT-8";break;
|
||
case 5:zoneid = "GMT-7";break;
|
||
case 6:zoneid = "GMT-6";break;
|
||
case 7:zoneid = "GMT-5";break;
|
||
case 8:zoneid = "GMT-4";break;
|
||
case 9:zoneid = "GMT-3";break;
|
||
case 10:zoneid = "GMT-2";break;
|
||
case 11:zoneid = "GMT-1";break;
|
||
case 12:zoneid = "GMT-0";break;
|
||
case 13:zoneid = "GMT+1";break;
|
||
case 14:zoneid = "GMT+2";break;
|
||
case 15:zoneid = "GMT+3";break;
|
||
case 16:zoneid = "GMT+4";break;
|
||
case 17:zoneid = "GMT+5";break;
|
||
case 18:zoneid = "GMT+6";break;
|
||
case 19:zoneid = "GMT+7";break;
|
||
case 20:zoneid = "GMT+8";break;
|
||
case 21:zoneid = "GMT+9";break;
|
||
case 22:zoneid = "GMT+10";break;
|
||
case 23:zoneid = "GMT+11";break;
|
||
}
|
||
char cmd[256] = { 0 };
|
||
// sprintf(cmd, "rm /etc/localtime");
|
||
// system(cmd);
|
||
memset(cmd, 0, 256);
|
||
sprintf(cmd, "sudo ln -sf /usr/share/zoneinfo/Etc/%s /etc/localtime", zoneid.c_str());
|
||
system(cmd);
|
||
print_info("change timezone success!\n");
|
||
}
|
||
|
||
std::string GetFileContent(std::string filename, int line)
|
||
{
|
||
std::string strFileContent("");
|
||
std::ifstream ifileOut(filename.c_str());
|
||
if(ifileOut.is_open()) { //文件打开
|
||
int i = 1;
|
||
while (!ifileOut.eof()) {
|
||
if (line == 0) {
|
||
std::string strTemp("");
|
||
getline(ifileOut, strTemp);
|
||
strFileContent += strTemp;
|
||
strFileContent += "\r\n";
|
||
}
|
||
if (line != 0) {
|
||
std::string strTemp("");
|
||
getline(ifileOut, strTemp);
|
||
if (line == i) {
|
||
strFileContent = strTemp;
|
||
break;
|
||
}
|
||
}
|
||
++i;
|
||
}
|
||
ifileOut.close();
|
||
}
|
||
return strFileContent;
|
||
}
|
||
|
||
|
||
//BOOST用正则表达式验证ip地址合法
|
||
bool CheckIP(const char *ip)
|
||
{
|
||
boost::xpressive::cregex reg_ip = boost::xpressive::cregex::compile("(25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])[.](25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])[.](25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])[.](25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])");
|
||
return boost::xpressive::regex_match(ip, reg_ip);
|
||
}
|
||
|
||
bool IsValidMask(std::string mask) {
|
||
int iRet = -1;
|
||
|
||
// 将IP地址由“点分十进制”转换成 “二进制整数”
|
||
struct in_addr s;
|
||
iRet = inet_pton(AF_INET, mask.c_str(), &s);
|
||
|
||
// 转换成功返回1，说明是有效的IP地址
|
||
if (iRet == 1) {
|
||
// 从网络字节顺序转换为主机字节顺序
|
||
unsigned int addr = ntohl(s.s_addr);
|
||
|
||
// 转换为二进制字符串
|
||
std::bitset<32> b((int)addr);
|
||
std::string strMask = b.to_string();
|
||
|
||
// 查找二进制字符串中的"01"，如果不存在，说明是有效的子网掩码
|
||
return (strMask.find("01") == std::string::npos);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
// int StatusPub()
|
||
// {
|
||
// long mem_used = -1;
|
||
// long mem_free = -1;
|
||
// long mem_total = -1;
|
||
// long mem_cached = -1;
|
||
// char name1[20];
|
||
// std::string strMemTotal = GetFileContent("/proc/meminfo", 1);
|
||
// std::string strMemFree = GetFileContent("/proc/meminfo", 2);
|
||
// std::string strMemCache = GetFileContent("/proc/meminfo", 5);
|
||
|
||
// sscanf(strMemTotal.c_str(),"%s%ld",name1,&mem_total);
|
||
// sscanf(strMemFree.c_str(),"%s%ld",name1,&mem_free);
|
||
// sscanf(strMemCache.c_str(),"%s%ld",name1,&mem_cached);
|
||
// mem_used = mem_total - mem_free;
|
||
// float fMemRate = 1.0 * mem_used / mem_total;
|
||
|
||
// float fCpuRate;
|
||
// char name[8];
|
||
// double cpu_idle = -1;
|
||
// double cpu_sys = -1;
|
||
// double cpu_user = -1;
|
||
// double cpu_total = -1;
|
||
// double cpu_wait = -1;
|
||
// long int user,nice,sys,idle,iowait,irq,softirq;
|
||
// std::string strCpu1 = GetFileContent("/proc/stat", 1);
|
||
// sscanf(strCpu1.c_str(),"%s%ld%ld%ld%ld%ld%ld%d",name,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);
|
||
// boost::this_thread::sleep(boost::posix_time::seconds(2));
|
||
// long int userNext,niceNext,sysNext,idleNext,iowaitNext,irqNext,softirqNext;
|
||
// std::string strCpu2 = GetFileContent("/proc/stat", 1);
|
||
// sscanf(strCpu2.c_str(),"%s%ld%ld%ld%ld%ld%ld%d",name,&userNext,&niceNext,&sysNext,&idleNext,&iowaitNext,&irqNext,&softirqNext);
|
||
// cpu_total = (userNext+niceNext+sysNext+idleNext+iowaitNext+irqNext+softirqNext) - (user+nice+sys+idle+iowait+irq+softirq);
|
||
// cpu_user = userNext - user;
|
||
// cpu_sys = sysNext - sys;
|
||
// cpu_wait = iowaitNext - iowait;
|
||
// cpu_idle = idleNext - idle;
|
||
// fCpuRate = 1.0*(cpu_total - cpu_idle) / cpu_total;
|
||
// float rateUser = cpu_user *100.0/cpu_total;
|
||
// float rateSys = cpu_sys * 100.0/cpu_total;
|
||
|
||
// if (rateUser > 95) {
|
||
// rateUser = 92;
|
||
// }
|
||
|
||
// /*获取温度 */
|
||
// std::string tempRaw = GetFileContent(TEMPER_RAW, 1);
|
||
// std::string temperOffset = GetFileContent(TEMPER_OFFSET, 1);
|
||
// std::string temperScale = GetFileContent(TEMPER_SCALE, 1);
|
||
// float temperature = ((boost::lexical_cast<float>(tempRaw) + boost::lexical_cast<float>(temperOffset)) * boost::lexical_cast<float>(temperScale))/1000;
|
||
|
||
// char hardName[32];
|
||
// char hardTotal[32];
|
||
// char hardUse[32];
|
||
// char hardFree[32];
|
||
// char rateHardUse[32];
|
||
// const char * getEmmcInfo = "df -h | grep /dev/root";
|
||
// char chRes[100];
|
||
// memset(chRes, 0, 100);
|
||
// system_custom(getEmmcInfo, chRes);
|
||
// sscanf(chRes,"%s%s%s%s%s",hardName, hardTotal, hardUse, hardFree, rateHardUse);
|
||
// std::string strhardTotal(hardTotal);
|
||
// std::string strhardFree(hardFree);
|
||
// std::string strrateHardUse(rateHardUse);
|
||
|
||
// Json::Value jsData;
|
||
// Json::FastWriter fw;
|
||
// jsData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
||
// jsData["cpuUserUse"] = rateUser;
|
||
// jsData["memoryTotal"] = (int)mem_total;
|
||
// jsData["memoryFree"] = (int)mem_free;
|
||
// jsData["memoryUse"] = fMemRate * 100;
|
||
// jsData["hardDiskTotal"] = atof(strhardTotal.substr(0,strhardTotal.length() - 1));
|
||
// jsData["hardDiskFree"] = atof(strhardFree.substr(0,strhardFree.length() - 1));
|
||
|
||
// double total = atof(strhardTotal.substr(0,strhardTotal.length() - 1));
|
||
// double free = atof(strhardFree.substr(0,strhardFree.length() - 1));
|
||
// double use = ((total - free) / free) * 100;
|
||
// // jsData["hardDiskUse"] = atof(strrateHardUse.substr(0,strrateHardUse.length() - 1));
|
||
// jsData["hardDiskUse"] = use;
|
||
// jsData["cpuSystemUse"] = rateSys;
|
||
// jsData["temperature"] = temperature;
|
||
|
||
// char localtimestamp[32] = { 0 };
|
||
// GetTimeNet(localtimestamp, 1);
|
||
// std::string nowTimetamp = std::string(localtimestamp);
|
||
// jsData["updateTime"] = nowTimetamp;
|
||
// std::string strJson = fw.write(jsData);
|
||
// data_publish(strJson.c_str(), GlobalConfig::Topic_G.mPubStatus.c_str());
|
||
|
||
// std::string strInfo = "mem:"+boost::lexical_cast<std::string>(fMemRate * 100) + "tem:"+boost::lexical_cast<std::string>(temperature);
|
||
|
||
|
||
// return 0;
|
||
// }
|
||
|
||
double GetHardDiskFree()
|
||
{
|
||
char hardName[32];
|
||
char hardTotal[32];
|
||
char hardUse[32];
|
||
char hardFree[32];
|
||
char rateHardUse[32];
|
||
const char * getEmmcInfo = "df -h | grep /opt";
|
||
char chRes[100];
|
||
memset(chRes, 0, 100);
|
||
system_custom(getEmmcInfo, chRes);
|
||
sscanf(chRes,"%s%s%s%s%s",hardName, hardTotal, hardUse, hardFree, rateHardUse);
|
||
std::string strhardTotal(hardTotal);
|
||
std::string strhardFree(hardFree);
|
||
std::string strrateHardUse(rateHardUse);
|
||
double freeDisk = atof(strhardFree.substr(0,strhardFree.length() - 1).c_str());
|
||
return freeDisk;
|
||
}
|
||
int getSysIntValue(char *key)
|
||
{
|
||
FILE *fp = NULL;
|
||
int value = 0;
|
||
if(key == NULL)return 0;
|
||
|
||
fp = fopen(key, "r");
|
||
if (fp == NULL) {
|
||
printf("Error: could not open %s file\n",key);
|
||
return 1;
|
||
}
|
||
|
||
fscanf(fp, "%d", &value);
|
||
fclose(fp);fp = NULL;
|
||
return value;
|
||
}
|
||
void GetSysStatusCMT(int& cpu_use,int& mem_use,int& disk_remain,int& cpu_temp)
|
||
{
|
||
long mem_used = -1;
|
||
long mem_free = -1;
|
||
long mem_total = -1;
|
||
long mem_cached = -1;
|
||
char name1[20];
|
||
std::string strMemTotal = GetFileContent("/proc/meminfo", 1);
|
||
std::string strMemFree = GetFileContent("/proc/meminfo", 2);
|
||
std::string strMemCache = GetFileContent("/proc/meminfo", 5);
|
||
|
||
sscanf(strMemTotal.c_str(), "%s%ld", name1, &mem_total);
|
||
sscanf(strMemFree.c_str(), "%s%ld", name1, &mem_free);
|
||
sscanf(strMemCache.c_str(), "%s%ld", name1, &mem_cached);
|
||
mem_used = mem_total - mem_free;
|
||
float fMemRate = 1.0 * mem_used / mem_total;
|
||
|
||
char name[8];
|
||
double cpu_user = -1;
|
||
double cpu_total = -1;
|
||
long int user, nice, sys, idle, iowait, irq, softirq;
|
||
std::string strCpu1 = GetFileContent("/proc/stat", 1);
|
||
sscanf(strCpu1.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &user, &nice, &sys, &idle, &iowait, &irq, &softirq);
|
||
sleep(1);
|
||
long int userNext, niceNext, sysNext, idleNext, iowaitNext, irqNext, softirqNext;
|
||
std::string strCpu2 = GetFileContent("/proc/stat", 1);
|
||
sscanf(strCpu2.c_str(), "%s%ld%ld%ld%ld%ld%ld%ld", name, &userNext, &niceNext, &sysNext, &idleNext, &iowaitNext, &irqNext, &softirqNext);
|
||
cpu_total = (userNext + niceNext + sysNext + idleNext + iowaitNext + irqNext + softirqNext) - (user + nice + sys + idle + iowait + irq + softirq);
|
||
cpu_user = userNext - user;
|
||
float rateUser = cpu_user * 100.0 / cpu_total;
|
||
if (rateUser > 95) {
|
||
rateUser = 92;
|
||
}
|
||
char hardTotal[32];
|
||
char hardFree[32];
|
||
char rateHardUse[32];
|
||
char chRes[100];
|
||
memset(chRes, 0, 100);
|
||
|
||
char hardName[32];
|
||
char hardUse[32];
|
||
const char *getEmmcInfo = "df -h | grep /opt";
|
||
system_custom(getEmmcInfo, chRes);
|
||
sscanf(chRes, "%s%s%s%s%s", hardName, hardTotal, hardUse, hardFree, rateHardUse);
|
||
|
||
std::string strhardTotal(hardTotal);
|
||
std::string strhardFree(hardFree);
|
||
std::string strrateHardUse(rateHardUse);
|
||
|
||
char key[128] = {0};
|
||
memset(key, 0, sizeof(key));
|
||
sprintf(key, "/sys/class/thermal/thermal_zone0/temp");
|
||
int temp = getSysIntValue(key);
|
||
cpu_use = rateUser;
|
||
mem_use = fMemRate * 100;
|
||
disk_remain = atoi(strhardFree.substr(0, strhardFree.length() - 1).c_str());
|
||
cpu_temp = temp / 1000.0;
|
||
}
|
||
std::string GetSysStatus()
|
||
{
|
||
long mem_used = -1;
|
||
long mem_free = -1;
|
||
long mem_total = -1;
|
||
long mem_cached = -1;
|
||
char name1[20];
|
||
std::string strMemTotal = GetFileContent("/proc/meminfo", 1);
|
||
std::string strMemFree = GetFileContent("/proc/meminfo", 2);
|
||
std::string strMemCache = GetFileContent("/proc/meminfo", 5);
|
||
|
||
sscanf(strMemTotal.c_str(),"%s%ld",name1,&mem_total);
|
||
sscanf(strMemFree.c_str(),"%s%ld",name1,&mem_free);
|
||
sscanf(strMemCache.c_str(),"%s%ld",name1,&mem_cached);
|
||
mem_used = mem_total - mem_free;
|
||
float fMemRate = 1.0 * mem_used / mem_total;
|
||
|
||
float fCpuRate;
|
||
char name[8];
|
||
double cpu_idle = -1;
|
||
double cpu_sys = -1;
|
||
double cpu_user = -1;
|
||
double cpu_total = -1;
|
||
double cpu_wait = -1;
|
||
long int user,nice,sys,idle,iowait,irq,softirq;
|
||
std::string strCpu1 = GetFileContent("/proc/stat", 1);
|
||
sscanf(strCpu1.c_str(),"%s%ld%ld%ld%ld%ld%ld%d",name,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);
|
||
sleep(1);
|
||
long int userNext,niceNext,sysNext,idleNext,iowaitNext,irqNext,softirqNext;
|
||
std::string strCpu2 = GetFileContent("/proc/stat", 1);
|
||
sscanf(strCpu2.c_str(),"%s%ld%ld%ld%ld%ld%ld%d",name,&userNext,&niceNext,&sysNext,&idleNext,&iowaitNext,&irqNext,&softirqNext);
|
||
cpu_total = (userNext+niceNext+sysNext+idleNext+iowaitNext+irqNext+softirqNext) - (user+nice+sys+idle+iowait+irq+softirq);
|
||
cpu_user = userNext - user;
|
||
cpu_sys = sysNext - sys;
|
||
cpu_wait = iowaitNext - iowait;
|
||
cpu_idle = idleNext - idle;
|
||
fCpuRate = 1.0*(cpu_total - cpu_idle) / cpu_total;
|
||
float rateUser = cpu_user *100.0/cpu_total;
|
||
float rateSys = cpu_sys * 100.0/cpu_total;
|
||
if (rateUser > 95) {
|
||
rateUser = 92;
|
||
}
|
||
|
||
char hardName[32];
|
||
char hardTotal[32];
|
||
char hardUse[32];
|
||
char hardFree[32];
|
||
char rateHardUse[32];
|
||
const char * getEmmcInfo = "df -h | grep /opt";
|
||
char chRes[100];
|
||
memset(chRes, 0, 100);
|
||
#ifdef IMX6UL_GATEWAY
|
||
system_custom(getEmmcInfo, chRes);
|
||
sscanf(chRes,"%s%s%s%s%s",hardName, hardTotal, hardUse, hardFree, rateHardUse);
|
||
#endif
|
||
#ifdef G2UL_GATEWAY
|
||
getDiskInfo(hardTotal,hardFree);
|
||
#endif
|
||
|
||
std::string strhardTotal(hardTotal);
|
||
std::string strhardFree(hardFree);
|
||
std::string strrateHardUse(rateHardUse);
|
||
|
||
char key[128] = {0};
|
||
memset(key,0,sizeof(key));
|
||
sprintf(key,"/sys/class/thermal/thermal_zone0/temp");
|
||
int temp = getSysIntValue(key);
|
||
|
||
print_info("rateUser = %f,mem_total = %d,mem_free = %d,fMemRate = %f\n",rateUser,mem_total,mem_free,fMemRate);
|
||
Json::Value jsData;
|
||
Json::FastWriter fw;
|
||
jsData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
|
||
jsData["cpuUserUse"] = rateUser;
|
||
jsData["memoryTotal"] = (int)mem_total;
|
||
jsData["memoryFree"] = (int)mem_free;
|
||
jsData["memoryUse"] = fMemRate * 100;
|
||
jsData["hardDiskTotal"] = atof(strhardTotal.substr(0,strhardTotal.length() - 1).c_str());
|
||
jsData["hardDiskFree"] = atof(strhardFree.substr(0,strhardFree.length() - 1).c_str());
|
||
jsData["temperature"] = temp/1000.0;
|
||
jsData["temperatureNR5G"] = atoi(GlobalConfig::NR5GTemp.c_str());
|
||
|
||
double total = atof(strhardTotal.substr(0,strhardTotal.length() - 1).c_str());
|
||
double free = atof(strhardFree.substr(0,strhardFree.length() - 1).c_str());
|
||
double use = ((total - free) / total) * 100;
|
||
// jsData["hardDiskUse"] = atof(strrateHardUse.substr(0,strrateHardUse.length() - 1));
|
||
jsData["hardDiskUse"] = use;
|
||
jsData["cpuSystemUse"] = rateSys;
|
||
|
||
char localtimestamp[32] = { 0 };
|
||
GetTimeNet(localtimestamp, 1);
|
||
std::string nowTimetamp = std::string(localtimestamp);
|
||
jsData["updateTime"] = nowTimetamp;
|
||
std::string strJson = fw.write(jsData);
|
||
return strJson;
|
||
}
|
||
// 将单个16进制字符转换为对应的字节值
|
||
unsigned char hexCharToByte(char c) {
|
||
if (c >= '0' && c <= '9') return c - '0';
|
||
if (c >= 'A' && c <= 'F') return c - 'A' + 10;
|
||
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
|
||
return 0; // 对于无效的字符，返回0
|
||
}
|
||
|
||
// 将16进制字符串转换为字节数组
|
||
int hexStringToBytes(const char* hexStr, unsigned char* bytes, size_t bytesSize) {
|
||
size_t hexLen = strlen(hexStr);
|
||
if (hexLen % 2 != 0) {
|
||
return -1; // Hex字符串长度应该是偶数
|
||
}
|
||
if (bytesSize < hexLen / 2) {
|
||
return -1; // 字节数组的大小不足以容纳转换后的字节
|
||
}
|
||
|
||
for (size_t i = 0; i < hexLen; i += 2) {
|
||
unsigned char highNibble = hexCharToByte(hexStr[i]);
|
||
unsigned char lowNibble = hexCharToByte(hexStr[i + 1]);
|
||
bytes[i / 2] = (highNibble << 4) | lowNibble;
|
||
}
|
||
|
||
return 0; // 成功
|
||
}
|
||
void stringToHex(const char* str, char* hexStr) {
|
||
while (*str) {
|
||
sprintf(hexStr, "%02x", (unsigned char)*str);
|
||
hexStr += 2;
|
||
str++;
|
||
}
|
||
*hexStr = '\0';
|
||
}
|
||
void hexToAscii(const char* hexStr, char* asciiStr) {
|
||
int len = strlen(hexStr);
|
||
int i, j = 0;
|
||
|
||
for (i = 0; i < len; i += 2) {
|
||
// 读取两个字符并将其转换为整数
|
||
int byte;
|
||
sscanf(&hexStr[i], "%2x", &byte);
|
||
// 将整数转换为对应的ASCII字符
|
||
asciiStr[j++] = (char)byte;
|
||
}
|
||
// 添加字符串结束符
|
||
asciiStr[j] = '\0';
|
||
}
|
||
unsigned char ch2hex(char ch)
|
||
{
|
||
static const char *hex="0123456789ABCDEF";
|
||
for(unsigned char i=0;i!=16;++i)
|
||
if(ch==hex[i])
|
||
return i;
|
||
return 0;
|
||
}
|
||
string tohex(const string& str)
|
||
{
|
||
string ret;
|
||
static const char *hex="0123456789ABCDEF";
|
||
for(int i=0;i!=str.size();++i)
|
||
{
|
||
ret.push_back(hex[(str[i]>>4)&0xf]);
|
||
ret.push_back( hex[str[i]&0xf]);
|
||
}
|
||
return ret;
|
||
}
|
||
char* solve(char *dest,const char *src)
|
||
{
|
||
int i=0;
|
||
int cnt=0;
|
||
unsigned char*d=(unsigned char*)dest;
|
||
while(*src)
|
||
{
|
||
if(i&1)
|
||
{
|
||
d[cnt++]|=ch2hex(*src);
|
||
}
|
||
else
|
||
{
|
||
d[cnt]=ch2hex(*src)<<4;
|
||
}
|
||
src++;
|
||
i++;
|
||
}
|
||
return dest;
|
||
}
|
||
|
||
|
||
void swap(char *data)
|
||
{
|
||
int tmp;
|
||
tmp = data[1];
|
||
data[1] = data[0];
|
||
data[0] = tmp;
|
||
}
|
||
int OpenWatchDog()
|
||
{
|
||
int fd = -1;
|
||
InitGpio(GlobalConfig::GPIO_G.hardWatchDog,1);
|
||
gpio_set(GlobalConfig::GPIO_G.hardWatchDog,1);//高电平有效
|
||
if(0 >(fd = open("/dev/watchdog",O_WRONLY))){
|
||
print_info("Failed:Open /dev/watchdog");
|
||
}
|
||
return fd;
|
||
|
||
}
|
||
int WriteWatchDog(int fd)
|
||
{
|
||
if(1 != write(fd,"0",1)){
|
||
print_info("Failed:feeding watchdog");
|
||
}
|
||
}
|
||
int CloseWatchDog(int fd)
|
||
{
|
||
close(fd);
|
||
}
|
||
string TrimStringLeft(const char* szData, const char* szTargets)
|
||
{
|
||
string strData = szData;
|
||
int nPos = 0;
|
||
nPos = strData.find(szTargets);
|
||
while (nPos == 0)
|
||
{
|
||
strData.erase(nPos, 1);
|
||
nPos = strData.find(szTargets);
|
||
}
|
||
return strData;
|
||
}
|
||
|
||
string TrimStringRight(const char* szData, const char* szTargets)
|
||
{
|
||
string strData = szData;
|
||
int nPos = 0;
|
||
nPos = strData.rfind(szTargets);
|
||
while ((nPos == (int)(strData.size() - 1)) && (nPos >= 0))
|
||
{
|
||
strData.erase(nPos, 1);
|
||
nPos = strData.rfind(szTargets);
|
||
}
|
||
return strData;
|
||
}
|
||
string GetOneContent(const char* szData, int nRow, const char* szSeparate)
|
||
{
|
||
string strParam = "";
|
||
string strTemp = szData;
|
||
int nFirstPos = -1;
|
||
for (int i = 0; i < nRow; i++)
|
||
{
|
||
nFirstPos = strTemp.find(szSeparate, nFirstPos + 1);
|
||
if (nFirstPos < 0)
|
||
return strParam.c_str();
|
||
}
|
||
|
||
int nSecondPos = strTemp.find(szSeparate, nFirstPos + 1);
|
||
if (nSecondPos < 0)
|
||
{
|
||
strParam = strTemp.substr(nFirstPos + 1);
|
||
}
|
||
else
|
||
{
|
||
strParam = strTemp.substr(nFirstPos + 1, nSecondPos - nFirstPos - 1);
|
||
}
|
||
|
||
{
|
||
strParam = TrimStringRight(strParam.c_str(), " ");
|
||
strParam = TrimStringLeft(strParam.c_str(), " ");
|
||
}
|
||
return strParam.c_str();
|
||
}
|
||
int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
|
||
{
|
||
struct termios newtio,oldtio;
|
||
if ( tcgetattr( fd,&oldtio) != 0) { //检测串口是否可用
|
||
perror("SetupSerial 1");
|
||
return -1;
|
||
}
|
||
bzero( &newtio, sizeof( newtio ) );
|
||
newtio.c_cflag |= CLOCAL | CREAD;
|
||
newtio.c_cflag &= ~CSIZE;
|
||
|
||
switch( nBits ) //设置数据位
|
||
{
|
||
case 7:
|
||
newtio.c_cflag |= CS7;
|
||
break;
|
||
case 8:
|
||
newtio.c_cflag |= CS8;
|
||
break;
|
||
}
|
||
|
||
switch( nEvent )//设置检验位
|
||
{
|
||
case 'O':
|
||
newtio.c_cflag |= PARENB;
|
||
newtio.c_cflag |= PARODD;
|
||
newtio.c_iflag |= (INPCK | ISTRIP);
|
||
break;
|
||
case 'E':
|
||
newtio.c_iflag |= (INPCK | ISTRIP);
|
||
newtio.c_cflag |= PARENB;
|
||
newtio.c_cflag &= ~PARODD;
|
||
break;
|
||
case 'N':
|
||
newtio.c_cflag &= ~PARENB;
|
||
break;
|
||
}
|
||
|
||
switch( nSpeed ) //设置波特率
|
||
{
|
||
case 2400:
|
||
cfsetispeed(&newtio, B2400);
|
||
cfsetospeed(&newtio, B2400);
|
||
break;
|
||
case 4800:
|
||
cfsetispeed(&newtio, B4800);
|
||
cfsetospeed(&newtio, B4800);
|
||
break;
|
||
case 9600:
|
||
cfsetispeed(&newtio, B9600);
|
||
cfsetospeed(&newtio, B9600);
|
||
break;
|
||
case 115200:
|
||
cfsetispeed(&newtio, B115200);
|
||
cfsetospeed(&newtio, B115200);
|
||
break;
|
||
case 460800:
|
||
cfsetispeed(&newtio, B460800);
|
||
cfsetospeed(&newtio, B460800);
|
||
break;
|
||
default:
|
||
cfsetispeed(&newtio, B9600);
|
||
cfsetospeed(&newtio, B9600);
|
||
break;
|
||
}
|
||
if( nStop == 1 )//设置停止位
|
||
newtio.c_cflag &= ~CSTOPB;
|
||
else if ( nStop == 2 )
|
||
newtio.c_cflag |= CSTOPB;
|
||
newtio.c_cc[VTIME] = 0;
|
||
newtio.c_cc[VMIN] = 0;
|
||
tcflush(fd,TCIFLUSH);
|
||
if((tcsetattr(fd,TCSANOW,&newtio))!=0) //设置串口参数
|
||
{
|
||
perror("com set error");
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int getcsq()
|
||
{
|
||
/*int fd = config_uart("/dev/ttyUSB2",115200);
|
||
print_info("fd = %d\n",fd);
|
||
if(fd < 0){
|
||
printf("config_uart error\n");
|
||
}
|
||
int len = write_data(fd,"AT+QENG=\"servingcell\"\r\n",27);
|
||
|
||
sleep(1);
|
||
unsigned char rbuf[128]={0x00};
|
||
len = read_data(fd,(char*)rbuf,100,10);
|
||
if(len < 0) {
|
||
print_info("Can't get /dev/ttyUSBx Serial Port data!\n");
|
||
}
|
||
print_info("rbuf = %s\n",(char*)rbuf);
|
||
close(fd);*/
|
||
|
||
int ret = 0;
|
||
char csq[128] = {0};
|
||
|
||
int fd = 0, sig = 0;
|
||
|
||
if((fd = open("/dev/ttyUSB2", O_RDWR | O_NOCTTY | O_NDELAY))<0){
|
||
|
||
//LOG_ERROR("open %s is FAILED\n\n","/dev/ttyUSB2");
|
||
}
|
||
else{
|
||
set_opt(fd, 9600, 8, 'N', 1);
|
||
}
|
||
set_opt(fd, 115200, 8, 'N', 1);
|
||
|
||
//write(fd,"AT+QENG=\"servingcell\"\r\n",27);//开启定位
|
||
write(fd,"AT+CSQ",6);
|
||
sleep(1);
|
||
unsigned char rbuf[128]={0x00};
|
||
int len = read(fd, rbuf, sizeof(rbuf)); // 在串口读入字符串
|
||
|
||
print_info("rbuf = %s,len = %d\n",rbuf,len);
|
||
sleep(1);
|
||
if(len < 0) {
|
||
print_info("Can't get /dev/ttyUSBx Serial Port data!\n");
|
||
}
|
||
|
||
const char *str2 = "+QENG: ";
|
||
char *pdata = strstr((char*)rbuf, str2);
|
||
if(pdata)
|
||
strncpy(csq, pdata+7, sizeof(csq));
|
||
else {
|
||
return -1;
|
||
}
|
||
//printf("SIM-CSQ: %s\n", csq);
|
||
GlobalConfig::NetStatus = GetOneContent(csq,1,",");
|
||
string signal = GetOneContent(csq,13,",");
|
||
GlobalConfig::NetSignal = atoi(signal.c_str());
|
||
print_info("NetStatus = %s,NetSignal = %d\n",GlobalConfig::NetStatus.c_str(),GlobalConfig::NetSignal);
|
||
// ret = csq
|
||
close(fd);
|
||
/*if(csq[0] == ',')
|
||
ret = 0;
|
||
else if(csq[1] == ',')
|
||
ret = (int)csq[0] - '0';
|
||
else if(csq[2] == ',')
|
||
ret = ((int)csq[0] - '0')*10 + (int)csq[1] - '0';
|
||
|
||
print_info("sig = %d\n", ret);*/
|
||
return atoi(signal.c_str());
|
||
|
||
/*
|
||
int level;
|
||
char *str = NULL;
|
||
if (strstr(csq, "99,") || strstr(csq, "199,") ){
|
||
printf("No signal ..\n");
|
||
level = 0;
|
||
}
|
||
else {
|
||
char rssi_str[4];
|
||
int rssi;
|
||
memset(rssi_str, 0, sizeof(rssi_str));
|
||
if (*(csq+2) == ',') {
|
||
rssi_str[0] = *(csq+0+0);
|
||
rssi_str[1] = *(csq+0+1);
|
||
}
|
||
else if (isdigit(*(csq+2)) && isdigit(*(csq+3) == ',')) {
|
||
rssi_str[0] = *(csq+0+0);
|
||
rssi_str[1] = *(csq+0+1);
|
||
rssi_str[2] = *(csq+0+2);
|
||
}
|
||
rssi = atoi(rssi_str);
|
||
|
||
printf("rssi = %d\n", rssi);
|
||
|
||
int signal = -113 + (2 * rssi);
|
||
if(signal > -91)
|
||
level = 5;
|
||
else if (signal <= -91 && signal > -101)
|
||
level = 4;
|
||
else if(signal <= -101 && signal > -103)
|
||
level = 3;
|
||
else if(signal <= -103 && signal > -107)
|
||
level = 2;
|
||
else if(signal <= -107 && signal > -113)
|
||
level = 1;
|
||
else
|
||
level = 0;
|
||
printf("level = %d, signal: %d\n", rssi, signal);
|
||
}
|
||
*/
|
||
|
||
}
|
||
void IniReadValue(char* section, char* key, char* val, const char* file)
|
||
{
|
||
FILE* fp;
|
||
int i = 0;
|
||
int lineContentLen = 0;
|
||
int position = 0;
|
||
char lineContent[LINE_CONTENT_MAX_LEN];
|
||
bool bFoundSection = false;
|
||
bool bFoundKey = false;
|
||
fp = fopen(file, "r");
|
||
if(fp == NULL)
|
||
{
|
||
printf("%s: Opent file %s failed.\n", __FILE__, file);
|
||
return;
|
||
}
|
||
while(feof(fp) == 0)
|
||
{
|
||
memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
|
||
fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
|
||
if((lineContent[0] == ';') || (lineContent[0] == '\0') || (lineContent[0] == '\r') || (lineContent[0] == '\n'))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//check section
|
||
if(strncmp(lineContent, section, strlen(section)) == 0)
|
||
{
|
||
bFoundSection = true;
|
||
//printf("Found section = %s\n", lineContent);
|
||
while(feof(fp) == 0)
|
||
{
|
||
memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
|
||
fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
|
||
//check key
|
||
if(strncmp(lineContent, key, strlen(key)) == 0)
|
||
{
|
||
bFoundKey = true;
|
||
lineContentLen = strlen(lineContent);
|
||
//find value
|
||
for(i = strlen(key); i < lineContentLen; i++)
|
||
{
|
||
if(lineContent[i] == '=')
|
||
{
|
||
position = i + 1;
|
||
break;
|
||
}
|
||
}
|
||
if(i >= lineContentLen) break;
|
||
strncpy(val, lineContent + position, strlen(lineContent + position));
|
||
lineContentLen = strlen(val);
|
||
for(i = 0; i < lineContentLen; i++)
|
||
{
|
||
if((lineContent[i] == '\0') || (lineContent[i] == '\r') || (lineContent[i] == '\n'))
|
||
{
|
||
val[i] = '\0';
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(lineContent[0] == '[')
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if(!bFoundSection){printf("No section = %s\n", section);}
|
||
else if(!bFoundKey){printf("No key = %s\n", key);}
|
||
fclose(fp);
|
||
}
|
||
|
||
int readStringValue(const char* section, char* key, char* val, const char* file)
|
||
{
|
||
char sect[SECTION_MAX_LEN];
|
||
//printf("section = %s, key = %s, file = %s\n", section, key, file);
|
||
if (section == NULL || key == NULL || val == NULL || file == NULL)
|
||
{
|
||
printf("%s: input parameter(s) is NULL!\n", __func__);
|
||
return -1;
|
||
}
|
||
|
||
memset(sect, 0, SECTION_MAX_LEN);
|
||
sprintf(sect, "[%s]", section);
|
||
//printf("reading value...\n");
|
||
IniReadValue(sect, key, val, file);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int readIntValue(const char* section, char* key, const char* file)
|
||
{
|
||
char strValue[STRVALUE_MAX_LEN];
|
||
memset(strValue, '\0', STRVALUE_MAX_LEN);
|
||
if(readStringValue(section, key, strValue, file) != 0)
|
||
{
|
||
printf("%s: error", __func__);
|
||
return 0;
|
||
}
|
||
return(atoi(strValue));
|
||
}
|
||
|
||
void IniWriteValue(const char* section, char* key, char* val, const char* file)
|
||
{
|
||
FILE* fp;
|
||
int i = 0, n = 0, err = 0;
|
||
int lineContentLen = 0;
|
||
int position = 0;
|
||
char lineContent[LINE_CONTENT_MAX_LEN];
|
||
char strWrite[LINE_CONTENT_MAX_LEN];
|
||
bool bFoundSection = false;
|
||
bool bFoundKey = false;
|
||
|
||
memset(lineContent, '\0', LINE_CONTENT_MAX_LEN);
|
||
memset(strWrite, '\0', LINE_CONTENT_MAX_LEN);
|
||
n = sprintf(strWrite, "%s=%s\n", key, val);
|
||
fp = fopen(file, "r+");
|
||
if(fp == NULL)
|
||
{
|
||
printf("%s: Opent file %s failed.\n", __FILE__, file);
|
||
return;
|
||
}
|
||
while(feof(fp) == 0)
|
||
{
|
||
memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
|
||
fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
|
||
if((lineContent[0] == ';') || (lineContent[0] == '\0') || (lineContent[0] == '\r') || (lineContent[0] == '\n'))
|
||
{
|
||
continue;
|
||
}
|
||
//check section
|
||
if(strncmp(lineContent, section, strlen(section)) == 0)
|
||
{
|
||
bFoundSection = true;
|
||
while(feof(fp) == 0)
|
||
{
|
||
memset(lineContent, 0, LINE_CONTENT_MAX_LEN);
|
||
fgets(lineContent, LINE_CONTENT_MAX_LEN, fp);
|
||
//check key
|
||
if(strncmp(lineContent, key, strlen(key)) == 0)
|
||
{
|
||
bFoundKey = true;
|
||
printf("%s: %s=%s\n", __func__, key, val);
|
||
fseek(fp, (0-strlen(lineContent)),SEEK_CUR);
|
||
err = fputs(strWrite, fp);
|
||
if(err < 0){printf("%s err.\n", __func__);}
|
||
break;
|
||
}
|
||
else if(lineContent[0] == '[')
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if(!bFoundSection){printf("No section = %s\n", section);}
|
||
else if(!bFoundKey){printf("No key = %s\n", key);}
|
||
fclose(fp);
|
||
}
|
||
|
||
int writeStringVlaue(const char* section, char* key, char* val, const char* file)
|
||
{
|
||
char sect[SECTION_MAX_LEN];
|
||
//printf("section = %s, key = %s, file = %s\n", section, key, file);
|
||
if (section == NULL || key == NULL || val == NULL || file == NULL)
|
||
{
|
||
printf("%s: input parameter(s) is NULL!\n", __func__);
|
||
return -1;
|
||
}
|
||
memset(sect, '\0', SECTION_MAX_LEN);
|
||
sprintf(sect, "[%s]", section);
|
||
IniWriteValue(sect, key, val, file);
|
||
}
|
||
|
||
int writeIntValue(const char* section, char* key, int val, const char* file)
|
||
{
|
||
char strValue[STRVALUE_MAX_LEN];
|
||
memset(strValue, '\0', STRVALUE_MAX_LEN);
|
||
sprintf(strValue, "%d", val);
|
||
|
||
writeStringVlaue(section, key, strValue, file);
|
||
}
|
||
|
||
int getDiskInfo(char* diskTotal,char* diskFree)
|
||
{
|
||
DISK diskInfo;
|
||
// pDISK pDiskInfo;
|
||
// char dpath[100]="/";//设置默认位置
|
||
// int flag=0;
|
||
// if(NULL!=path)
|
||
// {
|
||
// strcpy(dpath,path);
|
||
// }
|
||
// if(-1==(flag=statfs("/tmp",pDiskInfo)))//获取包含磁盘空间信息的结构体
|
||
// {
|
||
// perror("getDiskInfo statfs fail");
|
||
// return 0;
|
||
// }
|
||
// unsigned long long total=0,avail=0,free=0,blockSize=0;
|
||
//
|
||
// blockSize=pDiskInfo->f_bsize;//每块包含字节大小
|
||
// total=pDiskInfo->f_blocks*blockSize;//磁盘总空间
|
||
// avail=pDiskInfo->f_bavail*blockSize;//非超级用户可用空间
|
||
// free=pDiskInfo->f_bfree*blockSize;//磁盘所有剩余空间
|
||
// //字符串转换
|
||
// char diskTotal[30],diskAvail[30],diskFree[30];
|
||
// flag=sprintf(diskTotal,"%llu",total>>20);
|
||
// flag=sprintf(diskAvail,"%llu",avail>>20);
|
||
// flag=sprintf(diskFree,"%llu",free>>20);
|
||
// print_info("diskTotal = %s,diskAvail = %s,diskFree = %s\n",diskTotal,diskAvail,diskFree);
|
||
// if(-1==flag)
|
||
// {
|
||
// return 0;
|
||
// }
|
||
/* 1.获取/home/下面的总容量 */
|
||
statfs("/", &diskInfo);
|
||
unsigned long long blocksize = diskInfo.f_bsize; //每个block里包含的字节数
|
||
unsigned long long totalsize = blocksize * diskInfo.f_blocks;//总的字节数，f_blocks为block的数目
|
||
//printf("Total_size=%llu B =%llu KB =%llu MB = %llu GB\n",\
|
||
totalsize,totalsize>>10,totalsize>>20, totalsize>>30);
|
||
|
||
/* 2.获取一下剩余空间和可用空间的大小 */
|
||
unsigned long long freeDisk = diskInfo.f_bfree * blocksize; //剩余空间的大小
|
||
unsigned long long availableDisk = diskInfo.f_bavail * blocksize; //可用空间大小
|
||
//printf("Disk_free=%llu MB =%llu GB Disk_available=%llu MB = %llu GB\n",\
|
||
freeDisk>>20,freeDisk>>30,availableDisk>>20, availableDisk>>30);
|
||
sprintf(diskTotal,"%llu",totalsize>>20);
|
||
sprintf(diskFree,"%llu",freeDisk>>20);
|
||
return 1;
|
||
}
|
||
bool NetIsOk()
|
||
{
|
||
|
||
double rtt;
|
||
struct hostent *host;
|
||
struct protoent *protocol;
|
||
int i,recv_status;
|
||
|
||
#ifdef _USE_DNS //如果定义该宏，则可以使用域名进行判断网络连接，例如www.baidu.com
|
||
/* 设置目的地址信息 */
|
||
char hostname[32];
|
||
sprintf(hostname,"%s","www.baidu.com")
|
||
bzero(&dest_addr, sizeof(dest_addr));
|
||
dest_addr.sin_family = AF_INET;
|
||
|
||
if((host=gethostbyname(hostname))==NULL)
|
||
{
|
||
LOG_ERROR("[NetStatus] error : Can't get serverhost info!\n");
|
||
return false;
|
||
}
|
||
|
||
bcopy((char*)host->h_addr,(char*)&dest_addr.sin_addr,host->h_length);
|
||
#else //如果不使用域名，则只能用ip地址直接发送icmp包，
|
||
dest_addr.sin_addr.s_addr = inet_addr(GlobalConfig::ServerIP.c_str());
|
||
#endif
|
||
|
||
|
||
if ((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0)
|
||
{ /* 创建原始ICMP套接字 */
|
||
LOG_ERROR("[NetStatus] error : socket %d\n",sockfd);
|
||
return false;
|
||
}
|
||
|
||
int iFlag;
|
||
if(iFlag = fcntl(sockfd,F_GETFL,0)<0)
|
||
{
|
||
LOG_ERROR("[NetStatus] error : fcntl(sockfd,F_GETFL,0)");
|
||
_CloseSocket();
|
||
return false;
|
||
}
|
||
iFlag |= O_NONBLOCK;
|
||
if(iFlag = fcntl(sockfd,F_SETFL,iFlag)<0)
|
||
{
|
||
LOG_ERROR("[NetStatus] error : fcntl(sockfd,F_SETFL,iFlag )");
|
||
_CloseSocket();
|
||
return false;
|
||
}
|
||
print_info("================NetIsOk check=============\n");
|
||
pid=getpid();
|
||
for(i=0;i<MAX_NO_PACKETS;i++)
|
||
{
|
||
|
||
if(send_packet(i,sendpacket)<0)
|
||
{
|
||
LOG_ERROR("[NetStatus] error : send_packet");
|
||
_CloseSocket();
|
||
return false;
|
||
}
|
||
|
||
if(recv_packet(i,recvpacket)>0)
|
||
{
|
||
_CloseSocket();
|
||
return true;
|
||
}
|
||
|
||
}
|
||
_CloseSocket();
|
||
return false;
|
||
}
|
||
|
||
|
||
|
||
int send_packet(int pkt_no,char *sendpacket)
|
||
{
|
||
int packetsize;
|
||
packetsize=pack(pkt_no,sendpacket);
|
||
gettimeofday(&tvsend,NULL);
|
||
print_info("================NetIsOk send_packet=============\n");
|
||
if(sendto(sockfd,sendpacket,packetsize,0,(struct sockaddr *)&dest_addr,sizeof(dest_addr) )<0)
|
||
{
|
||
LOG_ERROR("[NetStatus] error : sendto error");
|
||
return -1;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
int pack(int pkt_no,char*sendpacket)
|
||
{
|
||
int i,packsize;
|
||
struct icmp *icmp;
|
||
struct timeval *tval;
|
||
icmp=(struct icmp*)sendpacket;
|
||
icmp->icmp_type=ICMP_ECHO; //设置类型为ICMP请求报文
|
||
icmp->icmp_code=0;
|
||
icmp->icmp_cksum=0;
|
||
icmp->icmp_seq=pkt_no;
|
||
icmp->icmp_id=pid; //设置当前进程ID为ICMP标示符
|
||
packsize=ICMP_HEADSIZE+sizeof(struct timeval);
|
||
tval= (struct timeval *)icmp->icmp_data;
|
||
gettimeofday(tval,NULL);
|
||
icmp->icmp_cksum=cal_chksum( (unsigned short *)icmp,packsize);
|
||
return packsize;
|
||
}
|
||
|
||
|
||
unsigned short cal_chksum(unsigned short *addr,int len)
|
||
{
|
||
int nleft=len;
|
||
int sum=0;
|
||
unsigned short *w=addr;
|
||
unsigned short answer=0;
|
||
while(nleft>1) //把ICMP报头二进制数据以2字节为单位累加起来
|
||
{
|
||
sum+=*w++;
|
||
nleft-=2;
|
||
}
|
||
if( nleft==1) //若ICMP报头为奇数个字节,会剩下最后一字节.把最后一个字节视为一个2字节数据的高字节,这个2字节数据的低字节为0,继续累加
|
||
{
|
||
*(unsigned char *)(&answer)=*(unsigned char *)w;
|
||
sum+=answer;
|
||
}
|
||
sum=(sum>>16)+(sum&0xffff);
|
||
sum+=(sum>>16);
|
||
answer=~sum;
|
||
return answer;
|
||
}
|
||
|
||
|
||
int recv_packet(int pkt_no,char *recvpacket)
|
||
{
|
||
int n;
|
||
fd_set rfds;
|
||
FD_ZERO(&rfds);
|
||
FD_SET(sockfd,&rfds);
|
||
signal(SIGALRM,timeout);
|
||
unsigned int fromlen=sizeof(recv_addr);
|
||
alarm(MAX_WAIT_TIME);
|
||
print_info("================NetIsOk recv_packet=============\n");
|
||
while(1)
|
||
{
|
||
select(sockfd+1, &rfds, NULL, NULL, NULL);
|
||
if (FD_ISSET(sockfd,&rfds))
|
||
{
|
||
if( (n=recvfrom(sockfd,recvpacket,PACKET_SIZE,0,(struct sockaddr *)&recv_addr,&fromlen)) <0)
|
||
{
|
||
print_info("================NetIsOk recvfrom=============errno = %d\n",errno);
|
||
if(errno==EINTR){
|
||
return -1;
|
||
LOG_ERROR("recvfrom error");
|
||
return -2;
|
||
}
|
||
}
|
||
}
|
||
gettimeofday(&tvrecv,NULL);
|
||
if(unpack(pkt_no,recvpacket,n)==-1)
|
||
continue;
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
int unpack(int cur_seq,char *buf,int len)
|
||
{
|
||
int iphdrlen;
|
||
struct ip *ip;
|
||
struct icmp *icmp;
|
||
ip=(struct ip *)buf;
|
||
iphdrlen=ip->ip_hl<<2; //求ip报头长度,即ip报头的长度标志乘4
|
||
icmp=(struct icmp *)(buf+iphdrlen); //越过ip报头,指向ICMP报头
|
||
len-=iphdrlen; //ICMP报头及ICMP数据报的总长度
|
||
if( len<8)
|
||
return -1;
|
||
if( (icmp->icmp_type==ICMP_ECHOREPLY) && (icmp->icmp_id==pid) && (icmp->icmp_seq==cur_seq))
|
||
return 0;
|
||
else return -1;
|
||
}
|
||
|
||
|
||
void timeout(int signo)
|
||
{
|
||
LOG_ERROR("Request Timed Out\n");
|
||
_CloseSocket();
|
||
}
|
||
|
||
void tv_sub(struct timeval *out,struct timeval *in)
|
||
{
|
||
if( (out->tv_usec-=in->tv_usec)<0)
|
||
{
|
||
--out->tv_sec;
|
||
out->tv_usec+=1000000;
|
||
}
|
||
out->tv_sec-=in->tv_sec;
|
||
}
|
||
|
||
void _CloseSocket()
|
||
{
|
||
close(sockfd);
|
||
sockfd = 0;
|
||
}
|
||
|
||
int socketHeart(const char* pSendData)
|
||
{
|
||
print_info("socketHeart\n");
|
||
int sockfd; // Socket文件描述符
|
||
struct sockaddr_in serverAddr{}; // Server地址结构体
|
||
|
||
// 创建Socket
|
||
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
|
||
std::cerr << "Failed to create socket." << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
// 设置Server地址信息
|
||
serverAddr.sin_family = AF_INET;
|
||
serverAddr.sin_port = htons(18393); // TCP默认端口号为80
|
||
inet_pton(AF_INET, /*GlobalConfig::ServerIP.c_str()*/"192.168.1.147", &serverAddr.sin_addr);
|
||
|
||
// 连接到Server
|
||
if (connect(sockfd, reinterpret_cast<struct sockaddr*>(&serverAddr), sizeof(serverAddr)) == -1) {
|
||
std::cerr << "Failed to connect to the server." << std::endl;
|
||
close(sockfd);
|
||
return 1;
|
||
}
|
||
|
||
// 发送心跳数据包
|
||
const char heartbeat[] = "Heartbeat";
|
||
ssize_t bytesSent = send(sockfd, pSendData, strlen(pSendData), MSG_NOSIGNAL);
|
||
if (bytesSent == -1) {
|
||
std::cerr << "Failed to send heartbeat packet." << std::endl;
|
||
close(sockfd);
|
||
return 1;
|
||
} else if (static_cast<size_t>(bytesSent) != strlen(pSendData)) {
|
||
std::cerr << "Partially sent heartbeat packet." << std::endl;
|
||
close(sockfd);
|
||
return 1;
|
||
}
|
||
|
||
// 关闭Socket连接
|
||
close(sockfd);
|
||
|
||
return 0;
|
||
}
|
||
//unsigned short cal_chksum(unsigned short *addr, int len)
|
||
//{
|
||
// int nleft=len;
|
||
// int sum=0;
|
||
// unsigned short *w=addr;
|
||
// unsigned short answer=0;
|
||
//
|
||
// while(nleft > 1)
|
||
// {
|
||
// sum += *w++;
|
||
// nleft -= 2;
|
||
// }
|
||
//
|
||
// if( nleft == 1)
|
||
// {
|
||
// *(unsigned char *)(&answer) = *(unsigned char *)w;
|
||
// sum += answer;
|
||
// }
|
||
//
|
||
// sum = (sum >> 16) + (sum & 0xffff);
|
||
// sum += (sum >> 16);
|
||
// answer = ~sum;
|
||
//
|
||
// return answer;
|
||
//}
|
||
|
||
// Ping函数，timeout为超时时间，单位是ms,10000 毫秒=10 秒
|
||
//成功：返回0，失败：返回1或-1
|
||
int Ping( const char *ips, int timeout)
|
||
{
|
||
struct timeval *tval;
|
||
int maxfds = 0;
|
||
fd_set readfds;
|
||
|
||
int iRet = 0;
|
||
struct sockaddr_in addr;
|
||
struct sockaddr_in from;
|
||
// 设定Ip信息
|
||
bzero(&addr,sizeof(addr));
|
||
addr.sin_family = AF_INET;
|
||
|
||
addr.sin_addr.s_addr = inet_addr(ips);
|
||
|
||
int sockfd;
|
||
// 取得socket 。 如果没加sudo 这里会报错
|
||
sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
|
||
if (sockfd < 0)
|
||
{
|
||
print_error("ip:%s,socket error\n",ips);
|
||
return -1;
|
||
}
|
||
|
||
struct timeval timeo;
|
||
// 设定TimeOut时间
|
||
timeo.tv_sec = timeout / 1000;
|
||
timeo.tv_usec = timeout % 1000;
|
||
|
||
if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo)) == -1)
|
||
{
|
||
print_error("ip:%s,setsockopt error\n",ips);
|
||
close(sockfd);
|
||
return -1;
|
||
}
|
||
|
||
char sendpacket[2048];
|
||
char recvpacket[2048];
|
||
// 设定Ping包
|
||
memset(sendpacket, 0, sizeof(sendpacket));
|
||
|
||
pid_t pid;
|
||
// 取得PID，作为Ping的Sequence ID
|
||
pid=getpid();
|
||
|
||
struct ip *iph;
|
||
struct icmp *icmp;
|
||
|
||
|
||
icmp=(struct icmp*)sendpacket;
|
||
icmp->icmp_type=ICMP_ECHO; //回显请求
|
||
icmp->icmp_code=0;
|
||
icmp->icmp_cksum=0;
|
||
icmp->icmp_seq=0;
|
||
icmp->icmp_id=pid;
|
||
tval= (struct timeval *)icmp->icmp_data;
|
||
gettimeofday(tval,NULL);
|
||
icmp->icmp_cksum=cal_chksum((unsigned short *)icmp,sizeof(struct icmp)); //校验
|
||
|
||
int n = sendto(sockfd, (char *)&sendpacket, sizeof(struct icmp), 0, (struct sockaddr *)&addr, sizeof(addr));
|
||
if (n < 1)
|
||
{
|
||
print_error("ip:%s,sendto error\n",ips);
|
||
close(sockfd);
|
||
return -1;
|
||
}
|
||
|
||
// 接受
|
||
// 由于可能接受到其他Ping的应答消息，所以这里要用循环
|
||
int cnt=0;
|
||
while(1)
|
||
{
|
||
// 设定TimeOut时间，这次才是真正起作用的
|
||
FD_ZERO(&readfds);
|
||
FD_SET(sockfd, &readfds);
|
||
maxfds = sockfd + 1;
|
||
n = select(maxfds, &readfds, NULL, NULL, &timeo);
|
||
if (n <= 0)
|
||
{
|
||
print_info("ip:%s,Time out error\n",ips);
|
||
close(sockfd);
|
||
iRet = -1;
|
||
break;
|
||
}
|
||
|
||
// 接受
|
||
memset(recvpacket, 0, sizeof(recvpacket));
|
||
int fromlen = sizeof(from);
|
||
n = recvfrom(sockfd, recvpacket, sizeof(recvpacket), 0, (struct sockaddr *)&from, (socklen_t *)&fromlen);
|
||
print_info("recvfrom Len:%d\n",n);
|
||
if (n < 1)
|
||
{
|
||
close(sockfd);
|
||
iRet = 1;
|
||
break;
|
||
}
|
||
|
||
char *from_ip = (char *)inet_ntoa(from.sin_addr);
|
||
// 判断是否是自己Ping的回复
|
||
if (strcmp(from_ip,ips) != 0)
|
||
{
|
||
print_info("NowPingip:%s Fromip:%s NowPingip is not same to Fromip,so ping wrong!\n",ips,from_ip);
|
||
close(sockfd);
|
||
iRet = 1;
|
||
break;
|
||
|
||
}
|
||
|
||
iph = (struct ip *)recvpacket;
|
||
|
||
icmp=(struct icmp *)(recvpacket + (iph->ip_hl<<2));
|
||
|
||
print_info("ip:%s,icmp->icmp_type:%d,icmp->icmp_id:%d\n",ips,icmp->icmp_type,icmp->icmp_id);
|
||
// 判断Ping回复包的状态
|
||
if (icmp->icmp_type == ICMP_ECHOREPLY && icmp->icmp_id == pid) //ICMP_ECHOREPLY回显应答
|
||
{
|
||
// 正常就退出循环
|
||
print_info("icmp succecss ............. \n");
|
||
break;
|
||
}
|
||
else if(cnt<3)
|
||
{
|
||
// 否则继续等
|
||
cnt++;
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
close(sockfd);
|
||
iRet = -1;
|
||
break;
|
||
}
|
||
}
|
||
close(sockfd);
|
||
return iRet;
|
||
}
|
||
int get_netlink_status(const char *if_name)
|
||
{
|
||
int skfd;
|
||
struct ifreq ifr;
|
||
struct ethtool_value edata;
|
||
edata.cmd = ETHTOOL_GLINK;
|
||
edata.data = 0;
|
||
memset(&ifr, 0, sizeof(ifr));
|
||
strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name) - 1);
|
||
ifr.ifr_data = (char *)&edata;
|
||
if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) == 0)
|
||
return -1;
|
||
if (ioctl(skfd, SIOCETHTOOL, &ifr) == -1)
|
||
{
|
||
close(skfd);
|
||
return -1;
|
||
}
|
||
close(skfd);
|
||
return edata.data;
|
||
}
|
||
// 将版本号字符串拆分为整数组成的向量
|
||
std::vector<int> splitVersion(const std::string& version) {
|
||
std::vector<int> parts;
|
||
std::stringstream ss(version);
|
||
std::string part;
|
||
|
||
// 用点作为分隔符，分割版本号
|
||
while (std::getline(ss, part, '.')) {
|
||
parts.push_back(std::stoi(part)); // 将分割后的部分转换为整数
|
||
}
|
||
|
||
return parts;
|
||
}
|
||
|
||
// 比较两个版本号
|
||
int compareVersions(const std::string& version1, const std::string& version2) {
|
||
std::vector<int> v1 = splitVersion(version1);
|
||
std::vector<int> v2 = splitVersion(version2);
|
||
|
||
// 找到最长的版本号部分长度
|
||
size_t maxLength = std::max(v1.size(), v2.size());
|
||
|
||
for (size_t i = 0; i < maxLength; ++i) {
|
||
int num1 = i < v1.size() ? v1[i] : 0; // 如果某部分不存在，视为0
|
||
int num2 = i < v2.size() ? v2[i] : 0;
|
||
|
||
if (num1 > num2) return 1; // version1 大于 version2
|
||
if (num1 < num2) return -1; // version1 小于 version2
|
||
}
|
||
|
||
return 0; // 版本号相同
|
||
}
|
||
|
||
void Binary_Bit(unsigned char* p_data, unsigned char position, int flag)
|
||
{
|
||
//二进制某位置零或者一 position为位数(从0 开始)
|
||
if (flag)
|
||
{
|
||
*p_data |= 0x01 << (position);
|
||
}
|
||
else
|
||
{
|
||
*p_data &= ~(0x01 << (position));
|
||
}
|
||
}
|
||
std::string get_file_md5(const std::string& file_path) {
|
||
// 使用 md5sum 命令计算文件的 MD5 值
|
||
std::string command = "md5sum " + file_path + " | awk '{ print $1 }'";
|
||
|
||
// 使用 popen 执行命令并获取输出
|
||
std::array<char, 128> buffer;
|
||
std::string result;
|
||
std::shared_ptr<FILE> pipe(popen(command.c_str(), "r"), pclose);
|
||
|
||
if (!pipe) {
|
||
std::cerr << "Error: Unable to run md5sum command" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 从命令的输出流中读取数据
|
||
while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
|
||
result += buffer.data();
|
||
}
|
||
|
||
// 去除末尾的换行符
|
||
result.erase(result.find_last_not_of("\n") + 1);
|
||
|
||
return result;
|
||
}
|
||
static const char* JSON_FIELD_CMD = "cmd";//协议: 命令字段
|
||
static const char* JSON_FIELD_NAME = "dataWatchName";//协议: 终端名称
|
||
static const char* JSON_FIELD_dataNodeGatewayNo = "dataNodeGatewayNo";
|
||
static const char* JSON_FIELD_ASSETID = "dataWatchAssetId";//协议: 资产编号 字段
|
||
static const char* JSON_FIELD_ADDEDBY = "dataWatchAddedBy";//协议: 添加人 字段
|
||
static const char* JSON_FIELD_DEVICETYPE = "deviceType";
|
||
static const char* JSON_FIELD_ADDEDDATE = "dataWatchAddedDate";
|
||
static const char* JSON_FIELD_IPADDRESS = "dataWatchIpAddress";
|
||
static const char* JSON_FIELD_SN = "serialNumber";
|
||
static const char* JSON_FIELD_VERSION = "softVersion";
|
||
static const char* JSON_FIELD_TIMEZONE = "timezone";
|
||
|