Terminal_process_CT/test/terminal_client.cpp

//
// Created by zx on 2020/7/10.
//

//
// Created by zx on 2020/7/3.
//
#include <unistd.h>
#include <iostream>
#include <nnxx/message>
#include <nnxx/socket.h>
#include <nnxx/bus.h>

#include "terminal_message.pb.h"
#include <thread>
#include "threadSafeQueue.h"

#include "Terminal_communication.h"
#include "store_terminal.h"
#include "pickup_terminal.h"
#include "pathcreator.h"
#include "process_message.pb.h"
#include "system_communicator.h"

GOOGLE_GLOG_DLL_DECL void shut_down_logging(const char* data, int size)
{
    time_t tt;
    time( &tt );
    tt = tt + 8*3600;  // transform the time zone
    tm* t= gmtime( &tt );
    char buf[255]={0};
    sprintf(buf,"./%d%02d%02d-%02d%02d%02d-dump_client.txt",
            t->tm_year + 1900,
            t->tm_mon + 1,
            t->tm_mday,
            t->tm_hour,
            t->tm_min,
            t->tm_sec);

    FILE* tp_file=fopen(buf,"w");
    fprintf(tp_file,data,strlen(data));
    fclose(tp_file);

}

void init_glog()
{
    time_t tt = time(0);//时间cuo
    struct tm* t = localtime(&tt);

    char strYear[255]={0};
    char strMonth[255]={0};
    char strDay[255]={0};

    sprintf(strYear,"%04d", t->tm_year+1900);
    sprintf(strMonth,"%02d", t->tm_mon+1);
    sprintf(strDay,"%02d", t->tm_mday);

    char buf[255]={0};
    getcwd(buf,255);
    char strdir[255]={0};
    sprintf(strdir,"%s/log_client/%s/%s/%s", buf,strYear,strMonth,strDay);
    PathCreator creator;
    creator.Mkdir(strdir);

    char logPath[255] = { 0 };
    sprintf(logPath, "%s/", strdir);
    FLAGS_max_log_size = 100;
    FLAGS_logbufsecs = 0;
    google::InitGoogleLogging("LidarMeasurement");
    google::SetStderrLogging(google::INFO);
    google::SetLogDestination(0, logPath);
    google::SetLogFilenameExtension("zxlog");
    google::InstallFailureSignalHandler();
    google::InstallFailureWriter(&shut_down_logging);
    FLAGS_colorlogtostderr = true;        // Set log color
    FLAGS_logbufsecs = 0;                // Set log output speed(s)
    FLAGS_max_log_size = 1024;            // Set max log file size(GB)
    FLAGS_stop_logging_if_full_disk = true;
}

int main() {
    init_glog();
    Terminal_communication::get_instance_pointer()->communication_connect("tcp://192.168.2.183:30001");
    Terminal_communication::get_instance_pointer()->communication_run();
    usleep(2000*1000);
    threadsafe_queue<message::Car_info> input_queue;
    threadsafe_queue<message::Car_info> output_queue;

    const int n_input=3;
    const int n_output=1;
    std::vector<store_terminal*> input_terminals;
    std::vector<pickup_terminal*> output_terminals;
    for(int i=0;i<n_input;++i)
    {
        store_terminal* store=new store_terminal(i);
        store->init(&input_queue,&output_queue);
        input_terminals.push_back(store);
    }

    for(int i=0;i<n_output;++i)
    {
        pickup_terminal* picker=new pickup_terminal(i);
        picker->init(&output_queue);
        output_terminals.push_back(picker);
    }

    int n = 0;
    bool run = true;
    Error_manager code;
    char c=0;

    while (c!='q') {

        /*int k=rand()%4;

        message::Storing_process_statu_msg msg;
        message::Base_info base_info;
        base_info.set_msg_type(message::eStoring_process_statu_msg);
        base_info.set_sender(message::eMain);
        base_info.set_receiver(message::eTerminor);
        msg.mutable_base_info()->CopyFrom(base_info);

        message::Alloc_space_step_statu alloc_step;
        alloc_step.set_step_statu(message::Step_statu(k));

        message::Measure_step_statu     measure_step;
        measure_step.set_step_statu(message::eWaiting);

        message::Dispatch_store_step_statu  store_step;
        store_step.set_step_statu(message::eWaiting);

        message::Confirm_space_step_statu   confirm_step;
        confirm_step.set_step_statu(message::eWaiting);

        message::Release_space_step_statu   release_step;
        release_step.set_step_statu(message::eWaiting);

        msg.mutable_alloc_space_step()->CopyFrom(alloc_step);
        msg.mutable_measure_step()->CopyFrom(measure_step);
        msg.mutable_dispatch_step()->CopyFrom(store_step);
        msg.mutable_confirm_space_step()->CopyFrom(confirm_step);
        msg.mutable_failed_release_space_step()->CopyFrom(release_step);

        System_communicator::get_instance_pointer()->post_entrance_statu(msg);
        usleep(1000*1000);*/




        int license_id = rand() % 90000 + 10000;
        char C=rand()%10+'A';
        char license[255] = {0};
        sprintf(license, "鄂%c%d",C, license_id);
        message::Car_info car_info;
        car_info.set_license(license);
        car_info.set_car_height(1.5);
        car_info.set_car_width(1.7);
        input_queue.push(car_info);
       // std::cout<<" input : "<<++n<<std::endl;

        n++;

        int in_count=input_queue.size();
        int out_count=output_queue.size();

        if(n%1==0) {
            usleep(1000*1000*1);
        }
        else {
            //暂停 5-15s 代替
            int delay=10*1000;//in_count*200;
            usleep(1000*delay+1);
            std::this_thread::yield();
        }
    }
}