release01

main.cpp

@@ -23,6 +23,8 @@ using google::protobuf::io::CodedOutputStream;
 using google::protobuf::Message;
 #include "setting.pb.h"
 #include "safety_excutor.h"
+#include <byteswap.h>
+
 GOOGLE_GLOG_DLL_DECL void shut_down_logging(const char* data, int size)
 {
     time_t tt;
@@ -108,177 +110,7 @@ int Working()
         break;
     }
 
-    /*Error_manager code;
-
-    Eigen::Vector4f plane,plane1;
-    plane[0]=0;
-    plane[1]=1;
-    plane[2]=0.2;
-    plane[3]=2;
-
-    plane1[0]=0;
-    plane1[1]=1;
-    plane1[2]=-0.2;
-    plane1[3]=-1.3;
-    float maxd=0.02,mind=-0.08,maxd1=-0.02,mind1=-0.12;
-
-    shuttler_verifier left_shutter;
-    shuttler_verifier right_shutter;
-    left_shutter.set_condition(plane1,maxd1,mind1);
-    right_shutter.set_condition(plane,maxd,mind);
-
-    verifier shutter(left_shutter,right_shutter);
-    mut.lock();
-    left_shutter.create_plane(viewer);
-    right_shutter.create_plane(viewer);
-    mut.unlock();
-
-    //创建雷达  循环采集
-    //读laser配置
-    Laser_proto::Laser_parameter_all laser_parameters;
-    if(!proto_tool::read_proto_param("./setting/laser.prototxt",laser_parameters))
-    {
-        LOG(ERROR)<<"read laser parameter failed";
-        return -1;
-    }
-
-    int laser_cout=laser_parameters.laser_parameters_size();
-    if(laser_cout==0)
-    {
-        LOG(ERROR)<<" no lidars ";
-        return 0;
-    }
-    std::vector<Laser_base*>  plasers;
-    plasers.resize(laser_cout);
-    for(int i=0;i<laser_parameters.laser_parameters_size();++i)
-    {
-        plasers[i] = LaserRegistory::CreateLaser(laser_parameters.laser_parameters(i).type(), i,
-                                                 laser_parameters.laser_parameters(i));
-        if (plasers[i] != NULL)
-        {
-            if (plasers[i]->connect_laser() != SUCCESS)
-            {
-                char description[255] = {0};
-                sprintf(description, "Laser %d connect failed...", i);
-                LOG(ERROR)<<description;
-            }
-        }
-    }
-    for (int i = 0; i < laser_parameters.laser_parameters_size(); ++i)
-    {
-        std::string type = laser_parameters.laser_parameters(i).type();
-        if (type.find("Livox") != type.npos ||type.find("Horizon") != type.npos)
-        {
-            if (Start() == false)
-            {
-                Uninit();
-                LOG(ERROR)<<"Livox laser init failed...";
-                return -2;
-            }
-            break;
-        }
-    }
-
-    usleep(3000*1000);
-
-    LOG(INFO)<<"init ok...";
-
-    //采集
-    int frames=0;
-    while(1)
-    {
-        auto t_start_point = std::chrono::system_clock::now();
-
-        pcl::PointCloud<pcl::PointXYZ> scan_cloud;
-        std::mutex cloud_lock;
-        std::vector<Laser_task *> laser_task_vector;
-        for (int i = 0; i < plasers.size(); ++i)
-        {
-            int frame_count = laser_parameters.laser_parameters(i).frame_num();
-            if (plasers[i] != nullptr)
-            {
-
-                //创建扫描任务,
-                Laser_task *laser_task = new Laser_task();
-                //
-                laser_task->task_init(TASK_CREATED, &scan_cloud, &cloud_lock);
-                laser_task->set_task_frame_maxnum(frame_count);
-                laser_task_vector.push_back(laser_task);
-                //发送任务单给雷达
-                code = plasers[i]->execute_task(laser_task);
-                if (code != SUCCESS)
-                {
-                    LOG(ERROR) << " capture failed :" << code.get_error_description();
-                    return -3;
-                }
-            }
-
-        }
-
-
-        //等待雷达完成任务单
-        double second=0.0;
-        while (1)
-        {
-            //判断是否强制退出
-            //判断雷达任务单是否全部完成
-            bool tb_laser_complete = true;
-            for (int i = 0; i < laser_task_vector.size(); ++i)
-            {
-                tb_laser_complete &= (TASK_OVER == laser_task_vector[i]->get_statu());
-            }
-            if (tb_laser_complete)
-            {
-                break;
-            }
-            //计算扫描时间,若超时,并且没有点,则返回错误.
-            auto t_end_point = std::chrono::system_clock::now();
-            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t_end_point - t_start_point);
-            second = double(duration.count()) *
-                    std::chrono::milliseconds::period::num / std::chrono::milliseconds::period::den;
-            if (second > 0.5)
-            {
-                LOG(WARNING)<<"capture time out";
-                break;
-            }
-            usleep(1000*10);
-        }
-        //检查雷达任务完成情况,是否是正常完成
-
-        //释放扫描任务单
-        for (int i = 0; i < laser_task_vector.size(); ++i) {
-            if (laser_task_vector[i] != 0) {
-                delete laser_task_vector[i];
-                laser_task_vector[i] = NULL;
-            }
-        }
-        LOG(INFO) << " frame :"<<++frames<<",laser scanning over cloud size:" << scan_cloud.size()
-                  <<" , time:"<<second;
-
-
-        //处理点云--------------------------------------------------------------------------
-
-
-        int color[3]={0,255,0};
-        if(shutter.verify(scan_cloud.makeShared())!=SUCCESS)
-        {
-            color[0]=255;
-            color[1]=0;
-            color[2]=0;
-        }
-
-        mut.lock();
-        viewer.removeAllPointClouds();
-        pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> single_color(scan_cloud.makeShared(), color[0],color[1],color[2]); // green
-        viewer.addPointCloud(scan_cloud.makeShared(), single_color, "livox");
-        viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "livox");
-        mut.unlock();
-        usleep(10*1000);
-    }
-
-*/
-
-
+    return 0;
 }
 
 int main(int argc,char* argv[])
@@ -291,84 +123,99 @@ int main(int argc,char* argv[])
 
     int ret = livox::LdsLidar::InitLdsLidar();
 
-
-    shutter::shutter_param  shutter_param;
-    if(read_proto_param("./setting/setting.prototxt",shutter_param)==false)
+    shutter::setting_parameter  setting_parameter;
+    if(read_proto_param("./setting/setting.prototxt",setting_parameter)==false)
     {
         printf("  read proto failed \n");
         return -1;
     }
 
-    safety_excutor* excutor=safety_excutor::CreateExcutor(shutter_param);
-    if(excutor== nullptr)
-    {
-        printf(" create safety_excutor failed\n");
-        return -1;
-    }
-
-
 
