Vehicle-cpp/zxf/main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>
#include <signal.h>
#include <pthread.h>
#include <dirent.h>

#include "pxTools.h"
#include "pxEpoll.h"
#include "JMcan.h"
#include "JMremote.h"
#include "JMPlc.h"
#include "JMros.h"
#include "JMmqtt.h"
#include "JMrtk.h"
#include "canTransmit.h"

extern POSTDATABUF_S postData;
int epollfd=0;

CONFIG_S config={
    .logLevel=3,
    .MqttBrockerAddress="127.0.0.1",
    .MqttBrockerPort=1883,
    .MqttClientID="x",
    .MqttUserName="",
    .MqttPassWord="",
    .MqttReconnectTime=60,
    .canName="",
    .PlcIP=NULL,
    .LeftLeg=408,
    .RightLeg=410,
};

void readConfig(char *path)
{
	cJSON* confJson=pxReadJsonFile_malloc(path);
	if(confJson==NULL)
	{
    	pxLog(NONE,"read config error:\"%s\"",path);
		exit(-1);
	}
    pxJsonIntcpy(confJson,"logLevel",                   &config.logLevel);
    pxJsonStrdup(confJson,"MqttBrockerAddress",         &config.MqttBrockerAddress);
    pxJsonIntcpy(confJson,"MqttBrockerPort",            &config.MqttBrockerPort);
    pxJsonStrdup(confJson,"MqttClientID",               &config.MqttClientID);
    pxJsonStrdup(confJson,"MqttUserName",               &config.MqttUserName);
    pxJsonStrdup(confJson,"MqttPassWord",               &config.MqttPassWord);
    pxJsonIntcpy(confJson,"MqttReconnectTime",          &config.MqttReconnectTime);
    pxJsonStrdup(confJson,"RemoteControlTopic",         &config.RemoteControlTopic);
    pxJsonStrdup(confJson,"AutoControlTopic",           &config.AutoControlTopic);
    pxJsonStrdup(confJson,"ManualControlTopic",         &config.ManualControlTopic);
    pxJsonStrdup(confJson,"canName",                    &config.canName);
    pxJsonStrdup(confJson,"PlcIP",                      &config.PlcIP);
    pxJsonIntcpy(confJson,"LeftLeg",                    &config.LeftLeg);
    pxJsonIntcpy(confJson,"RightLeg",                   &config.RightLeg);

    cJSON_Delete(confJson);
    pxLog(NONE,"use config[\n\
	logLevel:%d,\n\
	MqttBrockerAddress:%s\n\
	MqttBrockerPort:%d\n\
	MqttClientID:%s\n\
	MqttUserName:%s\n\
	MqttPassWord:%s\n\
	MqttReconnectTime:%d\n\
	RemoteControlTopic:%s\n\
	AutoControlTopic:%s\n\
	ManualControlTopic:%s\n\
	canName:%s\n\
	PlcIP:%s\n\
	LeftLeg:%d\n\
	RightLeg:%d\n\
]\n",
	config.logLevel,
	config.MqttBrockerAddress,
	config.MqttBrockerPort,
	config.MqttClientID,
	config.MqttUserName,
	config.MqttPassWord,
	config.MqttReconnectTime,
	config.RemoteControlTopic,
	config.AutoControlTopic,
	config.ManualControlTopic,
	config.canName,
	config.PlcIP,
	config.LeftLeg,
	config.RightLeg
	);
}

char topic[100]={0};
void postTimer(PXTIMER_S *timer)
{
    char buf[2048]={0};
    // struct timeval tv;
    // gettimeofday(&tv,NULL);
    // uint64_t milliseconds = (uint64_t)(tv.tv_sec) * 1000 + (uint64_t)(tv.tv_usec) / 1000 ;
    // pxLog(EVENT,"[POST] post can data");
    u64 milliseconds = get_timeStamp();
    buf[0]=2;
    memcpy(buf+1,&postData,sizeof(postData));
    memcpy(buf+sizeof(postData)+1,&milliseconds,8);

    static int times=0;
    if(++times>=2)
    {
        times=0;
        if(postData.status.mqtt)
        {
            MQTT_publishBytes(topic,buf+1,sizeof(postData)+8);
        }
    }
    if(postData.status.system==REMOTECONTROL && postData.status.udp)
    {
        Remote_send(buf,sizeof(postData)+9);
    }
}

void rotateLog(PXTIMER_S *timer)
{
    time_t now;
	struct tm *dateNow;
	struct dirent **name_list;
    
    pxLog(EVENT,"[LOG] rotateLog");
	int n = scandir(DATALOGPATH,&name_list,0,alphasort);
	if(n > 0)
	{
		int index=0;
        time(&now);
        dateNow = localtime(&now);
		while(index < n)
		{
            if(name_list[index]->d_name[0]!='.') 
			{
                int year,month,day;
                int count=sscanf(name_list[index]->d_name,"%d-%d-%d",&year,&month,&day);
                if(count==3)
                {
                    int dmonth=(dateNow->tm_year+1900-year)*12+dateNow->tm_mon+1-month;
                    int dday=dmonth*30+dateNow->tm_mday-day;
                    if(dday>60)
                    {
                        pxLog(EVENT,"[LOG] file %s timeout,delete",name_list[index]->d_name);
                        char file_path[256];
                        sprintf(file_path,DATALOGPATH"%s",name_list[index]->d_name);
                        remove(file_path);
                    }
                }
			}
			free(name_list[index++]);
        }
		free(name_list);
    }
}

void canTransmitRun()
{
    pthread_t thread;
    pthread_t rtkthreadhd;
    epollfd=epollInit("MAIN");
    while (pthread_create(&thread, NULL, CAN_Run, (void*)config.canName) != 0)
    {
        pxLog(WARNING,"create CAN thread WRONG,retry");
        sleep(3);
    }
    
    while (pthread_create(&rtkthreadhd, NULL, rtkthread, NULL) != 0)
    {
        pxLog(WARNING,"create RTK thread WRONG,retry");
        sleep(3);
    }
    while (MQTT_connect()!=0)
    {
        pxLog(WARNING,"connect MQTT WRONG,retry");
        sleep(3);
    }
    ROS_listen(NULL);
    PLC_conn(NULL);
    sprintf(topic,"%s/data/canData",config.MqttClientID);
    timerAdd(epollfd,1,POSTTIMERINTERVAL,1,postTimer,NULL);
    timerAdd(epollfd,2,60*1000,1,rotateLog,NULL);
    timerAdd(epollfd,3,1000,1,mqttTimer,NULL);
    
    epollMain(epollfd,"MAIN");
}

int main(int argc, char **argv)
{
    int opt = 0;
	int debugLevel=-1;
    char *configPath="/etc/config/cantTransmit";

    while ((opt = getopt(argc, argv, "c:l:h")) != -1)
	{
		switch (opt)
		{
            case 'c':
				configPath=optarg;
				break;
			case 'l':
				debugLevel=optarg[0] - 0x30;
				break;
            case 'h':
				printf("cantTransmit -l $loglevel -c $configPath(default /etc/config/cantTransmit)");
				exit(0);
				break;
			default:
				break;
		}
	}

    pxDeamonUniq(SFOTWARE_NAME);
	pxOpenLogFile(SFOTWARE_NAME);

	readConfig(configPath);
	if(debugLevel!=-1)
		pxSetLogLevel(debugLevel);
	else
    	pxSetLogLevel(config.logLevel);
        
    canTransmitRun();
}