-    /*const float DEGREE=M_PI/180.0;
-    float transform1[]={-2.31,161.58,-64,2.512,0,0};
-    float transform2[]={176.45,28.05,71.85,0,0,0};
+    safety_excutor* excutor_entrance=safety_excutor::CreateExcutor(setting_parameter.entrance_parameter());
+    safety_excutor* excutor_export=safety_excutor::CreateExcutor(setting_parameter.export_parameter());
 
-
-    std::string sn1="3GGDJ8S00100921";
-    std::string sn2="3GGDJ8X00100541";
-    Eigen::Vector3f rpy1;
-    rpy1<<-2.31*DEGREE,161.58*DEGREE,-64*DEGREE;
-    Eigen::Vector3f rpy2;
-    rpy2<<176.45*DEGREE,28.05*DEGREE,71.85*DEGREE;
-
-    Eigen::Vector3f t1;
-    t1<<1.256,0,0;
-    Eigen::Vector3f t2;
-    t2<<-1.256,0,0;
-
-
-    read_lidar.SetTransformParam(rpy1,t1);
-    read_lidar1.SetTransformParam(rpy2,t2);
-
-    if(read_lidar.AddBroadcastCode(sn1)!=0)
-        printf("%s  connect failed\n",sn1.c_str());
-    if(read_lidar1.AddBroadcastCode(sn2)!=0)
+    Snap7_communication_base 					snap7_client;			//通信的客户端
+    Error_manager code=snap7_client.communication_init(setting_parameter.plc_setting().ip());
+    if(code!=SUCCESS)
     {
-        printf("%s  connect failed\n",sn2.c_str());
-
+        std::cout<<code<<std::endl;
+        return -1;
     }
-    read_lidar.SetFPS(10.0);
-    read_lidar1.SetFPS(10.0);*/
-    usleep(3000*1000);
 
+    usleep(3000*1000);
 
-    //lidar1.AddSNCode(sn1);
-    //lidar2.AddSNCode(sn2);
-
-    std::thread* thread=new std::thread(Working);
-    tagMeasureData  measure_data;
+    //std::thread* thread=new std::thread(Working);
+    tagMeasureData  measure_data_entrance;
+    tagMeasureData  measure_data_export;
+#pragma pack(push,1)
     struct PLCData
     {
-        int   pingpong;
-        unsigned short  safety;
+        unsigned short   pingpong;
+        unsigned short  wheel_path_safety;
+        unsigned short  parkspace_safety;
         float left_space;
         float right_space;
         float theta;
         float offset_x;
+
+        unsigned short  wheel_path_safety_export;
+        unsigned short  parkspace_safety_export;
+        float left_space_export;
+        float right_space_export;
+        float theta_export;
+        float offset_x_export;
     };
+#pragma pack(pop)
     int PING=0;
+    Snap7_buf buf;
+    buf.m_communication_mode = Snap7_buf::Communication_mode::LOOP_COMMUNICATION;
     while(1)
     {
-        excutor->verify(measure_data);
+        memset(&measure_data_entrance,0,sizeof(measure_data_entrance));
+        memset(&measure_data_export,0,sizeof(measure_data_export));
+        if(excutor_entrance!= nullptr)
+            excutor_entrance->verify(measure_data_entrance);
+        if(excutor_export!= nullptr)
+            excutor_export->verify(measure_data_export);
+
+
         struct PLCData plc_data;
-        plc_data.pingpong=(PING++)%10000;
-        plc_data.offset_x=measure_data.offset_x;
-        plc_data.left_space=measure_data.left_space;
-        plc_data.right_space=measure_data.right_space;
-        plc_data.theta=measure_data.theta;
-        plc_data.safety=measure_data.safety;
+        plc_data.pingpong=bswap_16((PING++)%100000);
+        plc_data.offset_x=bswap_32(measure_data_entrance.offset_x);
+        plc_data.left_space=bswap_32(measure_data_entrance.left_space);
+        plc_data.right_space=bswap_32(measure_data_entrance.right_space);
+        plc_data.theta=bswap_32(measure_data_entrance.theta);
+        plc_data.wheel_path_safety=bswap_16(measure_data_entrance.wheel_path_safety);
+        plc_data.parkspace_safety=bswap_16(measure_data_entrance.parkspcae_safety);
+
+        plc_data.offset_x_export=bswap_32(measure_data_export.offset_x);
+        plc_data.left_space_export=bswap_32(measure_data_export.left_space);
+        plc_data.right_space_export=bswap_32(measure_data_export.right_space);
+        plc_data.theta_export=bswap_32(measure_data_export.theta);
+        plc_data.wheel_path_safety_export=bswap_16(measure_data_export.wheel_path_safety);
+        plc_data.parkspace_safety_export=bswap_16(measure_data_export.parkspcae_safety);
+
+
+        buf.m_id=setting_parameter.plc_setting().dbnumber();
+        buf.m_size=sizeof(plc_data);
+        buf.m_start_index=setting_parameter.plc_setting().start_id();
+        buf.mp_buf_reverse=&plc_data;
+        /*int result = m_snap7_client.AsDBWrite(snap7_buf.m_id, snap7_buf.m_start_index, snap7_buf.m_size,
+                                              snap7_buf.mp_buf_reverse);*/
+
+        //code=snap7_client.read_data_buf(buf);
+        code=snap7_client.write_data_buf(buf);
+        /*unsigned short a;
+        memcpy(&a,buf.mp_buf_reverse,2);
+        printf("------------%d\n",bswap_16(a));*/
+
+        if(code!=SUCCESS)
+        {
+            std::cout<<code<<std::endl;
+        }
 
 
-        usleep(33*1000);
+        usleep(50*1000);
     }
 
     return 0;

plc/plc_data.h

@@ -10,7 +10,7 @@
 #include <atomic>
 #include "../tool/thread_condition.h"
 #include <thread>
-#include "../snap7_communication/s7_plc.h"
+#include "s7_plc.h"
 #include "unistd.h"
 //#include "define.h"
 #include "glog/logging.h"

plc/snap7_communication_base.cpp

@@ -257,7 +257,7 @@ Error_manager Snap7_communication_base::read_data_buf(Snap7_buf& snap7_buf)
 		{
 			m_snap7_client.WaitAsCompletion(100);
 			//倒序数据 转为 正序数据
-			snap7_buf.reverse_to_obverse();
+			//snap7_buf.reverse_to_obverse();
 		}
 		else
 		{
@@ -281,9 +281,12 @@ Error_manager Snap7_communication_base::write_data_buf(Snap7_buf& snap7_buf)
 		}
 
 		//正序数据 转为 倒序数据
-		snap7_buf.obverse_to_reverse();
+		//snap7_buf.obverse_to_reverse();
 
 		std::unique_lock<std::mutex> lck(m_communication_lock);
+		unsigned short a=0;
+		memcpy(&a,snap7_buf.mp_buf_reverse,2);
+		printf("id %d  start %d  size :%d   value :%d\n",snap7_buf.m_id, snap7_buf.m_start_index, snap7_buf.m_size,a);
 		int result = m_snap7_client.AsDBWrite(snap7_buf.m_id, snap7_buf.m_start_index, snap7_buf.m_size,
 											  snap7_buf.mp_buf_reverse);
 

plc/snap7_communication_base.h

@@ -53,11 +53,14 @@ public://API functions
 
 public://get or set member variable
 	Snap7_communication_statu get_status();
+    //接受数据, 读取DB块,
+    Error_manager read_data_buf(Snap7_buf& snap7_buf);
+    //发送数据, 写入DB块,
+    Error_manager write_data_buf(Snap7_buf& snap7_buf);
 protected://member functions
 	//通信连接
 	Error_manager communication_connect(std::string ip_string);
-    //发送数据, 写入DB块,
-    Error_manager write_data_buf(Snap7_buf& snap7_buf);
+
 	//启动通信, run thread
 	Error_manager communication_run();
 	//通信断连
@@ -65,8 +68,7 @@ protected://member functions
 	//mp_communication_thread线程的执行函数, 负责进行s7的通信
 	void communication_thread();
 
-	//接受数据, 读取DB块,
-	Error_manager read_data_buf(Snap7_buf& snap7_buf);
+
 
 	//数据颠倒
 	Error_manager reverse_byte(void* p_buf_in, void* p_buf_out, int size);

proto.sh

@@ -1,2 +1 @@
 protoc -I=./ setting.proto --cpp_out=./
-

safety_excutor.cpp

@@ -4,6 +4,7 @@
 
 #include "safety_excutor.h"
 #include <pcl/filters/passthrough.h>
+#include <pcl/common/common.h>
 
 safety_excutor::safety_excutor()
 {
@@ -79,7 +80,6 @@ pcl::PointCloud<pcl::PointXYZ>::Ptr  safety_excutor::PassThroughCloud(pcl::Point
 bool safety_excutor::verify(tagMeasureData& data)
 {
 
-
     pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
     bool connected=true;
     for(int i=0;i<m_parameter.lidars_size();++i)
@@ -90,7 +90,7 @@ bool safety_excutor::verify(tagMeasureData& data)
         (*cloud)+=(*cloud_t);
     }
 
-    printf(" shutter  recieve points %d\n",cloud->size());
+
 
     shutter::box_param box=m_parameter.box();
     pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_inner=PassThroughCloud(cloud,box);
@@ -101,8 +101,54 @@ bool safety_excutor::verify(tagMeasureData& data)
     pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_warnning2=PassThroughCloud(cloud_inner,box2);
 
     bool safe1=(cloud_warnning1->size()<=5),safe2=((cloud_warnning2->size()<=5));
+    data.wheel_path_safety=(unsigned short)(safe1&safe2&connected);
+
+    shutter::box_param box_parkspace,box_left,box_right;
+    if(box1.maxx()<box2.minx())
+    {
+        box_left=box1;
+        box_right=box2;
+    }
+    else
+    {
+        box_left=box2;
+        box_right=box1;
+    }
+    box_parkspace=box1;
+    box_parkspace.set_minx(box_left.maxx());
+    box_parkspace.set_maxx(box_right.minx());
+    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_parkspace=PassThroughCloud(cloud_inner,box_parkspace);
+    data.parkspcae_safety=(cloud_parkspace->size()<=5)?(connected&true):(connected&false);
+
+    //计算缝隙与角度
+    if(cloud_inner->size()!=0)
+    {
+
+
+        pcl::PointXYZ minp, maxp;
+        pcl::getMinMax3D(*cloud_inner, minp, maxp);
+        float l = minp.x - box_left.maxx();
+        float r = box_right.minx() - maxp.x;
+        data.left_space = (l >= 0) ? l : 0;
+        data.right_space = (r >= 0) ? r : 0;
+
+        //优化求解角度与偏移
+        data.theta = 0;
+        data.offset_x = 0;
+    }
+    else
+    {
+        data.left_space = 2.0;
+        data.right_space = 2.0;
+
+        //优化求解角度与偏移
+        data.theta = 0;
+        data.offset_x = 0;
+    }
 
 #if VIEW
+
+
     viewer.removeAllPointClouds();
     viewer.removeShape("cube1");
     viewer.removeShape("cube2");
@@ -120,20 +166,16 @@ bool safety_excutor::verify(tagMeasureData& data)
     viewer.setShapeRenderingProperties(pcl::visualization::PCL_VISUALIZER_OPACITY, 0.3, "cube2");
 
 
+
     pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> single_color2(cloud,
-            255*int(!(safe1&safe2&connected)),255*int(safe1&safe2&connected),0);
+            255*int(!data.wheel_path_safety),255*int(data.wheel_path_safety),255*int(!data.parkspcae_safety));
     viewer.addPointCloud(cloud, single_color2, "cloud");
     viewer.setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "cloud");
 
     viewer.spinOnce();
 #endif
-
-    data.safety=(unsigned short)(safe1&safe2&connected);
-    data.left_space=0.1;
-    data.right_space=0.1;
-    data.theta=0;
-    data.offset_x=0;
-
+    printf(" shutter  recieve points %d l_space:%.3f  r_space:%.3f  wheel_safety: %d   parkspace_safety: %d\n",
+            cloud->size(),data.left_space,data.right_space,data.wheel_path_safety,data.parkspcae_safety);
     //保存一帧
     static bool saved=false;
     if(saved==false)
@@ -147,10 +189,7 @@ bool safety_excutor::verify(tagMeasureData& data)
         saved=true;
     }
 
-
-
-
-    return safe1&safe2&connected;
+    return data.wheel_path_safety;
 
 }
 

safety_excutor.h

@@ -11,7 +11,8 @@
 #include "setting.pb.h"
 typedef struct
 {
-    unsigned short  safety;
+    unsigned short  wheel_path_safety;
+    unsigned short  parkspcae_safety;
     float left_space;
     float right_space;
     float theta;

setting.pb.cc

@@ -16,6 +16,8 @@
 #include <google/protobuf/port_def.inc>
 extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_box_param_setting_2eproto;
 extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_parameter_setting_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_plc_param_setting_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_shutter_param_setting_2eproto;
 namespace shutter {
 class lidar_parameterDefaultTypeInternal {
  public:
@@ -25,10 +27,18 @@ class box_paramDefaultTypeInternal {
  public:
   ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<box_param> _instance;
 } _box_param_default_instance_;
+class plc_paramDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<plc_param> _instance;
+} _plc_param_default_instance_;
 class shutter_paramDefaultTypeInternal {
  public:
   ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<shutter_param> _instance;
 } _shutter_param_default_instance_;
+class setting_parameterDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<setting_parameter> _instance;
+} _setting_parameter_default_instance_;
 }  // namespace shutter
 static void InitDefaultsscc_info_box_param_setting_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
@@ -58,6 +68,36 @@ static void InitDefaultsscc_info_lidar_parameter_setting_2eproto() {
 ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_parameter_setting_2eproto =
     {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_lidar_parameter_setting_2eproto}, {}};
 
+static void InitDefaultsscc_info_plc_param_setting_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::shutter::_plc_param_default_instance_;
+    new (ptr) ::shutter::plc_param();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::shutter::plc_param::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_plc_param_setting_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_plc_param_setting_2eproto}, {}};
+
+static void InitDefaultsscc_info_setting_parameter_setting_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::shutter::_setting_parameter_default_instance_;
+    new (ptr) ::shutter::setting_parameter();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::shutter::setting_parameter::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_setting_parameter_setting_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_setting_parameter_setting_2eproto}, {
+      &scc_info_shutter_param_setting_2eproto.base,
+      &scc_info_plc_param_setting_2eproto.base,}};
+
 static void InitDefaultsscc_info_shutter_param_setting_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
@@ -74,7 +114,7 @@ static void InitDefaultsscc_info_shutter_param_setting_2eproto() {
       &scc_info_lidar_parameter_setting_2eproto.base,
       &scc_info_box_param_setting_2eproto.base,}};
 
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_setting_2eproto[3];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_setting_2eproto[5];
 static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_setting_2eproto = nullptr;
 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_setting_2eproto = nullptr;
 
@@ -117,6 +157,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_setting_2eproto::offsets[] PRO
   3,
   4,
   5,
+  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, ip_),
+  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, dbnumber_),
+  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, start_id_),
+  0,
+  1,
+  2,
   PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, _has_bits_),
   PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -130,17 +181,32 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_setting_2eproto::offsets[] PRO
   0,
   1,
   2,
+  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, entrance_parameter_),
+  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, export_parameter_),
+  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, plc_setting_),
+  0,
+  1,
+  2,
 };
 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 13, sizeof(::shutter::lidar_parameter)},
   { 21, 32, sizeof(::shutter::box_param)},
-  { 38, 47, sizeof(::shutter::shutter_param)},
+  { 38, 46, sizeof(::shutter::plc_param)},
+  { 49, 58, sizeof(::shutter::shutter_param)},
+  { 62, 70, sizeof(::shutter::setting_parameter)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_lidar_parameter_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_box_param_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_plc_param_default_instance_),
   reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_shutter_param_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_setting_parameter_default_instance_),
 };
 
 const char descriptor_table_protodef_setting_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
@@ -150,25 +216,33 @@ const char descriptor_table_protodef_setting_2eproto[] PROTOBUF_SECTION_VARIABLE
   "\002ty\030\006 \001(\001:\0011\022\r\n\002tz\030\007 \001(\001:\0011\022\017\n\003fps\030\010 \001(\001"
   ":\00210\"_\n\tbox_param\022\014\n\004minx\030\001 \001(\001\022\014\n\004maxx\030"
   "\002 \001(\001\022\014\n\004miny\030\003 \001(\001\022\014\n\004maxy\030\004 \001(\001\022\014\n\004min"
-  "z\030\005 \001(\001\022\014\n\004maxz\030\006 \001(\001\"\254\001\n\rshutter_param\022"
-  "(\n\006lidars\030\001 \003(\0132\030.shutter.lidar_paramete"
-  "r\022\037\n\003box\030\002 \001(\0132\022.shutter.box_param\022\'\n\013ve"
-  "rify_box1\030\003 \001(\0132\022.shutter.box_param\022\'\n\013v"
-  "erify_box2\030\004 \001(\0132\022.shutter.box_param"
+  "z\030\005 \001(\001\022\014\n\004maxz\030\006 \001(\001\">\n\tplc_param\022\n\n\002ip"
+  "\030\001 \002(\t\022\020\n\010dbnumber\030\002 \002(\005\022\023\n\010start_id\030\003 \001"
+  "(\005:\0010\"\254\001\n\rshutter_param\022(\n\006lidars\030\001 \003(\0132"
+  "\030.shutter.lidar_parameter\022\037\n\003box\030\002 \001(\0132\022"
+  ".shutter.box_param\022\'\n\013verify_box1\030\003 \001(\0132"
+  "\022.shutter.box_param\022\'\n\013verify_box2\030\004 \001(\013"
+  "2\022.shutter.box_param\"\242\001\n\021setting_paramet"
+  "er\0222\n\022entrance_parameter\030\001 \001(\0132\026.shutter"
+  ".shutter_param\0220\n\020export_parameter\030\002 \001(\013"
+  "2\026.shutter.shutter_param\022\'\n\013plc_setting\030"
+  "\003 \002(\0132\022.shutter.plc_param"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_setting_2eproto_deps[1] = {
 };
-static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_setting_2eproto_sccs[3] = {
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_setting_2eproto_sccs[5] = {
   &scc_info_box_param_setting_2eproto.base,
   &scc_info_lidar_parameter_setting_2eproto.base,
+  &scc_info_plc_param_setting_2eproto.base,
+  &scc_info_setting_parameter_setting_2eproto.base,
   &scc_info_shutter_param_setting_2eproto.base,
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_setting_2eproto_once;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_setting_2eproto = {
-  false, false, descriptor_table_protodef_setting_2eproto, "setting.proto", 436,
-  &descriptor_table_setting_2eproto_once, descriptor_table_setting_2eproto_sccs, descriptor_table_setting_2eproto_deps, 3, 0,
+  false, false, descriptor_table_protodef_setting_2eproto, "setting.proto", 665,
+  &descriptor_table_setting_2eproto_once, descriptor_table_setting_2eproto_sccs, descriptor_table_setting_2eproto_deps, 5, 0,
   schemas, file_default_instances, TableStruct_setting_2eproto::offsets,
-  file_level_metadata_setting_2eproto, 3, file_level_enum_descriptors_setting_2eproto, file_level_service_descriptors_setting_2eproto,
+  file_level_metadata_setting_2eproto, 5, file_level_enum_descriptors_setting_2eproto, file_level_service_descriptors_setting_2eproto,
 };
 
 // Force running AddDescriptors() at dynamic initialization time.
@@ -962,6 +1036,330 @@ void box_param::InternalSwap(box_param* other) {
 }
 
 
+// ===================================================================
+
+void plc_param::InitAsDefaultInstance() {
+}
+class plc_param::_Internal {
+ public:
+  using HasBits = decltype(std::declval<plc_param>()._has_bits_);
+  static void set_has_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_dbnumber(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_start_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
+  }
+};
+
+plc_param::plc_param(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:shutter.plc_param)
+}
+plc_param::plc_param(const plc_param& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (from._internal_has_ip()) {
+    ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ip(),
+      GetArena());
+  }
+  ::memcpy(&dbnumber_, &from.dbnumber_,
+    static_cast<size_t>(reinterpret_cast<char*>(&start_id_) -
+    reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
+  // @@protoc_insertion_point(copy_constructor:shutter.plc_param)
+}
+
+void plc_param::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_plc_param_setting_2eproto.base);
+  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  ::memset(&dbnumber_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&start_id_) -
+      reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
+}
+
+plc_param::~plc_param() {
+  // @@protoc_insertion_point(destructor:shutter.plc_param)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void plc_param::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void plc_param::ArenaDtor(void* object) {
+  plc_param* _this = reinterpret_cast< plc_param* >(object);
+  (void)_this;
+}
+void plc_param::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void plc_param::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const plc_param& plc_param::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_plc_param_setting_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void plc_param::Clear() {
+// @@protoc_insertion_point(message_clear_start:shutter.plc_param)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    ip_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&dbnumber_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&start_id_) -
+        reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* plc_param::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // required string ip = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_ip();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          #ifndef NDEBUG
+          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "shutter.plc_param.ip");
+          #endif  // !NDEBUG
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // required int32 dbnumber = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _Internal::set_has_dbnumber(&has_bits);
+          dbnumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // optional int32 start_id = 3 [default = 0];
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_start_id(&has_bits);
+          start_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* plc_param::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:shutter.plc_param)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required string ip = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_ip().data(), static_cast<int>(this->_internal_ip().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "shutter.plc_param.ip");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_ip(), target);
+  }
+
+  // required int32 dbnumber = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_dbnumber(), target);
+  }
+
+  // optional int32 start_id = 3 [default = 0];
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_start_id(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:shutter.plc_param)
+  return target;
+}
+
+size_t plc_param::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:shutter.plc_param)
+  size_t total_size = 0;
+
+  if (_internal_has_ip()) {
+    // required string ip = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_ip());
+  }
+
+  if (_internal_has_dbnumber()) {
+    // required int32 dbnumber = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_dbnumber());
+  }
+
+  return total_size;
+}
+size_t plc_param::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:shutter.plc_param)
+  size_t total_size = 0;
+
+  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
+    // required string ip = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_ip());
+
+    // required int32 dbnumber = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_dbnumber());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional int32 start_id = 3 [default = 0];
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000004u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_start_id());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void plc_param::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:shutter.plc_param)
+  GOOGLE_DCHECK_NE(&from, this);
+  const plc_param* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<plc_param>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.plc_param)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.plc_param)
+    MergeFrom(*source);
+  }
+}
+
+void plc_param::MergeFrom(const plc_param& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:shutter.plc_param)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _internal_set_ip(from._internal_ip());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      dbnumber_ = from.dbnumber_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      start_id_ = from.start_id_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void plc_param::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:shutter.plc_param)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void plc_param::CopyFrom(const plc_param& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:shutter.plc_param)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool plc_param::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
+  return true;
+}
+
+void plc_param::InternalSwap(plc_param* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ip_.Swap(&other->ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(plc_param, start_id_)
+      + sizeof(plc_param::start_id_)
+      - PROTOBUF_FIELD_OFFSET(plc_param, dbnumber_)>(
+          reinterpret_cast<char*>(&dbnumber_),
+          reinterpret_cast<char*>(&other->dbnumber_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata plc_param::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
 // ===================================================================
 
 void shutter_param::InitAsDefaultInstance() {
@@ -1325,6 +1723,343 @@ void shutter_param::InternalSwap(shutter_param* other) {
 }
 
 
+// ===================================================================
+
+void setting_parameter::InitAsDefaultInstance() {
+  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->entrance_parameter_ = const_cast< ::shutter::shutter_param*>(
+      ::shutter::shutter_param::internal_default_instance());
+  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->export_parameter_ = const_cast< ::shutter::shutter_param*>(
+      ::shutter::shutter_param::internal_default_instance());
+  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->plc_setting_ = const_cast< ::shutter::plc_param*>(
+      ::shutter::plc_param::internal_default_instance());
+}
+class setting_parameter::_Internal {
+ public:
+  using HasBits = decltype(std::declval<setting_parameter>()._has_bits_);
+  static const ::shutter::shutter_param& entrance_parameter(const setting_parameter* msg);
+  static void set_has_entrance_parameter(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::shutter::shutter_param& export_parameter(const setting_parameter* msg);
+  static void set_has_export_parameter(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::shutter::plc_param& plc_setting(const setting_parameter* msg);
+  static void set_has_plc_setting(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0;
+  }
+};
+
+const ::shutter::shutter_param&
+setting_parameter::_Internal::entrance_parameter(const setting_parameter* msg) {
+  return *msg->entrance_parameter_;
+}
+const ::shutter::shutter_param&
+setting_parameter::_Internal::export_parameter(const setting_parameter* msg) {
+  return *msg->export_parameter_;
+}
+const ::shutter::plc_param&
+setting_parameter::_Internal::plc_setting(const setting_parameter* msg) {
+  return *msg->plc_setting_;
+}
+setting_parameter::setting_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:shutter.setting_parameter)
+}
+setting_parameter::setting_parameter(const setting_parameter& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_entrance_parameter()) {
+    entrance_parameter_ = new ::shutter::shutter_param(*from.entrance_parameter_);
+  } else {
+    entrance_parameter_ = nullptr;
+  }
+  if (from._internal_has_export_parameter()) {
+    export_parameter_ = new ::shutter::shutter_param(*from.export_parameter_);
+  } else {
+    export_parameter_ = nullptr;
+  }
+  if (from._internal_has_plc_setting()) {
+    plc_setting_ = new ::shutter::plc_param(*from.plc_setting_);
+  } else {
+    plc_setting_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:shutter.setting_parameter)
+}
+
+void setting_parameter::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_setting_parameter_setting_2eproto.base);
+  ::memset(&entrance_parameter_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&plc_setting_) -
+      reinterpret_cast<char*>(&entrance_parameter_)) + sizeof(plc_setting_));
+}
+
+setting_parameter::~setting_parameter() {
+  // @@protoc_insertion_point(destructor:shutter.setting_parameter)
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void setting_parameter::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  if (this != internal_default_instance()) delete entrance_parameter_;
+  if (this != internal_default_instance()) delete export_parameter_;
+  if (this != internal_default_instance()) delete plc_setting_;
+}
+
+void setting_parameter::ArenaDtor(void* object) {
+  setting_parameter* _this = reinterpret_cast< setting_parameter* >(object);
+  (void)_this;
+}
+void setting_parameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void setting_parameter::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const setting_parameter& setting_parameter::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_setting_parameter_setting_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void setting_parameter::Clear() {
+// @@protoc_insertion_point(message_clear_start:shutter.setting_parameter)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(entrance_parameter_ != nullptr);
+      entrance_parameter_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(export_parameter_ != nullptr);
+      export_parameter_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(plc_setting_ != nullptr);
+      plc_setting_->Clear();
+    }
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* setting_parameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // optional .shutter.shutter_param entrance_parameter = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_entrance_parameter(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // optional .shutter.shutter_param export_parameter = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_export_parameter(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // required .shutter.plc_param plc_setting = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_plc_setting(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* setting_parameter::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:shutter.setting_parameter)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // optional .shutter.shutter_param entrance_parameter = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::entrance_parameter(this), target, stream);
+  }
+
+  // optional .shutter.shutter_param export_parameter = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::export_parameter(this), target, stream);
+  }
+
+  // required .shutter.plc_param plc_setting = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::plc_setting(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:shutter.setting_parameter)
+  return target;
+}
+
+size_t setting_parameter::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:shutter.setting_parameter)
+  size_t total_size = 0;
+
+  // required .shutter.plc_param plc_setting = 3;
+  if (_internal_has_plc_setting()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *plc_setting_);
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .shutter.shutter_param entrance_parameter = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *entrance_parameter_);
+    }
+
+    // optional .shutter.shutter_param export_parameter = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *export_parameter_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void setting_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:shutter.setting_parameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  const setting_parameter* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<setting_parameter>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.setting_parameter)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.setting_parameter)
+    MergeFrom(*source);
+  }
+}
+
+void setting_parameter::MergeFrom(const setting_parameter& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:shutter.setting_parameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _internal_mutable_entrance_parameter()->::shutter::shutter_param::MergeFrom(from._internal_entrance_parameter());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _internal_mutable_export_parameter()->::shutter::shutter_param::MergeFrom(from._internal_export_parameter());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _internal_mutable_plc_setting()->::shutter::plc_param::MergeFrom(from._internal_plc_setting());
+    }
+  }
+}
+
+void setting_parameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:shutter.setting_parameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void setting_parameter::CopyFrom(const setting_parameter& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:shutter.setting_parameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool setting_parameter::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
+  if (_internal_has_plc_setting()) {
+    if (!plc_setting_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void setting_parameter::InternalSwap(setting_parameter* other) {
+  using std::swap;
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(setting_parameter, plc_setting_)
+      + sizeof(setting_parameter::plc_setting_)
+      - PROTOBUF_FIELD_OFFSET(setting_parameter, entrance_parameter_)>(
+          reinterpret_cast<char*>(&entrance_parameter_),
+          reinterpret_cast<char*>(&other->entrance_parameter_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata setting_parameter::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace shutter
 PROTOBUF_NAMESPACE_OPEN
@@ -1334,9 +2069,15 @@ template<> PROTOBUF_NOINLINE ::shutter::lidar_parameter* Arena::CreateMaybeMessa
 template<> PROTOBUF_NOINLINE ::shutter::box_param* Arena::CreateMaybeMessage< ::shutter::box_param >(Arena* arena) {
   return Arena::CreateMessageInternal< ::shutter::box_param >(arena);
 }
+template<> PROTOBUF_NOINLINE ::shutter::plc_param* Arena::CreateMaybeMessage< ::shutter::plc_param >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::shutter::plc_param >(arena);
+}
 template<> PROTOBUF_NOINLINE ::shutter::shutter_param* Arena::CreateMaybeMessage< ::shutter::shutter_param >(Arena* arena) {
   return Arena::CreateMessageInternal< ::shutter::shutter_param >(arena);
 }
+template<> PROTOBUF_NOINLINE ::shutter::setting_parameter* Arena::CreateMaybeMessage< ::shutter::setting_parameter >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::shutter::setting_parameter >(arena);
+}
 PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(global_scope)

setting.pb.h

@@ -47,7 +47,7 @@ struct TableStruct_setting_2eproto {
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
     PROTOBUF_SECTION_VARIABLE(protodesc_cold);
   static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
   static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -61,6 +61,12 @@ extern box_paramDefaultTypeInternal _box_param_default_instance_;
 class lidar_parameter;
 class lidar_parameterDefaultTypeInternal;
 extern lidar_parameterDefaultTypeInternal _lidar_parameter_default_instance_;
+class plc_param;
+class plc_paramDefaultTypeInternal;
+extern plc_paramDefaultTypeInternal _plc_param_default_instance_;
+class setting_parameter;
+class setting_parameterDefaultTypeInternal;
+extern setting_parameterDefaultTypeInternal _setting_parameter_default_instance_;
 class shutter_param;
 class shutter_paramDefaultTypeInternal;
 extern shutter_paramDefaultTypeInternal _shutter_param_default_instance_;
@@ -68,6 +74,8 @@ extern shutter_paramDefaultTypeInternal _shutter_param_default_instance_;
 PROTOBUF_NAMESPACE_OPEN
 template<> ::shutter::box_param* Arena::CreateMaybeMessage<::shutter::box_param>(Arena*);
 template<> ::shutter::lidar_parameter* Arena::CreateMaybeMessage<::shutter::lidar_parameter>(Arena*);
+template<> ::shutter::plc_param* Arena::CreateMaybeMessage<::shutter::plc_param>(Arena*);
+template<> ::shutter::setting_parameter* Arena::CreateMaybeMessage<::shutter::setting_parameter>(Arena*);
 template<> ::shutter::shutter_param* Arena::CreateMaybeMessage<::shutter::shutter_param>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace shutter {
@@ -559,6 +567,195 @@ class box_param PROTOBUF_FINAL :
 };
 // -------------------------------------------------------------------
 
+class plc_param PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:shutter.plc_param) */ {
+ public:
+  inline plc_param() : plc_param(nullptr) {}
+  virtual ~plc_param();
+
+  plc_param(const plc_param& from);
+  plc_param(plc_param&& from) noexcept
+    : plc_param() {
+    *this = ::std::move(from);
+  }
+
+  inline plc_param& operator=(const plc_param& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline plc_param& operator=(plc_param&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const plc_param& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const plc_param* internal_default_instance() {
+    return reinterpret_cast<const plc_param*>(
+               &_plc_param_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(plc_param& a, plc_param& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(plc_param* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(plc_param* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline plc_param* New() const final {
+    return CreateMaybeMessage<plc_param>(nullptr);
+  }
+
+  plc_param* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<plc_param>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const plc_param& from);
+  void MergeFrom(const plc_param& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(plc_param* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "shutter.plc_param";
+  }
+  protected:
+  explicit plc_param(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_setting_2eproto);
+    return ::descriptor_table_setting_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIpFieldNumber = 1,
+    kDbnumberFieldNumber = 2,
+    kStartIdFieldNumber = 3,
+  };
+  // required string ip = 1;
+  bool has_ip() const;
+  private:
+  bool _internal_has_ip() const;
+  public:
+  void clear_ip();
+  const std::string& ip() const;
+  void set_ip(const std::string& value);
+  void set_ip(std::string&& value);
+  void set_ip(const char* value);
+  void set_ip(const char* value, size_t size);
+  std::string* mutable_ip();
+  std::string* release_ip();
+  void set_allocated_ip(std::string* ip);
+  private:
+  const std::string& _internal_ip() const;
+  void _internal_set_ip(const std::string& value);
+  std::string* _internal_mutable_ip();
+  public:
+
+  // required int32 dbnumber = 2;
+  bool has_dbnumber() const;
+  private:
+  bool _internal_has_dbnumber() const;
+  public:
+  void clear_dbnumber();
+  ::PROTOBUF_NAMESPACE_ID::int32 dbnumber() const;
+  void set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_dbnumber() const;
+  void _internal_set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // optional int32 start_id = 3 [default = 0];
+  bool has_start_id() const;
+  private:
+  bool _internal_has_start_id() const;
+  public:
+  void clear_start_id();
+  ::PROTOBUF_NAMESPACE_ID::int32 start_id() const;
+  void set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_start_id() const;
+  void _internal_set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:shutter.plc_param)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
+  ::PROTOBUF_NAMESPACE_ID::int32 dbnumber_;
+  ::PROTOBUF_NAMESPACE_ID::int32 start_id_;
+  friend struct ::TableStruct_setting_2eproto;
+};
+// -------------------------------------------------------------------
+
 class shutter_param PROTOBUF_FINAL :
     public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:shutter.shutter_param) */ {
  public:
@@ -608,7 +805,7 @@ class shutter_param PROTOBUF_FINAL :
                &_shutter_param_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    2;
+    3;
 
   friend void swap(shutter_param& a, shutter_param& b) {
     a.Swap(&b);
@@ -771,6 +968,200 @@ class shutter_param PROTOBUF_FINAL :
   ::shutter::box_param* verify_box2_;
   friend struct ::TableStruct_setting_2eproto;
 };
+// -------------------------------------------------------------------
+
+class setting_parameter PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:shutter.setting_parameter) */ {
+ public:
+  inline setting_parameter() : setting_parameter(nullptr) {}
+  virtual ~setting_parameter();
+
+  setting_parameter(const setting_parameter& from);
+  setting_parameter(setting_parameter&& from) noexcept
+    : setting_parameter() {
+    *this = ::std::move(from);
+  }
+
+  inline setting_parameter& operator=(const setting_parameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline setting_parameter& operator=(setting_parameter&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const setting_parameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const setting_parameter* internal_default_instance() {
+    return reinterpret_cast<const setting_parameter*>(
+               &_setting_parameter_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(setting_parameter& a, setting_parameter& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(setting_parameter* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(setting_parameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline setting_parameter* New() const final {
+    return CreateMaybeMessage<setting_parameter>(nullptr);
+  }
+
+  setting_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<setting_parameter>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const setting_parameter& from);
+  void MergeFrom(const setting_parameter& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(setting_parameter* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "shutter.setting_parameter";
+  }
+  protected:
+  explicit setting_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_setting_2eproto);
+    return ::descriptor_table_setting_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntranceParameterFieldNumber = 1,
+    kExportParameterFieldNumber = 2,
+    kPlcSettingFieldNumber = 3,
+  };
+  // optional .shutter.shutter_param entrance_parameter = 1;
+  bool has_entrance_parameter() const;
+  private:
+  bool _internal_has_entrance_parameter() const;
+  public:
+  void clear_entrance_parameter();
+  const ::shutter::shutter_param& entrance_parameter() const;
+  ::shutter::shutter_param* release_entrance_parameter();
+  ::shutter::shutter_param* mutable_entrance_parameter();
+  void set_allocated_entrance_parameter(::shutter::shutter_param* entrance_parameter);
+  private:
+  const ::shutter::shutter_param& _internal_entrance_parameter() const;
+  ::shutter::shutter_param* _internal_mutable_entrance_parameter();
+  public:
+  void unsafe_arena_set_allocated_entrance_parameter(
+      ::shutter::shutter_param* entrance_parameter);
+  ::shutter::shutter_param* unsafe_arena_release_entrance_parameter();
+
+  // optional .shutter.shutter_param export_parameter = 2;
+  bool has_export_parameter() const;
+  private:
+  bool _internal_has_export_parameter() const;
+  public:
+  void clear_export_parameter();
+  const ::shutter::shutter_param& export_parameter() const;
+  ::shutter::shutter_param* release_export_parameter();
+  ::shutter::shutter_param* mutable_export_parameter();
+  void set_allocated_export_parameter(::shutter::shutter_param* export_parameter);
+  private:
+  const ::shutter::shutter_param& _internal_export_parameter() const;
+  ::shutter::shutter_param* _internal_mutable_export_parameter();
+  public:
+  void unsafe_arena_set_allocated_export_parameter(
+      ::shutter::shutter_param* export_parameter);
+  ::shutter::shutter_param* unsafe_arena_release_export_parameter();
+
+  // required .shutter.plc_param plc_setting = 3;
+  bool has_plc_setting() const;
+  private:
+  bool _internal_has_plc_setting() const;
+  public:
+  void clear_plc_setting();
+  const ::shutter::plc_param& plc_setting() const;
+  ::shutter::plc_param* release_plc_setting();
+  ::shutter::plc_param* mutable_plc_setting();
+  void set_allocated_plc_setting(::shutter::plc_param* plc_setting);
+  private:
+  const ::shutter::plc_param& _internal_plc_setting() const;
+  ::shutter::plc_param* _internal_mutable_plc_setting();
+  public:
+  void unsafe_arena_set_allocated_plc_setting(
+      ::shutter::plc_param* plc_setting);
+  ::shutter::plc_param* unsafe_arena_release_plc_setting();
+
+  // @@protoc_insertion_point(class_scope:shutter.setting_parameter)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::shutter::shutter_param* entrance_parameter_;
+  ::shutter::shutter_param* export_parameter_;
+  ::shutter::plc_param* plc_setting_;
+  friend struct ::TableStruct_setting_2eproto;
+};
 // ===================================================================
 
 
@@ -1226,6 +1617,140 @@ inline void box_param::set_maxz(double value) {
 
 // -------------------------------------------------------------------
 
+// plc_param
+
+// required string ip = 1;
+inline bool plc_param::_internal_has_ip() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool plc_param::has_ip() const {
+  return _internal_has_ip();
+}
+inline void plc_param::clear_ip() {
+  ip_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& plc_param::ip() const {
+  // @@protoc_insertion_point(field_get:shutter.plc_param.ip)
+  return _internal_ip();
+}
+inline void plc_param::set_ip(const std::string& value) {
+  _internal_set_ip(value);
+  // @@protoc_insertion_point(field_set:shutter.plc_param.ip)
+}
+inline std::string* plc_param::mutable_ip() {
+  // @@protoc_insertion_point(field_mutable:shutter.plc_param.ip)
+  return _internal_mutable_ip();
+}
+inline const std::string& plc_param::_internal_ip() const {
+  return ip_.Get();
+}
+inline void plc_param::_internal_set_ip(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
+}
+inline void plc_param::set_ip(std::string&& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ip_.Set(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
+  // @@protoc_insertion_point(field_set_rvalue:shutter.plc_param.ip)
+}
+inline void plc_param::set_ip(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _has_bits_[0] |= 0x00000001u;
+  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArena());
+  // @@protoc_insertion_point(field_set_char:shutter.plc_param.ip)
+}
+inline void plc_param::set_ip(const char* value,
+    size_t size) {
+  _has_bits_[0] |= 0x00000001u;
+  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
+  // @@protoc_insertion_point(field_set_pointer:shutter.plc_param.ip)
+}
+inline std::string* plc_param::_internal_mutable_ip() {
+  _has_bits_[0] |= 0x00000001u;
+  return ip_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline std::string* plc_param::release_ip() {
+  // @@protoc_insertion_point(field_release:shutter.plc_param.ip)
+  if (!_internal_has_ip()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return ip_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void plc_param::set_allocated_ip(std::string* ip) {
+  if (ip != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip,
+      GetArena());
+  // @@protoc_insertion_point(field_set_allocated:shutter.plc_param.ip)
+}
+
+// required int32 dbnumber = 2;
+inline bool plc_param::_internal_has_dbnumber() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool plc_param::has_dbnumber() const {
+  return _internal_has_dbnumber();
+}
+inline void plc_param::clear_dbnumber() {
+  dbnumber_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::_internal_dbnumber() const {
+  return dbnumber_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::dbnumber() const {
+  // @@protoc_insertion_point(field_get:shutter.plc_param.dbnumber)
+  return _internal_dbnumber();
+}
+inline void plc_param::_internal_set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  dbnumber_ = value;
+}
+inline void plc_param::set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_dbnumber(value);
+  // @@protoc_insertion_point(field_set:shutter.plc_param.dbnumber)
+}
+
+// optional int32 start_id = 3 [default = 0];
+inline bool plc_param::_internal_has_start_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool plc_param::has_start_id() const {
+  return _internal_has_start_id();
+}
+inline void plc_param::clear_start_id() {
+  start_id_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::_internal_start_id() const {
+  return start_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::start_id() const {
+  // @@protoc_insertion_point(field_get:shutter.plc_param.start_id)
+  return _internal_start_id();
+}
+inline void plc_param::_internal_set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  start_id_ = value;
+}
+inline void plc_param::set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_start_id(value);
+  // @@protoc_insertion_point(field_set:shutter.plc_param.start_id)
+}
+
+// -------------------------------------------------------------------
+
 // shutter_param
 
 // repeated .shutter.lidar_parameter lidars = 1;
@@ -1516,6 +2041,259 @@ inline void shutter_param::set_allocated_verify_box2(::shutter::box_param* verif
   // @@protoc_insertion_point(field_set_allocated:shutter.shutter_param.verify_box2)
 }
 
+// -------------------------------------------------------------------
+
+// setting_parameter
+
+// optional .shutter.shutter_param entrance_parameter = 1;
+inline bool setting_parameter::_internal_has_entrance_parameter() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || entrance_parameter_ != nullptr);
+  return value;
+}
+inline bool setting_parameter::has_entrance_parameter() const {
+  return _internal_has_entrance_parameter();
+}
+inline void setting_parameter::clear_entrance_parameter() {
+  if (entrance_parameter_ != nullptr) entrance_parameter_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::shutter::shutter_param& setting_parameter::_internal_entrance_parameter() const {
+  const ::shutter::shutter_param* p = entrance_parameter_;
+  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::shutter_param*>(
+      &::shutter::_shutter_param_default_instance_);
+}
+inline const ::shutter::shutter_param& setting_parameter::entrance_parameter() const {
+  // @@protoc_insertion_point(field_get:shutter.setting_parameter.entrance_parameter)
+  return _internal_entrance_parameter();
+}
+inline void setting_parameter::unsafe_arena_set_allocated_entrance_parameter(
+    ::shutter::shutter_param* entrance_parameter) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entrance_parameter_);
+  }
+  entrance_parameter_ = entrance_parameter;
+  if (entrance_parameter) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.entrance_parameter)
+}
+inline ::shutter::shutter_param* setting_parameter::release_entrance_parameter() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::shutter::shutter_param* temp = entrance_parameter_;
+  entrance_parameter_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
+}
+inline ::shutter::shutter_param* setting_parameter::unsafe_arena_release_entrance_parameter() {
+  // @@protoc_insertion_point(field_release:shutter.setting_parameter.entrance_parameter)
+  _has_bits_[0] &= ~0x00000001u;
+  ::shutter::shutter_param* temp = entrance_parameter_;
+  entrance_parameter_ = nullptr;
+  return temp;
+}
+inline ::shutter::shutter_param* setting_parameter::_internal_mutable_entrance_parameter() {
+  _has_bits_[0] |= 0x00000001u;
+  if (entrance_parameter_ == nullptr) {
+    auto* p = CreateMaybeMessage<::shutter::shutter_param>(GetArena());
+    entrance_parameter_ = p;
+  }
+  return entrance_parameter_;
+}
+inline ::shutter::shutter_param* setting_parameter::mutable_entrance_parameter() {
+  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.entrance_parameter)
+  return _internal_mutable_entrance_parameter();
+}
+inline void setting_parameter::set_allocated_entrance_parameter(::shutter::shutter_param* entrance_parameter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete entrance_parameter_;
+  }
+  if (entrance_parameter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(entrance_parameter);
+    if (message_arena != submessage_arena) {
+      entrance_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, entrance_parameter, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  entrance_parameter_ = entrance_parameter;
+  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.entrance_parameter)
+}
+
+// optional .shutter.shutter_param export_parameter = 2;
+inline bool setting_parameter::_internal_has_export_parameter() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || export_parameter_ != nullptr);
+  return value;
+}
+inline bool setting_parameter::has_export_parameter() const {
+  return _internal_has_export_parameter();
+}
+inline void setting_parameter::clear_export_parameter() {
+  if (export_parameter_ != nullptr) export_parameter_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::shutter::shutter_param& setting_parameter::_internal_export_parameter() const {
+  const ::shutter::shutter_param* p = export_parameter_;
+  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::shutter_param*>(
+      &::shutter::_shutter_param_default_instance_);
+}
+inline const ::shutter::shutter_param& setting_parameter::export_parameter() const {
+  // @@protoc_insertion_point(field_get:shutter.setting_parameter.export_parameter)
+  return _internal_export_parameter();
+}
+inline void setting_parameter::unsafe_arena_set_allocated_export_parameter(
+    ::shutter::shutter_param* export_parameter) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(export_parameter_);
+  }
+  export_parameter_ = export_parameter;
+  if (export_parameter) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.export_parameter)
+}
+inline ::shutter::shutter_param* setting_parameter::release_export_parameter() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::shutter::shutter_param* temp = export_parameter_;
+  export_parameter_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
+}
+inline ::shutter::shutter_param* setting_parameter::unsafe_arena_release_export_parameter() {
+  // @@protoc_insertion_point(field_release:shutter.setting_parameter.export_parameter)
+  _has_bits_[0] &= ~0x00000002u;
+  ::shutter::shutter_param* temp = export_parameter_;
+  export_parameter_ = nullptr;
+  return temp;
+}
+inline ::shutter::shutter_param* setting_parameter::_internal_mutable_export_parameter() {
+  _has_bits_[0] |= 0x00000002u;
+  if (export_parameter_ == nullptr) {
+    auto* p = CreateMaybeMessage<::shutter::shutter_param>(GetArena());
+    export_parameter_ = p;
+  }
+  return export_parameter_;
+}
+inline ::shutter::shutter_param* setting_parameter::mutable_export_parameter() {
+  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.export_parameter)
+  return _internal_mutable_export_parameter();
+}
+inline void setting_parameter::set_allocated_export_parameter(::shutter::shutter_param* export_parameter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete export_parameter_;
+  }
+  if (export_parameter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(export_parameter);
+    if (message_arena != submessage_arena) {
+      export_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, export_parameter, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  export_parameter_ = export_parameter;
+  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.export_parameter)
+}
+
+// required .shutter.plc_param plc_setting = 3;
+inline bool setting_parameter::_internal_has_plc_setting() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || plc_setting_ != nullptr);
+  return value;
+}
+inline bool setting_parameter::has_plc_setting() const {
+  return _internal_has_plc_setting();
+}
+inline void setting_parameter::clear_plc_setting() {
+  if (plc_setting_ != nullptr) plc_setting_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::shutter::plc_param& setting_parameter::_internal_plc_setting() const {
+  const ::shutter::plc_param* p = plc_setting_;
+  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::plc_param*>(
+      &::shutter::_plc_param_default_instance_);
+}
+inline const ::shutter::plc_param& setting_parameter::plc_setting() const {
+  // @@protoc_insertion_point(field_get:shutter.setting_parameter.plc_setting)
+  return _internal_plc_setting();
+}
+inline void setting_parameter::unsafe_arena_set_allocated_plc_setting(
+    ::shutter::plc_param* plc_setting) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(plc_setting_);
+  }
+  plc_setting_ = plc_setting;
+  if (plc_setting) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.plc_setting)
+}
+inline ::shutter::plc_param* setting_parameter::release_plc_setting() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::shutter::plc_param* temp = plc_setting_;
+  plc_setting_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
+}
+inline ::shutter::plc_param* setting_parameter::unsafe_arena_release_plc_setting() {
+  // @@protoc_insertion_point(field_release:shutter.setting_parameter.plc_setting)
+  _has_bits_[0] &= ~0x00000004u;
+  ::shutter::plc_param* temp = plc_setting_;
+  plc_setting_ = nullptr;
+  return temp;
+}
+inline ::shutter::plc_param* setting_parameter::_internal_mutable_plc_setting() {
+  _has_bits_[0] |= 0x00000004u;
+  if (plc_setting_ == nullptr) {
+    auto* p = CreateMaybeMessage<::shutter::plc_param>(GetArena());
+    plc_setting_ = p;
+  }
+  return plc_setting_;
+}
+inline ::shutter::plc_param* setting_parameter::mutable_plc_setting() {
+  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.plc_setting)
+  return _internal_mutable_plc_setting();
+}
+inline void setting_parameter::set_allocated_plc_setting(::shutter::plc_param* plc_setting) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete plc_setting_;
+  }
+  if (plc_setting) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(plc_setting);
+    if (message_arena != submessage_arena) {
+      plc_setting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, plc_setting, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  plc_setting_ = plc_setting;
+  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.plc_setting)
+}
+
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
 #endif  // __GNUC__
@@ -1523,6 +2301,10 @@ inline void shutter_param::set_allocated_verify_box2(::shutter::box_param* verif
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

setting.proto

@@ -22,10 +22,24 @@ message box_param
     optional double maxz=6;
 }
 
+message plc_param
+{
+    required string  ip=1;
+    required int32   dbnumber=2;
+    optional int32   start_id=3 [default=0];
+}
+
 message shutter_param
 {
    repeated lidar_parameter     lidars=1;
    optional box_param           box=2;
    optional box_param           verify_box1=3;
    optional box_param           verify_box2=4;
+}
+
+message setting_parameter
+{
+    optional shutter_param      entrance_parameter=1;
+    optional shutter_param      export_parameter=2;
+    required plc_param          plc_setting=3;
 }