How to use launch method in Puppeteer

1const axios = require('axios');
2// Linking our mongodb launches collection
3const launchesDatabase = require('./launches.mongo');
4const planets = require('./planets.mongo');
5
6// Default flight number in case our getLatestLaunch function has no launches to reference
7const DEFAULT_FLIGHT_NUMBER = 100;
8
9// SpaceX API url
10const SPACEX_API_URL = "https://api.spacexdata.com/v4/launches/query";
11
12// Saving SpaceX launches to our database
13async function populateLaunches() {
14    console.log("Downloading launches data...");
15    const response = await axios.post(SPACEX_API_URL, {
16        query: {},
17        options: {
18            pagination: false,
19            populate: [
20                {
21                    path: 'rocket',
22                    select: {
23                        name: 1
24                    }
25
26                },
27                {
28                    path: 'payloads',
29                    select: {
30                        'customers': 1
31                    }
32                }
33            ]
34        }
35    });
36
37    if (response.status != 200) {
38        console.log('Problem downloading launch data');
39        throw new Error('Launch data download failed');
40    }
41    // Response from our axios query for launch data, which axios stores in a docs array in the response.data   
42    const launchDocs = response.data.docs
43    // Looping over the launch data to make a launch object to save in our database
44    for (const launchDoc of launchDocs) {
45        // Using the built in flatMap() function to make a new array out of each element in the array where customers are stored, it is called on an array and takes a callback which runs on each element and then combines the results of each into a new array
46        const payloads = launchDoc['payloads'];
47        // Iterating over each payload and taking each customers value for each payload and combining them into an array to use in our new launch document, creating the new document, and saving it to mongodb
48        const customers = payloads.flatMap((payload) => {
49            return payload['customers'];
50        });
51
52        const launch = {
53            flightNumber: launchDoc['flight_number'],
54            mission: launchDoc['name'],
55            rocket: launchDoc['rocket']['name'],
56            launchDate: launchDoc['date_local'],
57            upcoming: launchDoc['upcoming'],
58            success: launchDoc['success'],
59            customers
60        }
61        console.log(`${launch.flightNumber}, ${launch.mission}`);
62        // Populate launches collection
63        await saveLaunch(launch);
64    }
65}
66// Loading all the SpaceX launch data we need with axios
67async function loadLaunchesData() {
68    // Checking if the data has already been loaded
69    const firstLaunch = await findLaunch({
70        flightNumber: 1,
71        rocket: 'Falcon 1',
72        mission: 'FalconSat'
73    });
74    if (firstLaunch) {
75        console.log('Launch data already loaded');
76    } else {
77        await populateLaunches();
78    }
79}
80
81// Function to use to only add launches not in our database already
82async function findLaunch(filter) {
83    return await launchesDatabase.findOne(filter);
84}
85// See if a launch exists within our database
86async function existsLaunchWithId(launchId) {
87    return await findLaunch({
88        flightNumber: launchId
89    });
90}
91
92// Get our latest flight number from the database using a filter that finds the highest flight number value
93async function getLatestFlightNumber() {
94    const latestLaunch = await launchesDatabase
95        .findOne()
96        .sort('-flightNumber');
97
98    if (!latestLaunch) {
99        return DEFAULT_FLIGHT_NUMBER;
100    }
101
102    return latestLaunch.flightNumber;
103}
104
105// GET all launches
106async function getAllLaunches(skip, limit) {
107    return await launchesDatabase
108    .find({}, { '_id': 0, '__v': 0})
109    .sort({ flightNumber: 1 })
110    .skip(skip)
111    .limit(limit);
112}
113
114// Saving launches to mongodb
115async function saveLaunch(launch) {
116    // Saving a doocument with the newly passed in launch object, or updating it if it already exists by flight number
117    try {
118        await launchesDatabase.findOneAndUpdate({
119            flightNumber: launch.flightNumber,
120        }, launch, {
121            upsert: true
122        })} catch(err) {
123                return console.error(`Could not save launch ${err}`); 
124    }
125}
126
127// Adding a document containing a new launch to mongodb
128async function scheduleNewLaunch(launch) {
129    // Validating the planet exists, so we do not add launches to planets that do not exist in our database
130    const planet = await planets.findOne({
131        keplerName: launch.target
132    });
133
134    if (!planet) {
135        throw new Error('No matching planet was found');
136    }
137
138    const newFlightNumber = await getLatestFlightNumber() + 1;
139
140    const newLaunch = Object.assign(launch, {
141        success: true,
142        upcoming: true,
143        customers: ['ZTM', 'NASA'],
144        flightNumber: newFlightNumber
145    });
146
147    await saveLaunch(newLaunch);
148}
149
150// Rather than deleting aborted launches outright, update them to show they are not successful and are no longer upcoming
151async function abortLaunchById(launchId) {
152    const aborted = await launchesDatabase.updateOne({
153        flightNumber: launchId
154    }, {
155        upcoming: false,
156        success: false
157    });
158    /* Returning that a document was modified, and that one document was modified. We can see this object by reading the res.json from our controller function if we simply  used the above await updateOne operation, like below
159    const aborted = await abortLaunchById(launchId);
160    return res.status(200).json(aborted); */
161    return aborted.modifiedCount === 1;
162}
163
164module.exports = {
165    loadLaunchesData,
166    existsLaunchWithId,
167    getAllLaunches,
168    scheduleNewLaunch,
169    abortLaunchById
170};

Source: launches.model.js

const axios = require('axios');
// Linking our mongodb launches collection
const launchesDatabase = require('./launches.mongo');
const planets = require('./planets.mongo');

// Default flight number in case our getLatestLaunch function has no launches to reference
const DEFAULT_FLIGHT_NUMBER = 100;

// SpaceX API url
const SPACEX_API_URL = "https://api.spacexdata.com/v4/launches/query";

// Saving SpaceX launches to our database
async function populateLaunches() {
    console.log("Downloading launches data...");
    const response = await axios.post(SPACEX_API_URL, {
        query: {},
        options: {
            pagination: false,
            populate: [
                {
                    path: 'rocket',
                    select: {
                        name: 1
                    }

                },
                {
                    path: 'payloads',
                    select: {
                        'customers': 1
                    }
                }
            ]
        }
    });

    if (response.status != 200) {
        console.log('Problem downloading launch data');
        throw new Error('Launch data download failed');
    }
    // Response from our axios query for launch data, which axios stores in a docs array in the response.data   
    const launchDocs = response.data.docs
    // Looping over the launch data to make a launch object to save in our database
    for (const launchDoc of launchDocs) {
        // Using the built in flatMap() function to make a new array out of each element in the array where customers are stored, it is called on an array and takes a callback which runs on each element and then combines the results of each into a new array
        const payloads = launchDoc['payloads'];
        // Iterating over each payload and taking each customers value for each payload and combining them into an array to use in our new launch document, creating the new document, and saving it to mongodb
        const customers = payloads.flatMap((payload) => {
            return payload['customers'];
        });

        const launch = {
            flightNumber: launchDoc['flight_number'],
            mission: launchDoc['name'],
            rocket: launchDoc['rocket']['name'],
            launchDate: launchDoc['date_local'],
            upcoming: launchDoc['upcoming'],
            success: launchDoc['success'],
            customers
        }
        console.log(`${launch.flightNumber}, ${launch.mission}`);
        // Populate launches collection
        await saveLaunch(launch);
    }
}
// Loading all the SpaceX launch data we need with axios
async function loadLaunchesData() {
    // Checking if the data has already been loaded
    const firstLaunch = await findLaunch({
        flightNumber: 1,
        rocket: 'Falcon 1',
        mission: 'FalconSat'
    });
    if (firstLaunch) {
        console.log('Launch data already loaded');
    } else {
        await populateLaunches();
    }
}

// Function to use to only add launches not in our database already
async function findLaunch(filter) {
    return await launchesDatabase.findOne(filter);
}
// See if a launch exists within our database
async function existsLaunchWithId(launchId) {
    return await findLaunch({
        flightNumber: launchId
    });
}

// Get our latest flight number from the database using a filter that finds the highest flight number value
async function getLatestFlightNumber() {
    const latestLaunch = await launchesDatabase
        .findOne()
        .sort('-flightNumber');

    if (!latestLaunch) {
        return DEFAULT_FLIGHT_NUMBER;
    }

    return latestLaunch.flightNumber;
}

// GET all launches
async function getAllLaunches(skip, limit) {
    return await launchesDatabase
    .find({}, { '_id': 0, '__v': 0})
    .sort({ flightNumber: 1 })
    .skip(skip)
    .limit(limit);
}

// Saving launches to mongodb
async function saveLaunch(launch) {
    // Saving a doocument with the newly passed in launch object, or updating it if it already exists by flight number
    try {
        await launchesDatabase.findOneAndUpdate({
            flightNumber: launch.flightNumber,
        }, launch, {
            upsert: true
        })} catch(err) {
                return console.error(`Could not save launch ${err}`); 
    }
}

// Adding a document containing a new launch to mongodb
async function scheduleNewLaunch(launch) {
    // Validating the planet exists, so we do not add launches to planets that do not exist in our database
    const planet = await planets.findOne({
        keplerName: launch.target
    });

    if (!planet) {
        throw new Error('No matching planet was found');
    }

    const newFlightNumber = await getLatestFlightNumber() + 1;

    const newLaunch = Object.assign(launch, {
        success: true,
        upcoming: true,
        customers: ['ZTM', 'NASA'],
        flightNumber: newFlightNumber
    });

    await saveLaunch(newLaunch);
}

// Rather than deleting aborted launches outright, update them to show they are not successful and are no longer upcoming
async function abortLaunchById(launchId) {
    const aborted = await launchesDatabase.updateOne({
        flightNumber: launchId
    }, {
        upcoming: false,
        success: false
    });
    /* Returning that a document was modified, and that one document was modified. We can see this object by reading the res.json from our controller function if we simply  used the above await updateOne operation, like below
    const aborted = await abortLaunchById(launchId);
    return res.status(200).json(aborted); */
    return aborted.modifiedCount === 1;
}

module.exports = {
    loadLaunchesData,
    existsLaunchWithId,
    getAllLaunches,
    scheduleNewLaunch,
    abortLaunchById
};

1const { RESTDataSource } = require('apollo-datasource-rest');
2
3class LaunchAPI extends RESTDataSource {
4  constructor() {
5    super();
6    this.baseURL = 'https://api.spacexdata.com/v2/';
7  }
8
9  // Create a rocket object although it is based on a launch
10  rocketReducer(launch) {
11    let launchFailureDetails = null
12    if(launch.launch_failure_details) {
13      launchFailureDetails = launch.launch_failure_details.reason
14    }
15    return {
16      id: launch.rocket.rocket_id,
17      name: launch.rocket.rocket_name,
18      mission: {
19        name: launch.mission_name,
20        launchDateLocal: launch.launch_date_local,
21        launchSuccess: launch.launch_success,
22        launchFailureDetails: launchFailureDetails,
23        missionPatchSmall:launch.links.mission_patch_small
24      },
25      site: {
26        name: launch.launch_site.site_name
27      }
28    }
29  };
30
31  // Group launches by rocket id
32  groupRockets(launches) {
33    const launchesByRocket = new Map();
34    let rocketId, rocketLaunches;
35    launches.forEach((launch) => {
36      rocketId = launch.rocket.rocket_id;
37      rocketLaunches = launchesByRocket.get(rocketId);
38      if (!rocketLaunches) {
39        launchesByRocket.set(rocketId, launch);
40      } else {
41        // To simplify the project, I'll use only one launch per rocket
42        // rocketLaunches.push(launch)
43      }
44    })
45    return launchesByRocket;
46  }
47
48  // leaving this inside the class to make the class easier to test
49  launchReducer(launch) {
50    return {
51      id: launch.flight_number || 0,
52      cursor: `${launch.launch_date_local}`,
53      site: launch.launch_site && launch.launch_site.site_name,
54      mission: {
55        name: launch.mission_name,
56        missionPatchSmall: launch.links.mission_patch_small,
57        missionPatchLarge: launch.links.mission_patch,
58      },
59      rocket: {
60        id: launch.rocket.rocket_id,
61        name: launch.rocket.rocket_name,
62        type: launch.rocket.rocket_type,
63        
64      },
65    };
66  }
67
68  async getAllRockets() {
69    const response = await this.get('launches');
70
71    if (Array.isArray(response)) {
72      const launchesPerRocket = Array.from(this.groupRockets(response).values());
73      const result = launchesPerRocket.map(launch => this.rocketReducer(launch))
74
75      return result
76    } else {
77      return []
78    }
79  }
80
81  async getAllLaunches() {
82    const response = await this.get('launches');
83
84    // transform the raw launches to a more friendly
85    return Array.isArray(response)
86      ? response.map(launch => this.launchReducer(launch)) : [];
87  }
88
89  async getLaunchById({ launchId }) {
90    const res = await this.get('launches', { flight_number: launchId });
91    return this.launchReducer(res[0]);
92  }
93
94  async getLaunchesByIds({ launchIds }) {
95    return Promise.all(
96      launchIds.map(launchId => this.getLaunchById({ launchId })),
97    );
98  }
99}
100
101module.exports = LaunchAPI;
102

Source: launch.js

const { RESTDataSource } = require('apollo-datasource-rest');

class LaunchAPI extends RESTDataSource {
  constructor() {
    super();
    this.baseURL = 'https://api.spacexdata.com/v2/';
  }

  // Create a rocket object although it is based on a launch
  rocketReducer(launch) {
    let launchFailureDetails = null
    if(launch.launch_failure_details) {
      launchFailureDetails = launch.launch_failure_details.reason
    }
    return {
      id: launch.rocket.rocket_id,
      name: launch.rocket.rocket_name,
      mission: {
        name: launch.mission_name,
        launchDateLocal: launch.launch_date_local,
        launchSuccess: launch.launch_success,
        launchFailureDetails: launchFailureDetails,
        missionPatchSmall:launch.links.mission_patch_small
      },
      site: {
        name: launch.launch_site.site_name
      }
    }
  };

  // Group launches by rocket id
  groupRockets(launches) {
    const launchesByRocket = new Map();
    let rocketId, rocketLaunches;
    launches.forEach((launch) => {
      rocketId = launch.rocket.rocket_id;
      rocketLaunches = launchesByRocket.get(rocketId);
      if (!rocketLaunches) {
        launchesByRocket.set(rocketId, launch);
      } else {
        // To simplify the project, I'll use only one launch per rocket
        // rocketLaunches.push(launch)
      }
    })
    return launchesByRocket;
  }

  // leaving this inside the class to make the class easier to test
  launchReducer(launch) {
    return {
      id: launch.flight_number || 0,
      cursor: `${launch.launch_date_local}`,
      site: launch.launch_site && launch.launch_site.site_name,
      mission: {
        name: launch.mission_name,
        missionPatchSmall: launch.links.mission_patch_small,
        missionPatchLarge: launch.links.mission_patch,
      },
      rocket: {
        id: launch.rocket.rocket_id,
        name: launch.rocket.rocket_name,
        type: launch.rocket.rocket_type,
        
      },
    };
  }

  async getAllRockets() {
    const response = await this.get('launches');

    if (Array.isArray(response)) {
      const launchesPerRocket = Array.from(this.groupRockets(response).values());
      const result = launchesPerRocket.map(launch => this.rocketReducer(launch))

      return result
    } else {
      return []
    }
  }

  async getAllLaunches() {
    const response = await this.get('launches');

    // transform the raw launches to a more friendly
    return Array.isArray(response)
      ? response.map(launch => this.launchReducer(launch)) : [];
  }

  async getLaunchById({ launchId }) {
    const res = await this.get('launches', { flight_number: launchId });
    return this.launchReducer(res[0]);
  }

  async getLaunchesByIds({ launchIds }) {
    return Promise.all(
      launchIds.map(launchId => this.getLaunchById({ launchId })),
    );
  }
}

module.exports = LaunchAPI;

1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4################################################################################
5# Copyright 2018 ROBOTIS CO., LTD.
6#
7# Licensed under the Apache License, Version 2.0 (the "License");
8# you may not use this file except in compliance with the License.
9# You may obtain a copy of the License at
10#
11#     http://www.apache.org/licenses/LICENSE-2.0
12#
13# Unless required by applicable law or agreed to in writing, software
14# distributed under the License is distributed on an "AS IS" BASIS,
15# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16# See the License for the specific language governing permissions and
17# limitations under the License.
18################################################################################
19
20# Authors: Leon Jung, [AuTURBO] Kihoon Kim (https://github.com/auturbo), Gilbert
21
22import rospy, roslaunch
23import numpy as np
24import subprocess
25import os
26import sys
27from enum import Enum
28from std_msgs.msg import UInt8
29 
30class CoreNodeController():
31    def __init__(self):
32        self.ros_package_path = os.path.dirname(os.path.realpath(__file__))
33        self.ros_package_path = self.ros_package_path.replace('turtlebot3_autorace_core/nodes', '')
34
35        self.sub_mode_control = rospy.Subscriber('/core/decided_mode', UInt8, self.cbReceiveMode, queue_size=1)
36
37        self.CurrentMode = Enum('CurrentMode', 'idle lane_following traffic_light parking_lot level_crossing tunnel')
38
39        # subscribes : status returned
40        self.sub_parking_lot_stamped = rospy.Subscriber('/detect/parking_lot_stamped', UInt8, self.cbParkingLotStamped, queue_size=1)
41        self.sub_level_crossing_stamped = rospy.Subscriber('/detect/level_crossing_stamped', UInt8, self.cbLevelCrossingStamped, queue_size=1)
42        self.sub_tunnel_stamped = rospy.Subscriber('/detect/tunnel_stamped', UInt8, self.cbTunnelStamped, queue_size=1)
43
44        # publishes orders
45        self.pub_traffic_light_order = rospy.Publisher('/detect/traffic_light_order', UInt8, queue_size=1)
46        self.pub_parking_lot_order = rospy.Publisher('/detect/parking_lot_order', UInt8, queue_size=1)
47        self.pub_level_crossing_order = rospy.Publisher('/detect/level_crossing_order', UInt8, queue_size=1)
48        self.pub_tunnel_order = rospy.Publisher('/detect/tunnel_order', UInt8, queue_size=1)
49
50        self.pub_mode_return = rospy.Publisher('/core/returned_mode', UInt8, queue_size=1)
51
52        self.StepOfParkingLot = Enum('StepOfParkingLot', 'searching_parking_sign searching_parking_point_line searching_nonreserved_parking_area parking')
53        self.StepOfLevelCrossing = Enum('StepOfLevelCrossing', 'searching_stop_sign searching_level watching_level stop pass_level')
54        self.StepOfTunnel = Enum('StepOfTunnel', 'searching_tunnel_sign go_in_to_tunnel navigation go_out_from_tunnel exit')
55
56        self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
57        self.current_step_level_crossing = self.StepOfLevelCrossing.searching_stop_sign.value
58        self.current_step_tunnel = self.StepOfTunnel.searching_tunnel_sign.value
59
60        self.Launcher = Enum('Launcher', 'launch_camera_ex_calib launch_detect_sign launch_detect_lane launch_control_lane launch_detect_traffic_light launch_control_traffic_light launch_detect_parking launch_control_parking launch_detect_level launch_control_level launch_detect_tunnel launch_control_tunnel')
61
62        self.uuid = roslaunch.rlutil.get_or_generate_uuid(None, False)
63        
64        self.launch_camera_launched = False
65        self.launch_detect_sign_launched = False
66        self.launch_detect_lane_launched = False    
67        self.launch_control_lane_launched = False
68        self.launch_detect_parking_launched = False
69        self.launch_control_parking_launched = False
70        self.launch_detect_level_launched = False
71        self.launch_detect_traffic_light_launched = False
72        self.launch_detect_tunnel_launched = False
73        self.launch_control_tunnel_launched = False
74
75        self.current_mode = self.CurrentMode.idle.value
76
77        self.is_triggered = False
78
79        loop_rate = rospy.Rate(10) # 10hz
80        while not rospy.is_shutdown():
81            if self.is_triggered == True:
82                self.fnControlNode()
83            
84            loop_rate.sleep()
85
86    def cbReceiveMode(self, mode_msg):
87        rospy.loginfo("starts the progress with %d", mode_msg.data)
88        
89        self.current_mode = mode_msg.data
90        self.is_triggered = True
91
92    # Which step is in Parking Lot
93    def cbParkingLotStamped(self, parking_lot_msg):
94        rospy.loginfo("ParkingLot Step changed from %d", self.current_step_parking_lot)
95
96        self.current_step_parking_lot = parking_lot_msg.data
97
98        rospy.loginfo("into %d", self.current_step_parking_lot)
99
100        if self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
101            self.current_mode = self.CurrentMode.lane_following.value
102            msg_mode_return = UInt8()
103            msg_mode_return.data = self.current_mode
104            self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
105
106            rospy.loginfo("pub_mode_return")
107            self.pub_mode_return.publish(msg_mode_return)
108
109        self.is_triggered = True
110
111    # Which step is in Level Crossing  
112    def cbLevelCrossingStamped(self, level_crossing_msg):
113        rospy.loginfo("LevelCrossing Step changed from %d", self.current_step_level_crossing)
114
115        self.current_step_level_crossing = level_crossing_msg.data
116
117        rospy.loginfo("into %d", self.current_step_level_crossing)
118
119        if self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
120            self.current_mode = self.CurrentMode.level_crossing.value
121            msg_mode_return = UInt8()
122            msg_mode_return.data = self.current_mode
123            self.pub_mode_return.publish(msg_mode_return)
124
125        self.is_triggered = True
126
127    # Which step is in Tunnel
128    def cbTunnelStamped(self, tunnel_msg):
129        rospy.loginfo("Tunnel Step changed from %d", self.current_step_tunnel)
130
131        self.current_step_tunnel = tunnel_msg.data
132
133        rospy.loginfo("into %d", self.current_step_tunnel)
134
135        if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
136            self.current_mode = self.CurrentMode.tunnel.value
137            msg_mode_return = UInt8()
138            msg_mode_return.data = self.current_mode
139            self.pub_mode_return.publish(msg_mode_return)
140
141        self.is_triggered = True
142
143    def fnControlNode(self):
144        # lane_following
145        if self.current_mode == self.CurrentMode.lane_following.value:
146            rospy.loginfo("New trigger for lane_following")
147
148            self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
149
150            self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
151            self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
152            self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
153            self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
154            self.fnLaunch(self.Launcher.launch_detect_level.value, False)
155            self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
156
157            self.fnLaunch(self.Launcher.launch_control_lane.value, True)
158            self.fnLaunch(self.Launcher.launch_control_parking.value, False)
159            self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
160              
161        # traffic_light
162        elif self.current_mode == self.CurrentMode.traffic_light.value:
163            rospy.loginfo("New trigger for traffic_light")
164            msg_pub_traffic_light_order = UInt8()
165
166            if self.current_step_traffic_light == self.StepOfTrafficLight.searching_traffic_light.value:
167                rospy.loginfo("Current step : searching_traffic_light")
168                rospy.loginfo("Go to next step : in_traffic_light")
169
170                msg_pub_traffic_light_order.data = self.StepOfTrafficLight.in_traffic_light.value
171
172                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
173                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
174                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
175                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
176                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
177                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
178
179                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
180                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
181                self.fnLaunch(self.Launcher.launch_control_level.value, False)
182
183            elif self.current_step_traffic_light == self.StepOfTrafficLight.in_traffic_light.value:
184                rospy.loginfo("Current step : in_traffic_light")
185                rospy.loginfo("Go to next step : pass_traffic_light")
186
187                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
188                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
189                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
190                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
191                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
192                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
193
194                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
195                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
196                self.fnLaunch(self.Launcher.launch_control_level.value, False)
197
198            rospy.sleep(2)
199
200            self.pub_traffic_light_order.publish(msg_pub_traffic_light_order)
201
202        # parking_lot
203        elif self.current_mode == self.CurrentMode.parking_lot.value:
204            rospy.loginfo("New trigger for parking_lot")
205            msg_pub_parking_lot_order = UInt8()
206
207            if self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_sign.value:
208                rospy.loginfo("Current step : searching_parking_sign")
209                rospy.loginfo("Go to next step : searching_parking_point_line")
210
211                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_point_line.value
212
213                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
214                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
215
216                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
217                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
218                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
219                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
220                                   
221            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_point_line.value:
222                rospy.loginfo("Current step : searching_parking_point_line")
223                rospy.loginfo("Go to next step : searching_nonreserved_parking_area")
224
225                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_nonreserved_parking_area.value
226
227                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
228                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
229
230                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
231                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
232                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
233                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
234
235            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_nonreserved_parking_area.value:
236                rospy.loginfo("Current step : searching_nonreserved_parking_area")
237                rospy.loginfo("Go to next step : parking")
238
239                msg_pub_parking_lot_order.data = self.StepOfParkingLot.parking.value
240
241                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
242                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
243                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
244                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
245                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
246                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
247
248            elif self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
249                rospy.loginfo("Current step : parking")
250                rospy.loginfo("Go to next step : searching_parking_sign")
251
252                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_sign.value
253
254                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
255                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
256                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
257                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
258                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
259                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
260
261            rospy.sleep(2)
262
263            self.pub_parking_lot_order.publish(msg_pub_parking_lot_order)
264
265        # level_crossing
266        elif self.current_mode == self.CurrentMode.level_crossing.value:
267            rospy.loginfo("New trigger for level_crossing")
268            msg_pub_level_crossing_order = UInt8()
269
270            if self.current_step_level_crossing == self.StepOfLevelCrossing.searching_stop_sign.value:
271                rospy.loginfo("Current step : searching_stop_sign")
272                rospy.loginfo("Go to next step : searching_level")
273
274                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_level.value
275
276                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
277                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
278                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
279                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
280                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
281                                   
282            elif self.current_step_level_crossing == self.StepOfLevelCrossing.searching_level.value:
283                rospy.loginfo("Current step : searching_level")
284                rospy.loginfo("Go to next step : watching_level")
285
286                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.watching_level.value
287
288                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
289                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
290                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
291                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
292                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
293
294            elif self.current_step_level_crossing == self.StepOfLevelCrossing.watching_level.value:
295                rospy.loginfo("Current step : watching_level")
296                rospy.loginfo("Go to next step : stop")
297
298                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.stop.value
299
300                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
301                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
302                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
303                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
304                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
305
306            elif self.current_step_level_crossing == self.StepOfLevelCrossing.stop.value:
307                rospy.loginfo("Current step : stop")
308                rospy.loginfo("Go to next step : pass_level")
309
310                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.pass_level.value
311
312                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
313                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
314                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
315                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
316                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
317
318            elif self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
319                rospy.loginfo("Current step : pass_level")
320                rospy.loginfo("Go to next step : searching_stop_sign")
321
322                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_stop_sign.value
323
324                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
325                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
326                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
327                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
328                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
329
330            rospy.sleep(2)
331
332            self.pub_level_crossing_order.publish(msg_pub_level_crossing_order)
333
334        # tunnel
335        elif self.current_mode == self.CurrentMode.tunnel.value:
336            rospy.loginfo("New trigger for tunnel")
337            msg_pub_tunnel_order = UInt8()
338
339            if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
340                rospy.loginfo("Current step : searching_tunnel_sign")
341                rospy.loginfo("Go to next step : go_in_to_tunnel")
342
343                msg_pub_tunnel_order.data = self.StepOfTunnel.go_in_to_tunnel.value
344
345                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
346                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
347                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
348                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
349                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
350                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
351                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
352
353                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
354                                   
355            elif self.current_step_tunnel == self.StepOfTunnel.go_in_to_tunnel.value:
356                rospy.loginfo("Current step : go_in_to_tunnel")
357                rospy.loginfo("Go to next step : navigation")
358
359                msg_pub_tunnel_order.data = self.StepOfTunnel.navigation.value
360
361                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
362                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
363                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
364                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
365                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
366                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
367                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
368
369                self.fnLaunch(self.Launcher.launch_control_tunnel.value, True)
370
371            elif self.current_step_tunnel == self.StepOfTunnel.navigation.value:
372                rospy.loginfo("Current step : navigation")
373                rospy.loginfo("Go to next step : go_out_from_tunnel")
374
375                msg_pub_tunnel_order.data = self.StepOfTunnel.go_out_from_tunnel.value
376
377                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
378                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
379                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
380                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
381                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
382                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
383                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
384
385                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
386
387            elif self.current_step_tunnel == self.StepOfTunnel.go_out_from_tunnel.value:
388                rospy.loginfo("Current step : go_out_from_tunnel")
389                rospy.loginfo("Go to next step : exit")
390
391                msg_pub_tunnel_order.data = self.StepOfTunnel.exit.value
392
393                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
394                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
395                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
396                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
397                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
398                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
399                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
400
401                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
402
403            elif self.current_step_tunnel == self.StepOfTunnel.exit.value:
404                rospy.loginfo("Current step : exit")
405                rospy.loginfo("Go to next step : searching_tunnel_sign")
406
407                msg_pub_tunnel_order.data = self.StepOfTunnel.searching_tunnel_sign.value
408
409                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
410                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
411                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
412                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
413                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
414                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
415                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
416
417                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
418                
419            rospy.sleep(2)
420
421            self.pub_tunnel_order.publish(msg_pub_tunnel_order)
422
423        self.is_triggered = False
424
425    def fnLaunch(self, launch_num, is_start):
426        if launch_num == self.Launcher.launch_camera_ex_calib.value:
427            if is_start == True:
428                if self.launch_camera_launched == False:
429                    self.launch_camera = roslaunch.scriptapi.ROSLaunch()
430                    self.launch_camera = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_camera/launch/turtlebot3_autorace_extrinsic_camera_calibration.launch"])
431                    self.launch_camera_launched = True
432                    self.launch_camera.start()
433                else:
434                    pass
435            else:
436                if self.launch_camera_launched == True:
437                    self.launch_camera_launched = False
438                    self.launch_camera.shutdown()
439                else:
440                    pass
441        elif launch_num == self.Launcher.launch_detect_sign.value:
442            if is_start == True:
443                if self.launch_detect_sign_launched == False:
444                    self.launch_detect_sign = roslaunch.scriptapi.ROSLaunch()
445                    self.launch_detect_sign = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_sign.launch"])
446                    self.launch_detect_sign_launched = True
447                    self.launch_detect_sign.start()
448                else:
449                    pass
450            else:
451                if self.launch_detect_sign_launched == True:
452                    self.launch_detect_sign_launched = False
453                    self.launch_detect_sign.shutdown()
454                else:
455                    pass                
456        elif launch_num == self.Launcher.launch_detect_lane.value:
457            if is_start == True:
458                if self.launch_detect_lane_launched == False:
459                    self.launch_detect_lane = roslaunch.scriptapi.ROSLaunch()
460                    self.launch_detect_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_lane.launch"])
461                    self.launch_detect_lane_launched = True
462                    self.launch_detect_lane.start()
463                else:
464                    pass
465            else:
466                if self.launch_detect_lane_launched == True:
467                    self.launch_detect_lane_launched = False
468                    self.launch_detect_lane.shutdown()
469                else:
470                    pass                  
471        elif launch_num == self.Launcher.launch_control_lane.value:
472            if is_start == True:
473                if self.launch_control_lane_launched == False:
474                    self.launch_control_lane = roslaunch.scriptapi.ROSLaunch()
475                    self.launch_control_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_lane.launch"])
476                    self.launch_control_lane_launched = True
477                    self.launch_control_lane.start()
478                else:
479                    pass
480            else:
481                if self.launch_control_lane_launched == True:
482                    self.launch_control_lane_launched = False
483                    self.launch_control_lane.shutdown()
484                else:
485                    pass                  
486        elif launch_num == self.Launcher.launch_detect_parking.value:
487            if is_start == True:
488                if self.launch_detect_parking_launched == False:
489                    self.launch_detect_parking = roslaunch.scriptapi.ROSLaunch()
490                    self.launch_detect_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_parking.launch"])
491                    self.launch_detect_parking_launched = True
492                    self.launch_detect_parking.start()
493                else:
494                    pass
495            else:
496                if self.launch_detect_parking_launched == True:
497                    self.launch_detect_parking_launched = False
498                    self.launch_detect_parking.shutdown()
499                else:
500                    pass                  
501        elif launch_num == self.Launcher.launch_control_parking.value:
502            if is_start == True:
503                if self.launch_control_parking_launched == False:
504                    self.launch_control_parking = roslaunch.scriptapi.ROSLaunch()
505                    self.launch_control_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_parking.launch"])     
506                    self.launch_control_parking_launched = True
507                    self.launch_control_parking.start()
508                else:
509                    pass
510            else:
511                if self.launch_control_parking_launched == True:
512                    self.launch_control_parking_launched = False
513                    self.launch_control_parking.shutdown()
514                else:
515                    pass
516        elif launch_num == self.Launcher.launch_detect_level.value:
517            if is_start == True:
518                if self.launch_detect_level_launched == False:
519                    self.launch_detect_level = roslaunch.scriptapi.ROSLaunch()
520                    self.launch_detect_level = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_level.launch"])     
521                    self.launch_detect_level_launched = True
522                    self.launch_detect_level.start()
523                else:
524                    pass
525            else:
526                if self.launch_detect_level_launched == True:
527                    self.launch_detect_level_launched = False
528                    self.launch_detect_level.shutdown()
529                else:
530                    pass                  
531        elif launch_num == self.Launcher.launch_detect_traffic_light.value:
532            if is_start == True:
533                if self.launch_detect_traffic_light_launched == False:
534                    self.launch_detect_traffic_light = roslaunch.scriptapi.ROSLaunch()
535                    self.launch_detect_traffic_light = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_traffic_light.launch"])     
536                    self.launch_detect_traffic_light_launched = True
537                    self.launch_detect_traffic_light.start()
538                else:
539                    pass
540            else:
541                if self.launch_detect_traffic_light_launched == True:
542                    self.launch_detect_traffic_light_launched = False
543                    self.launch_detect_traffic_light.shutdown()
544                else:
545                    pass    
546                    
547        elif launch_num == self.Launcher.launch_detect_tunnel.value:
548            if is_start == True:
549                if self.launch_detect_tunnel_launched == False:
550                    self.launch_detect_tunnel = roslaunch.scriptapi.ROSLaunch()
551                    self.launch_detect_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_tunnel.launch"])     
552                    self.launch_detect_tunnel_launched = True
553                    self.launch_detect_tunnel.start()
554                else:
555                    pass
556            else:
557                if self.launch_detect_tunnel_launched == True:
558                    self.launch_detect_tunnel_launched = False
559                    self.launch_detect_tunnel.shutdown()
560                else:
561                    pass    
562        elif launch_num == self.Launcher.launch_control_tunnel.value:
563            if is_start == True:
564                if self.launch_control_tunnel_launched == False:
565                    self.launch_control_tunnel = roslaunch.scriptapi.ROSLaunch()
566                    self.launch_control_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_tunnel.launch"])     
567                    self.launch_control_tunnel_launched = True
568                    self.launch_control_tunnel.start()
569                else:
570                    pass
571            else:
572                if self.launch_control_tunnel_launched == True:
573                    self.launch_control_tunnel_launched = False
574                    self.launch_control_tunnel.shutdown()
575                else:
576                    pass
577
578    def main(self):
579        rospy.spin()
580
581if __name__ == '__main__':
582    rospy.init_node('core_node_controller')
583    node = CoreNodeController()
584    node.main()
585

Source: core_node_controller

#!/usr/bin/env python
# -*- coding: utf-8 -*-

################################################################################
# Copyright 2018 ROBOTIS CO., LTD.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
################################################################################

# Authors: Leon Jung, [AuTURBO] Kihoon Kim (https://github.com/auturbo), Gilbert

import rospy, roslaunch
import numpy as np
import subprocess
import os
import sys
from enum import Enum
from std_msgs.msg import UInt8
 
class CoreNodeController():
    def __init__(self):
        self.ros_package_path = os.path.dirname(os.path.realpath(__file__))
        self.ros_package_path = self.ros_package_path.replace('turtlebot3_autorace_core/nodes', '')

        self.sub_mode_control = rospy.Subscriber('/core/decided_mode', UInt8, self.cbReceiveMode, queue_size=1)

        self.CurrentMode = Enum('CurrentMode', 'idle lane_following traffic_light parking_lot level_crossing tunnel')

        # subscribes : status returned
        self.sub_parking_lot_stamped = rospy.Subscriber('/detect/parking_lot_stamped', UInt8, self.cbParkingLotStamped, queue_size=1)
        self.sub_level_crossing_stamped = rospy.Subscriber('/detect/level_crossing_stamped', UInt8, self.cbLevelCrossingStamped, queue_size=1)
        self.sub_tunnel_stamped = rospy.Subscriber('/detect/tunnel_stamped', UInt8, self.cbTunnelStamped, queue_size=1)

        # publishes orders
        self.pub_traffic_light_order = rospy.Publisher('/detect/traffic_light_order', UInt8, queue_size=1)
        self.pub_parking_lot_order = rospy.Publisher('/detect/parking_lot_order', UInt8, queue_size=1)
        self.pub_level_crossing_order = rospy.Publisher('/detect/level_crossing_order', UInt8, queue_size=1)
        self.pub_tunnel_order = rospy.Publisher('/detect/tunnel_order', UInt8, queue_size=1)

        self.pub_mode_return = rospy.Publisher('/core/returned_mode', UInt8, queue_size=1)

        self.StepOfParkingLot = Enum('StepOfParkingLot', 'searching_parking_sign searching_parking_point_line searching_nonreserved_parking_area parking')
        self.StepOfLevelCrossing = Enum('StepOfLevelCrossing', 'searching_stop_sign searching_level watching_level stop pass_level')
        self.StepOfTunnel = Enum('StepOfTunnel', 'searching_tunnel_sign go_in_to_tunnel navigation go_out_from_tunnel exit')

        self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
        self.current_step_level_crossing = self.StepOfLevelCrossing.searching_stop_sign.value
        self.current_step_tunnel = self.StepOfTunnel.searching_tunnel_sign.value

        self.Launcher = Enum('Launcher', 'launch_camera_ex_calib launch_detect_sign launch_detect_lane launch_control_lane launch_detect_traffic_light launch_control_traffic_light launch_detect_parking launch_control_parking launch_detect_level launch_control_level launch_detect_tunnel launch_control_tunnel')

        self.uuid = roslaunch.rlutil.get_or_generate_uuid(None, False)
        
        self.launch_camera_launched = False
        self.launch_detect_sign_launched = False
        self.launch_detect_lane_launched = False    
        self.launch_control_lane_launched = False
        self.launch_detect_parking_launched = False
        self.launch_control_parking_launched = False
        self.launch_detect_level_launched = False
        self.launch_detect_traffic_light_launched = False
        self.launch_detect_tunnel_launched = False
        self.launch_control_tunnel_launched = False

        self.current_mode = self.CurrentMode.idle.value

        self.is_triggered = False

        loop_rate = rospy.Rate(10) # 10hz
        while not rospy.is_shutdown():
            if self.is_triggered == True:
                self.fnControlNode()
            
            loop_rate.sleep()

    def cbReceiveMode(self, mode_msg):
        rospy.loginfo("starts the progress with %d", mode_msg.data)
        
        self.current_mode = mode_msg.data
        self.is_triggered = True

    # Which step is in Parking Lot
    def cbParkingLotStamped(self, parking_lot_msg):
        rospy.loginfo("ParkingLot Step changed from %d", self.current_step_parking_lot)

        self.current_step_parking_lot = parking_lot_msg.data

        rospy.loginfo("into %d", self.current_step_parking_lot)

        if self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
            self.current_mode = self.CurrentMode.lane_following.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value

            rospy.loginfo("pub_mode_return")
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    # Which step is in Level Crossing  
    def cbLevelCrossingStamped(self, level_crossing_msg):
        rospy.loginfo("LevelCrossing Step changed from %d", self.current_step_level_crossing)

        self.current_step_level_crossing = level_crossing_msg.data

        rospy.loginfo("into %d", self.current_step_level_crossing)

        if self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
            self.current_mode = self.CurrentMode.level_crossing.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    # Which step is in Tunnel
    def cbTunnelStamped(self, tunnel_msg):
        rospy.loginfo("Tunnel Step changed from %d", self.current_step_tunnel)

        self.current_step_tunnel = tunnel_msg.data

        rospy.loginfo("into %d", self.current_step_tunnel)

        if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
            self.current_mode = self.CurrentMode.tunnel.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    def fnControlNode(self):
        # lane_following
        if self.current_mode == self.CurrentMode.lane_following.value:
            rospy.loginfo("New trigger for lane_following")

            self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)

            self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
            self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
            self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
            self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
            self.fnLaunch(self.Launcher.launch_detect_level.value, False)
            self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

            self.fnLaunch(self.Launcher.launch_control_lane.value, True)
            self.fnLaunch(self.Launcher.launch_control_parking.value, False)
            self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
              
        # traffic_light
        elif self.current_mode == self.CurrentMode.traffic_light.value:
            rospy.loginfo("New trigger for traffic_light")
            msg_pub_traffic_light_order = UInt8()

            if self.current_step_traffic_light == self.StepOfTrafficLight.searching_traffic_light.value:
                rospy.loginfo("Current step : searching_traffic_light")
                rospy.loginfo("Go to next step : in_traffic_light")

                msg_pub_traffic_light_order.data = self.StepOfTrafficLight.in_traffic_light.value

                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_level.value, False)

            elif self.current_step_traffic_light == self.StepOfTrafficLight.in_traffic_light.value:
                rospy.loginfo("Current step : in_traffic_light")
                rospy.loginfo("Go to next step : pass_traffic_light")

                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_level.value, False)

            rospy.sleep(2)

            self.pub_traffic_light_order.publish(msg_pub_traffic_light_order)

        # parking_lot
        elif self.current_mode == self.CurrentMode.parking_lot.value:
            rospy.loginfo("New trigger for parking_lot")
            msg_pub_parking_lot_order = UInt8()

            if self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_sign.value:
                rospy.loginfo("Current step : searching_parking_sign")
                rospy.loginfo("Go to next step : searching_parking_point_line")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_point_line.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)

                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                                   
            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_point_line.value:
                rospy.loginfo("Current step : searching_parking_point_line")
                rospy.loginfo("Go to next step : searching_nonreserved_parking_area")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_nonreserved_parking_area.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, True)

                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_nonreserved_parking_area.value:
                rospy.loginfo("Current step : searching_nonreserved_parking_area")
                rospy.loginfo("Go to next step : parking")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.parking.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
                rospy.loginfo("Current step : parking")
                rospy.loginfo("Go to next step : searching_parking_sign")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_sign.value

                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            rospy.sleep(2)

            self.pub_parking_lot_order.publish(msg_pub_parking_lot_order)

        # level_crossing
        elif self.current_mode == self.CurrentMode.level_crossing.value:
            rospy.loginfo("New trigger for level_crossing")
            msg_pub_level_crossing_order = UInt8()

            if self.current_step_level_crossing == self.StepOfLevelCrossing.searching_stop_sign.value:
                rospy.loginfo("Current step : searching_stop_sign")
                rospy.loginfo("Go to next step : searching_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                                   
            elif self.current_step_level_crossing == self.StepOfLevelCrossing.searching_level.value:
                rospy.loginfo("Current step : searching_level")
                rospy.loginfo("Go to next step : watching_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.watching_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.watching_level.value:
                rospy.loginfo("Current step : watching_level")
                rospy.loginfo("Go to next step : stop")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.stop.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.stop.value:
                rospy.loginfo("Current step : stop")
                rospy.loginfo("Go to next step : pass_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.pass_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
                rospy.loginfo("Current step : pass_level")
                rospy.loginfo("Go to next step : searching_stop_sign")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_stop_sign.value

                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            rospy.sleep(2)

            self.pub_level_crossing_order.publish(msg_pub_level_crossing_order)

        # tunnel
        elif self.current_mode == self.CurrentMode.tunnel.value:
            rospy.loginfo("New trigger for tunnel")
            msg_pub_tunnel_order = UInt8()

            if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
                rospy.loginfo("Current step : searching_tunnel_sign")
                rospy.loginfo("Go to next step : go_in_to_tunnel")

                msg_pub_tunnel_order.data = self.StepOfTunnel.go_in_to_tunnel.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
                                   
            elif self.current_step_tunnel == self.StepOfTunnel.go_in_to_tunnel.value:
                rospy.loginfo("Current step : go_in_to_tunnel")
                rospy.loginfo("Go to next step : navigation")

                msg_pub_tunnel_order.data = self.StepOfTunnel.navigation.value

                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, True)

            elif self.current_step_tunnel == self.StepOfTunnel.navigation.value:
                rospy.loginfo("Current step : navigation")
                rospy.loginfo("Go to next step : go_out_from_tunnel")

                msg_pub_tunnel_order.data = self.StepOfTunnel.go_out_from_tunnel.value

                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)

            elif self.current_step_tunnel == self.StepOfTunnel.go_out_from_tunnel.value:
                rospy.loginfo("Current step : go_out_from_tunnel")
                rospy.loginfo("Go to next step : exit")

                msg_pub_tunnel_order.data = self.StepOfTunnel.exit.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)

            elif self.current_step_tunnel == self.StepOfTunnel.exit.value:
                rospy.loginfo("Current step : exit")
                rospy.loginfo("Go to next step : searching_tunnel_sign")

                msg_pub_tunnel_order.data = self.StepOfTunnel.searching_tunnel_sign.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
                
            rospy.sleep(2)

            self.pub_tunnel_order.publish(msg_pub_tunnel_order)

        self.is_triggered = False

    def fnLaunch(self, launch_num, is_start):
        if launch_num == self.Launcher.launch_camera_ex_calib.value:
            if is_start == True:
                if self.launch_camera_launched == False:
                    self.launch_camera = roslaunch.scriptapi.ROSLaunch()
                    self.launch_camera = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_camera/launch/turtlebot3_autorace_extrinsic_camera_calibration.launch"])
                    self.launch_camera_launched = True
                    self.launch_camera.start()
                else:
                    pass
            else:
                if self.launch_camera_launched == True:
                    self.launch_camera_launched = False
                    self.launch_camera.shutdown()
                else:
                    pass
        elif launch_num == self.Launcher.launch_detect_sign.value:
            if is_start == True:
                if self.launch_detect_sign_launched == False:
                    self.launch_detect_sign = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_sign = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_sign.launch"])
                    self.launch_detect_sign_launched = True
                    self.launch_detect_sign.start()
                else:
                    pass
            else:
                if self.launch_detect_sign_launched == True:
                    self.launch_detect_sign_launched = False
                    self.launch_detect_sign.shutdown()
                else:
                    pass                
        elif launch_num == self.Launcher.launch_detect_lane.value:
            if is_start == True:
                if self.launch_detect_lane_launched == False:
                    self.launch_detect_lane = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_lane.launch"])
                    self.launch_detect_lane_launched = True
                    self.launch_detect_lane.start()
                else:
                    pass
            else:
                if self.launch_detect_lane_launched == True:
                    self.launch_detect_lane_launched = False
                    self.launch_detect_lane.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_control_lane.value:
            if is_start == True:
                if self.launch_control_lane_launched == False:
                    self.launch_control_lane = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_lane.launch"])
                    self.launch_control_lane_launched = True
                    self.launch_control_lane.start()
                else:
                    pass
            else:
                if self.launch_control_lane_launched == True:
                    self.launch_control_lane_launched = False
                    self.launch_control_lane.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_detect_parking.value:
            if is_start == True:
                if self.launch_detect_parking_launched == False:
                    self.launch_detect_parking = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_parking.launch"])
                    self.launch_detect_parking_launched = True
                    self.launch_detect_parking.start()
                else:
                    pass
            else:
                if self.launch_detect_parking_launched == True:
                    self.launch_detect_parking_launched = False
                    self.launch_detect_parking.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_control_parking.value:
            if is_start == True:
                if self.launch_control_parking_launched == False:
                    self.launch_control_parking = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_parking.launch"])     
                    self.launch_control_parking_launched = True
                    self.launch_control_parking.start()
                else:
                    pass
            else:
                if self.launch_control_parking_launched == True:
                    self.launch_control_parking_launched = False
                    self.launch_control_parking.shutdown()
                else:
                    pass
        elif launch_num == self.Launcher.launch_detect_level.value:
            if is_start == True:
                if self.launch_detect_level_launched == False:
                    self.launch_detect_level = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_level = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_level.launch"])     
                    self.launch_detect_level_launched = True
                    self.launch_detect_level.start()
                else:
                    pass
            else:
                if self.launch_detect_level_launched == True:
                    self.launch_detect_level_launched = False
                    self.launch_detect_level.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_detect_traffic_light.value:
            if is_start == True:
                if self.launch_detect_traffic_light_launched == False:
                    self.launch_detect_traffic_light = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_traffic_light = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_traffic_light.launch"])     
                    self.launch_detect_traffic_light_launched = True
                    self.launch_detect_traffic_light.start()
                else:
                    pass
            else:
                if self.launch_detect_traffic_light_launched == True:
                    self.launch_detect_traffic_light_launched = False
                    self.launch_detect_traffic_light.shutdown()
                else:
                    pass    
                    
        elif launch_num == self.Launcher.launch_detect_tunnel.value:
            if is_start == True:
                if self.launch_detect_tunnel_launched == False:
                    self.launch_detect_tunnel = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_tunnel.launch"])     
                    self.launch_detect_tunnel_launched = True
                    self.launch_detect_tunnel.start()
                else:
                    pass
            else:
                if self.launch_detect_tunnel_launched == True:
                    self.launch_detect_tunnel_launched = False
                    self.launch_detect_tunnel.shutdown()
                else:
                    pass    
        elif launch_num == self.Launcher.launch_control_tunnel.value:
            if is_start == True:
                if self.launch_control_tunnel_launched == False:
                    self.launch_control_tunnel = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_tunnel.launch"])     
                    self.launch_control_tunnel_launched = True
                    self.launch_control_tunnel.start()
                else:
                    pass
            else:
                if self.launch_control_tunnel_launched == True:
                    self.launch_control_tunnel_launched = False
                    self.launch_control_tunnel.shutdown()
                else:
                    pass

    def main(self):
        rospy.spin()

if __name__ == '__main__':
    rospy.init_node('core_node_controller')
    node = CoreNodeController()
    node.main()

1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4################################################################################
5# Copyright 2018 ROBOTIS CO., LTD.
6#
7# Licensed under the Apache License, Version 2.0 (the "License");
8# you may not use this file except in compliance with the License.
9# You may obtain a copy of the License at
10#
11#     http://www.apache.org/licenses/LICENSE-2.0
12#
13# Unless required by applicable law or agreed to in writing, software
14# distributed under the License is distributed on an "AS IS" BASIS,
15# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16# See the License for the specific language governing permissions and
17# limitations under the License.
18################################################################################
19
20# Authors: Leon Jung, [AuTURBO] Kihoon Kim (https://github.com/auturbo), Gilbert
21
22import rospy, roslaunch
23import numpy as np
24import subprocess
25import os
26import sys
27from enum import Enum
28from std_msgs.msg import UInt8
29 
30class CoreNodeController():
31    def __init__(self):
32        self.ros_package_path = os.path.dirname(os.path.realpath(__file__))
33        self.ros_package_path = self.ros_package_path.replace('turtlebot3_autorace_core/nodes', '')
34
35        self.sub_mode_control = rospy.Subscriber('/core/decided_mode', UInt8, self.cbReceiveMode, queue_size=1)
36
37        self.CurrentMode = Enum('CurrentMode', 'idle lane_following traffic_light parking_lot level_crossing tunnel')
38
39        # subscribes : status returned
40        self.sub_parking_lot_stamped = rospy.Subscriber('/detect/parking_lot_stamped', UInt8, self.cbParkingLotStamped, queue_size=1)
41        self.sub_level_crossing_stamped = rospy.Subscriber('/detect/level_crossing_stamped', UInt8, self.cbLevelCrossingStamped, queue_size=1)
42        self.sub_tunnel_stamped = rospy.Subscriber('/detect/tunnel_stamped', UInt8, self.cbTunnelStamped, queue_size=1)
43
44        # publishes orders
45        self.pub_traffic_light_order = rospy.Publisher('/detect/traffic_light_order', UInt8, queue_size=1)
46        self.pub_parking_lot_order = rospy.Publisher('/detect/parking_lot_order', UInt8, queue_size=1)
47        self.pub_level_crossing_order = rospy.Publisher('/detect/level_crossing_order', UInt8, queue_size=1)
48        self.pub_tunnel_order = rospy.Publisher('/detect/tunnel_order', UInt8, queue_size=1)
49
50        self.pub_mode_return = rospy.Publisher('/core/returned_mode', UInt8, queue_size=1)
51
52        self.StepOfParkingLot = Enum('StepOfParkingLot', 'searching_parking_sign searching_parking_point_line searching_nonreserved_parking_area parking')
53        self.StepOfLevelCrossing = Enum('StepOfLevelCrossing', 'searching_stop_sign searching_level watching_level stop pass_level')
54        self.StepOfTunnel = Enum('StepOfTunnel', 'searching_tunnel_sign go_in_to_tunnel navigation go_out_from_tunnel exit')
55
56        self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
57        self.current_step_level_crossing = self.StepOfLevelCrossing.searching_stop_sign.value
58        self.current_step_tunnel = self.StepOfTunnel.searching_tunnel_sign.value
59
60        self.Launcher = Enum('Launcher', 'launch_camera_ex_calib launch_detect_sign launch_detect_lane launch_control_lane launch_detect_traffic_light launch_control_traffic_light launch_detect_parking launch_control_parking launch_detect_level launch_control_level launch_detect_tunnel launch_control_tunnel')
61
62        self.uuid = roslaunch.rlutil.get_or_generate_uuid(None, False)
63        
64        self.launch_camera_launched = False
65        self.launch_detect_sign_launched = False
66        self.launch_detect_lane_launched = False    
67        self.launch_control_lane_launched = False
68        self.launch_detect_parking_launched = False
69        self.launch_control_parking_launched = False
70        self.launch_detect_level_launched = False
71        self.launch_detect_traffic_light_launched = False
72        self.launch_detect_tunnel_launched = False
73        self.launch_control_tunnel_launched = False
74
75        self.current_mode = self.CurrentMode.idle.value
76
77        self.is_triggered = False
78
79        loop_rate = rospy.Rate(10) # 10hz
80        while not rospy.is_shutdown():
81            if self.is_triggered == True:
82                self.fnControlNode()
83            
84            loop_rate.sleep()
85
86    def cbReceiveMode(self, mode_msg):
87        rospy.loginfo("starts the progress with %d", mode_msg.data)
88        
89        self.current_mode = mode_msg.data
90        self.is_triggered = True
91
92    # Which step is in Parking Lot
93    def cbParkingLotStamped(self, parking_lot_msg):
94        rospy.loginfo("ParkingLot Step changed from %d", self.current_step_parking_lot)
95
96        self.current_step_parking_lot = parking_lot_msg.data
97
98        rospy.loginfo("into %d", self.current_step_parking_lot)
99
100        if self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
101            self.current_mode = self.CurrentMode.lane_following.value
102            msg_mode_return = UInt8()
103            msg_mode_return.data = self.current_mode
104            self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
105
106            rospy.loginfo("pub_mode_return")
107            self.pub_mode_return.publish(msg_mode_return)
108
109        self.is_triggered = True
110
111    # Which step is in Level Crossing  
112    def cbLevelCrossingStamped(self, level_crossing_msg):
113        rospy.loginfo("LevelCrossing Step changed from %d", self.current_step_level_crossing)
114
115        self.current_step_level_crossing = level_crossing_msg.data
116
117        rospy.loginfo("into %d", self.current_step_level_crossing)
118
119        if self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
120            self.current_mode = self.CurrentMode.level_crossing.value
121            msg_mode_return = UInt8()
122            msg_mode_return.data = self.current_mode
123            self.pub_mode_return.publish(msg_mode_return)
124
125        self.is_triggered = True
126
127    # Which step is in Tunnel
128    def cbTunnelStamped(self, tunnel_msg):
129        rospy.loginfo("Tunnel Step changed from %d", self.current_step_tunnel)
130
131        self.current_step_tunnel = tunnel_msg.data
132
133        rospy.loginfo("into %d", self.current_step_tunnel)
134
135        if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
136            self.current_mode = self.CurrentMode.tunnel.value
137            msg_mode_return = UInt8()
138            msg_mode_return.data = self.current_mode
139            self.pub_mode_return.publish(msg_mode_return)
140
141        self.is_triggered = True
142
143    def fnControlNode(self):
144        # lane_following
145        if self.current_mode == self.CurrentMode.lane_following.value:
146            rospy.loginfo("New trigger for lane_following")
147
148            self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
149
150            self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
151            self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
152            self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
153            self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
154            self.fnLaunch(self.Launcher.launch_detect_level.value, False)
155            self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
156
157            self.fnLaunch(self.Launcher.launch_control_lane.value, True)
158            self.fnLaunch(self.Launcher.launch_control_parking.value, False)
159            self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
160              
161        # traffic_light
162        elif self.current_mode == self.CurrentMode.traffic_light.value:
163            rospy.loginfo("New trigger for traffic_light")
164            msg_pub_traffic_light_order = UInt8()
165
166            if self.current_step_traffic_light == self.StepOfTrafficLight.searching_traffic_light.value:
167                rospy.loginfo("Current step : searching_traffic_light")
168                rospy.loginfo("Go to next step : in_traffic_light")
169
170                msg_pub_traffic_light_order.data = self.StepOfTrafficLight.in_traffic_light.value
171
172                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
173                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
174                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
175                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
176                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
177                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
178
179                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
180                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
181                self.fnLaunch(self.Launcher.launch_control_level.value, False)
182
183            elif self.current_step_traffic_light == self.StepOfTrafficLight.in_traffic_light.value:
184                rospy.loginfo("Current step : in_traffic_light")
185                rospy.loginfo("Go to next step : pass_traffic_light")
186
187                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
188                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
189                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
190                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
191                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
192                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
193
194                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
195                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
196                self.fnLaunch(self.Launcher.launch_control_level.value, False)
197
198            rospy.sleep(2)
199
200            self.pub_traffic_light_order.publish(msg_pub_traffic_light_order)
201
202        # parking_lot
203        elif self.current_mode == self.CurrentMode.parking_lot.value:
204            rospy.loginfo("New trigger for parking_lot")
205            msg_pub_parking_lot_order = UInt8()
206
207            if self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_sign.value:
208                rospy.loginfo("Current step : searching_parking_sign")
209                rospy.loginfo("Go to next step : searching_parking_point_line")
210
211                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_point_line.value
212
213                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
214                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
215
216                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
217                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
218                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
219                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
220                                   
221            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_point_line.value:
222                rospy.loginfo("Current step : searching_parking_point_line")
223                rospy.loginfo("Go to next step : searching_nonreserved_parking_area")
224
225                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_nonreserved_parking_area.value
226
227                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
228                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
229
230                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
231                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
232                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
233                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
234
235            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_nonreserved_parking_area.value:
236                rospy.loginfo("Current step : searching_nonreserved_parking_area")
237                rospy.loginfo("Go to next step : parking")
238
239                msg_pub_parking_lot_order.data = self.StepOfParkingLot.parking.value
240
241                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
242                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
243                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
244                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
245                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
246                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
247
248            elif self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
249                rospy.loginfo("Current step : parking")
250                rospy.loginfo("Go to next step : searching_parking_sign")
251
252                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_sign.value
253
254                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
255                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
256                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
257                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
258                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
259                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
260
261            rospy.sleep(2)
262
263            self.pub_parking_lot_order.publish(msg_pub_parking_lot_order)
264
265        # level_crossing
266        elif self.current_mode == self.CurrentMode.level_crossing.value:
267            rospy.loginfo("New trigger for level_crossing")
268            msg_pub_level_crossing_order = UInt8()
269
270            if self.current_step_level_crossing == self.StepOfLevelCrossing.searching_stop_sign.value:
271                rospy.loginfo("Current step : searching_stop_sign")
272                rospy.loginfo("Go to next step : searching_level")
273
274                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_level.value
275
276                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
277                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
278                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
279                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
280                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
281                                   
282            elif self.current_step_level_crossing == self.StepOfLevelCrossing.searching_level.value:
283                rospy.loginfo("Current step : searching_level")
284                rospy.loginfo("Go to next step : watching_level")
285
286                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.watching_level.value
287
288                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
289                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
290                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
291                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
292                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
293
294            elif self.current_step_level_crossing == self.StepOfLevelCrossing.watching_level.value:
295                rospy.loginfo("Current step : watching_level")
296                rospy.loginfo("Go to next step : stop")
297
298                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.stop.value
299
300                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
301                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
302                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
303                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
304                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
305
306            elif self.current_step_level_crossing == self.StepOfLevelCrossing.stop.value:
307                rospy.loginfo("Current step : stop")
308                rospy.loginfo("Go to next step : pass_level")
309
310                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.pass_level.value
311
312                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
313                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
314                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
315                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
316                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
317
318            elif self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
319                rospy.loginfo("Current step : pass_level")
320                rospy.loginfo("Go to next step : searching_stop_sign")
321
322                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_stop_sign.value
323
324                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
325                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
326                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
327                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
328                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
329
330            rospy.sleep(2)
331
332            self.pub_level_crossing_order.publish(msg_pub_level_crossing_order)
333
334        # tunnel
335        elif self.current_mode == self.CurrentMode.tunnel.value:
336            rospy.loginfo("New trigger for tunnel")
337            msg_pub_tunnel_order = UInt8()
338
339            if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
340                rospy.loginfo("Current step : searching_tunnel_sign")
341                rospy.loginfo("Go to next step : go_in_to_tunnel")
342
343                msg_pub_tunnel_order.data = self.StepOfTunnel.go_in_to_tunnel.value
344
345                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
346                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
347                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
348                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
349                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
350                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
351                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
352
353                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
354                                   
355            elif self.current_step_tunnel == self.StepOfTunnel.go_in_to_tunnel.value:
356                rospy.loginfo("Current step : go_in_to_tunnel")
357                rospy.loginfo("Go to next step : navigation")
358
359                msg_pub_tunnel_order.data = self.StepOfTunnel.navigation.value
360
361                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
362                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
363                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
364                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
365                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
366                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
367                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
368
369                self.fnLaunch(self.Launcher.launch_control_tunnel.value, True)
370
371            elif self.current_step_tunnel == self.StepOfTunnel.navigation.value:
372                rospy.loginfo("Current step : navigation")
373                rospy.loginfo("Go to next step : go_out_from_tunnel")
374
375                msg_pub_tunnel_order.data = self.StepOfTunnel.go_out_from_tunnel.value
376
377                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
378                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
379                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
380                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
381                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
382                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
383                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
384
385                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
386
387            elif self.current_step_tunnel == self.StepOfTunnel.go_out_from_tunnel.value:
388                rospy.loginfo("Current step : go_out_from_tunnel")
389                rospy.loginfo("Go to next step : exit")
390
391                msg_pub_tunnel_order.data = self.StepOfTunnel.exit.value
392
393                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
394                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
395                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
396                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
397                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
398                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
399                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
400
401                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
402
403            elif self.current_step_tunnel == self.StepOfTunnel.exit.value:
404                rospy.loginfo("Current step : exit")
405                rospy.loginfo("Go to next step : searching_tunnel_sign")
406
407                msg_pub_tunnel_order.data = self.StepOfTunnel.searching_tunnel_sign.value
408
409                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
410                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
411                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
412                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
413                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
414                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
415                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
416
417                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
418                
419            rospy.sleep(2)
420
421            self.pub_tunnel_order.publish(msg_pub_tunnel_order)
422
423        self.is_triggered = False
424
425    def fnLaunch(self, launch_num, is_start):
426        if launch_num == self.Launcher.launch_camera_ex_calib.value:
427            if is_start == True:
428                if self.launch_camera_launched == False:
429                    self.launch_camera = roslaunch.scriptapi.ROSLaunch()
430                    self.launch_camera = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_camera/launch/turtlebot3_autorace_extrinsic_camera_calibration.launch"])
431                    self.launch_camera_launched = True
432                    self.launch_camera.start()
433                else:
434                    pass
435            else:
436                if self.launch_camera_launched == True:
437                    self.launch_camera_launched = False
438                    self.launch_camera.shutdown()
439                else:
440                    pass
441        elif launch_num == self.Launcher.launch_detect_sign.value:
442            if is_start == True:
443                if self.launch_detect_sign_launched == False:
444                    self.launch_detect_sign = roslaunch.scriptapi.ROSLaunch()
445                    self.launch_detect_sign = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_sign.launch"])
446                    self.launch_detect_sign_launched = True
447                    self.launch_detect_sign.start()
448                else:
449                    pass
450            else:
451                if self.launch_detect_sign_launched == True:
452                    self.launch_detect_sign_launched = False
453                    self.launch_detect_sign.shutdown()
454                else:
455                    pass                
456        elif launch_num == self.Launcher.launch_detect_lane.value:
457            if is_start == True:
458                if self.launch_detect_lane_launched == False:
459                    self.launch_detect_lane = roslaunch.scriptapi.ROSLaunch()
460                    self.launch_detect_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_lane.launch"])
461                    self.launch_detect_lane_launched = True
462                    self.launch_detect_lane.start()
463                else:
464                    pass
465            else:
466                if self.launch_detect_lane_launched == True:
467                    self.launch_detect_lane_launched = False
468                    self.launch_detect_lane.shutdown()
469                else:
470                    pass                  
471        elif launch_num == self.Launcher.launch_control_lane.value:
472            if is_start == True:
473                if self.launch_control_lane_launched == False:
474                    self.launch_control_lane = roslaunch.scriptapi.ROSLaunch()
475                    self.launch_control_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_lane.launch"])
476                    self.launch_control_lane_launched = True
477                    self.launch_control_lane.start()
478                else:
479                    pass
480            else:
481                if self.launch_control_lane_launched == True:
482                    self.launch_control_lane_launched = False
483                    self.launch_control_lane.shutdown()
484                else:
485                    pass                  
486        elif launch_num == self.Launcher.launch_detect_parking.value:
487            if is_start == True:
488                if self.launch_detect_parking_launched == False:
489                    self.launch_detect_parking = roslaunch.scriptapi.ROSLaunch()
490                    self.launch_detect_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_parking.launch"])
491                    self.launch_detect_parking_launched = True
492                    self.launch_detect_parking.start()
493                else:
494                    pass
495            else:
496                if self.launch_detect_parking_launched == True:
497                    self.launch_detect_parking_launched = False
498                    self.launch_detect_parking.shutdown()
499                else:
500                    pass                  
501        elif launch_num == self.Launcher.launch_control_parking.value:
502            if is_start == True:
503                if self.launch_control_parking_launched == False:
504                    self.launch_control_parking = roslaunch.scriptapi.ROSLaunch()
505                    self.launch_control_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_parking.launch"])     
506                    self.launch_control_parking_launched = True
507                    self.launch_control_parking.start()
508                else:
509                    pass
510            else:
511                if self.launch_control_parking_launched == True:
512                    self.launch_control_parking_launched = False
513                    self.launch_control_parking.shutdown()
514                else:
515                    pass
516        elif launch_num == self.Launcher.launch_detect_level.value:
517            if is_start == True:
518                if self.launch_detect_level_launched == False:
519                    self.launch_detect_level = roslaunch.scriptapi.ROSLaunch()
520                    self.launch_detect_level = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_level.launch"])     
521                    self.launch_detect_level_launched = True
522                    self.launch_detect_level.start()
523                else:
524                    pass
525            else:
526                if self.launch_detect_level_launched == True:
527                    self.launch_detect_level_launched = False
528                    self.launch_detect_level.shutdown()
529                else:
530                    pass                  
531        elif launch_num == self.Launcher.launch_detect_traffic_light.value:
532            if is_start == True:
533                if self.launch_detect_traffic_light_launched == False:
534                    self.launch_detect_traffic_light = roslaunch.scriptapi.ROSLaunch()
535                    self.launch_detect_traffic_light = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_traffic_light.launch"])     
536                    self.launch_detect_traffic_light_launched = True
537                    self.launch_detect_traffic_light.start()
538                else:
539                    pass
540            else:
541                if self.launch_detect_traffic_light_launched == True:
542                    self.launch_detect_traffic_light_launched = False
543                    self.launch_detect_traffic_light.shutdown()
544                else:
545                    pass    
546                    
547        elif launch_num == self.Launcher.launch_detect_tunnel.value:
548            if is_start == True:
549                if self.launch_detect_tunnel_launched == False:
550                    self.launch_detect_tunnel = roslaunch.scriptapi.ROSLaunch()
551                    self.launch_detect_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_tunnel.launch"])     
552                    self.launch_detect_tunnel_launched = True
553                    self.launch_detect_tunnel.start()
554                else:
555                    pass
556            else:
557                if self.launch_detect_tunnel_launched == True:
558                    self.launch_detect_tunnel_launched = False
559                    self.launch_detect_tunnel.shutdown()
560                else:
561                    pass    
562        elif launch_num == self.Launcher.launch_control_tunnel.value:
563            if is_start == True:
564                if self.launch_control_tunnel_launched == False:
565                    self.launch_control_tunnel = roslaunch.scriptapi.ROSLaunch()
566                    self.launch_control_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_tunnel.launch"])     
567                    self.launch_control_tunnel_launched = True
568                    self.launch_control_tunnel.start()
569                else:
570                    pass
571            else:
572                if self.launch_control_tunnel_launched == True:
573                    self.launch_control_tunnel_launched = False
574                    self.launch_control_tunnel.shutdown()
575                else:
576                    pass
577
578    def main(self):
579        rospy.spin()
580
581if __name__ == '__main__':
582    rospy.init_node('core_node_controller')
583    node = CoreNodeController()
584    node.main()
585

Source: core_node_controller.stamp

#!/usr/bin/env python
# -*- coding: utf-8 -*-

################################################################################
# Copyright 2018 ROBOTIS CO., LTD.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
################################################################################

# Authors: Leon Jung, [AuTURBO] Kihoon Kim (https://github.com/auturbo), Gilbert

import rospy, roslaunch
import numpy as np
import subprocess
import os
import sys
from enum import Enum
from std_msgs.msg import UInt8
 
class CoreNodeController():
    def __init__(self):
        self.ros_package_path = os.path.dirname(os.path.realpath(__file__))
        self.ros_package_path = self.ros_package_path.replace('turtlebot3_autorace_core/nodes', '')

        self.sub_mode_control = rospy.Subscriber('/core/decided_mode', UInt8, self.cbReceiveMode, queue_size=1)

        self.CurrentMode = Enum('CurrentMode', 'idle lane_following traffic_light parking_lot level_crossing tunnel')

        # subscribes : status returned
        self.sub_parking_lot_stamped = rospy.Subscriber('/detect/parking_lot_stamped', UInt8, self.cbParkingLotStamped, queue_size=1)
        self.sub_level_crossing_stamped = rospy.Subscriber('/detect/level_crossing_stamped', UInt8, self.cbLevelCrossingStamped, queue_size=1)
        self.sub_tunnel_stamped = rospy.Subscriber('/detect/tunnel_stamped', UInt8, self.cbTunnelStamped, queue_size=1)

        # publishes orders
        self.pub_traffic_light_order = rospy.Publisher('/detect/traffic_light_order', UInt8, queue_size=1)
        self.pub_parking_lot_order = rospy.Publisher('/detect/parking_lot_order', UInt8, queue_size=1)
        self.pub_level_crossing_order = rospy.Publisher('/detect/level_crossing_order', UInt8, queue_size=1)
        self.pub_tunnel_order = rospy.Publisher('/detect/tunnel_order', UInt8, queue_size=1)

        self.pub_mode_return = rospy.Publisher('/core/returned_mode', UInt8, queue_size=1)

        self.StepOfParkingLot = Enum('StepOfParkingLot', 'searching_parking_sign searching_parking_point_line searching_nonreserved_parking_area parking')
        self.StepOfLevelCrossing = Enum('StepOfLevelCrossing', 'searching_stop_sign searching_level watching_level stop pass_level')
        self.StepOfTunnel = Enum('StepOfTunnel', 'searching_tunnel_sign go_in_to_tunnel navigation go_out_from_tunnel exit')

        self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value
        self.current_step_level_crossing = self.StepOfLevelCrossing.searching_stop_sign.value
        self.current_step_tunnel = self.StepOfTunnel.searching_tunnel_sign.value

        self.Launcher = Enum('Launcher', 'launch_camera_ex_calib launch_detect_sign launch_detect_lane launch_control_lane launch_detect_traffic_light launch_control_traffic_light launch_detect_parking launch_control_parking launch_detect_level launch_control_level launch_detect_tunnel launch_control_tunnel')

        self.uuid = roslaunch.rlutil.get_or_generate_uuid(None, False)
        
        self.launch_camera_launched = False
        self.launch_detect_sign_launched = False
        self.launch_detect_lane_launched = False    
        self.launch_control_lane_launched = False
        self.launch_detect_parking_launched = False
        self.launch_control_parking_launched = False
        self.launch_detect_level_launched = False
        self.launch_detect_traffic_light_launched = False
        self.launch_detect_tunnel_launched = False
        self.launch_control_tunnel_launched = False

        self.current_mode = self.CurrentMode.idle.value

        self.is_triggered = False

        loop_rate = rospy.Rate(10) # 10hz
        while not rospy.is_shutdown():
            if self.is_triggered == True:
                self.fnControlNode()
            
            loop_rate.sleep()

    def cbReceiveMode(self, mode_msg):
        rospy.loginfo("starts the progress with %d", mode_msg.data)
        
        self.current_mode = mode_msg.data
        self.is_triggered = True

    # Which step is in Parking Lot
    def cbParkingLotStamped(self, parking_lot_msg):
        rospy.loginfo("ParkingLot Step changed from %d", self.current_step_parking_lot)

        self.current_step_parking_lot = parking_lot_msg.data

        rospy.loginfo("into %d", self.current_step_parking_lot)

        if self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
            self.current_mode = self.CurrentMode.lane_following.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.current_step_parking_lot = self.StepOfParkingLot.searching_parking_sign.value

            rospy.loginfo("pub_mode_return")
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    # Which step is in Level Crossing  
    def cbLevelCrossingStamped(self, level_crossing_msg):
        rospy.loginfo("LevelCrossing Step changed from %d", self.current_step_level_crossing)

        self.current_step_level_crossing = level_crossing_msg.data

        rospy.loginfo("into %d", self.current_step_level_crossing)

        if self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
            self.current_mode = self.CurrentMode.level_crossing.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    # Which step is in Tunnel
    def cbTunnelStamped(self, tunnel_msg):
        rospy.loginfo("Tunnel Step changed from %d", self.current_step_tunnel)

        self.current_step_tunnel = tunnel_msg.data

        rospy.loginfo("into %d", self.current_step_tunnel)

        if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
            self.current_mode = self.CurrentMode.tunnel.value
            msg_mode_return = UInt8()
            msg_mode_return.data = self.current_mode
            self.pub_mode_return.publish(msg_mode_return)

        self.is_triggered = True

    def fnControlNode(self):
        # lane_following
        if self.current_mode == self.CurrentMode.lane_following.value:
            rospy.loginfo("New trigger for lane_following")

            self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)

            self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
            self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
            self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
            self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
            self.fnLaunch(self.Launcher.launch_detect_level.value, False)
            self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

            self.fnLaunch(self.Launcher.launch_control_lane.value, True)
            self.fnLaunch(self.Launcher.launch_control_parking.value, False)
            self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
              
        # traffic_light
        elif self.current_mode == self.CurrentMode.traffic_light.value:
            rospy.loginfo("New trigger for traffic_light")
            msg_pub_traffic_light_order = UInt8()

            if self.current_step_traffic_light == self.StepOfTrafficLight.searching_traffic_light.value:
                rospy.loginfo("Current step : searching_traffic_light")
                rospy.loginfo("Go to next step : in_traffic_light")

                msg_pub_traffic_light_order.data = self.StepOfTrafficLight.in_traffic_light.value

                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_level.value, False)

            elif self.current_step_traffic_light == self.StepOfTrafficLight.in_traffic_light.value:
                rospy.loginfo("Current step : in_traffic_light")
                rospy.loginfo("Go to next step : pass_traffic_light")

                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_level.value, False)

            rospy.sleep(2)

            self.pub_traffic_light_order.publish(msg_pub_traffic_light_order)

        # parking_lot
        elif self.current_mode == self.CurrentMode.parking_lot.value:
            rospy.loginfo("New trigger for parking_lot")
            msg_pub_parking_lot_order = UInt8()

            if self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_sign.value:
                rospy.loginfo("Current step : searching_parking_sign")
                rospy.loginfo("Go to next step : searching_parking_point_line")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_point_line.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, False)

                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                                   
            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_parking_point_line.value:
                rospy.loginfo("Current step : searching_parking_point_line")
                rospy.loginfo("Go to next step : searching_nonreserved_parking_area")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_nonreserved_parking_area.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_parking.value, True)

                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_parking_lot == self.StepOfParkingLot.searching_nonreserved_parking_area.value:
                rospy.loginfo("Current step : searching_nonreserved_parking_area")
                rospy.loginfo("Go to next step : parking")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.parking.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_control_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_parking_lot == self.StepOfParkingLot.parking.value:
                rospy.loginfo("Current step : parking")
                rospy.loginfo("Go to next step : searching_parking_sign")

                msg_pub_parking_lot_order.data = self.StepOfParkingLot.searching_parking_sign.value

                self.fnLaunch(self.Launcher.launch_control_parking.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_parking.value, False)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            rospy.sleep(2)

            self.pub_parking_lot_order.publish(msg_pub_parking_lot_order)

        # level_crossing
        elif self.current_mode == self.CurrentMode.level_crossing.value:
            rospy.loginfo("New trigger for level_crossing")
            msg_pub_level_crossing_order = UInt8()

            if self.current_step_level_crossing == self.StepOfLevelCrossing.searching_stop_sign.value:
                rospy.loginfo("Current step : searching_stop_sign")
                rospy.loginfo("Go to next step : searching_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                                   
            elif self.current_step_level_crossing == self.StepOfLevelCrossing.searching_level.value:
                rospy.loginfo("Current step : searching_level")
                rospy.loginfo("Go to next step : watching_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.watching_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.watching_level.value:
                rospy.loginfo("Current step : watching_level")
                rospy.loginfo("Go to next step : stop")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.stop.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.stop.value:
                rospy.loginfo("Current step : stop")
                rospy.loginfo("Go to next step : pass_level")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.pass_level.value

                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            elif self.current_step_level_crossing == self.StepOfLevelCrossing.pass_level.value:
                rospy.loginfo("Current step : pass_level")
                rospy.loginfo("Go to next step : searching_stop_sign")

                msg_pub_level_crossing_order.data = self.StepOfLevelCrossing.searching_stop_sign.value

                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

            rospy.sleep(2)

            self.pub_level_crossing_order.publish(msg_pub_level_crossing_order)

        # tunnel
        elif self.current_mode == self.CurrentMode.tunnel.value:
            rospy.loginfo("New trigger for tunnel")
            msg_pub_tunnel_order = UInt8()

            if self.current_step_tunnel == self.StepOfTunnel.searching_tunnel_sign.value:
                rospy.loginfo("Current step : searching_tunnel_sign")
                rospy.loginfo("Go to next step : go_in_to_tunnel")

                msg_pub_tunnel_order.data = self.StepOfTunnel.go_in_to_tunnel.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
                                   
            elif self.current_step_tunnel == self.StepOfTunnel.go_in_to_tunnel.value:
                rospy.loginfo("Current step : go_in_to_tunnel")
                rospy.loginfo("Go to next step : navigation")

                msg_pub_tunnel_order.data = self.StepOfTunnel.navigation.value

                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, False)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, True)

            elif self.current_step_tunnel == self.StepOfTunnel.navigation.value:
                rospy.loginfo("Current step : navigation")
                rospy.loginfo("Go to next step : go_out_from_tunnel")

                msg_pub_tunnel_order.data = self.StepOfTunnel.go_out_from_tunnel.value

                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, False)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, False)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, False)
                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, True)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)

            elif self.current_step_tunnel == self.StepOfTunnel.go_out_from_tunnel.value:
                rospy.loginfo("Current step : go_out_from_tunnel")
                rospy.loginfo("Go to next step : exit")

                msg_pub_tunnel_order.data = self.StepOfTunnel.exit.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)

            elif self.current_step_tunnel == self.StepOfTunnel.exit.value:
                rospy.loginfo("Current step : exit")
                rospy.loginfo("Go to next step : searching_tunnel_sign")

                msg_pub_tunnel_order.data = self.StepOfTunnel.searching_tunnel_sign.value

                self.fnLaunch(self.Launcher.launch_detect_tunnel.value, False)
                self.fnLaunch(self.Launcher.launch_camera_ex_calib.value, True)
                self.fnLaunch(self.Launcher.launch_detect_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_sign.value, True)
                self.fnLaunch(self.Launcher.launch_detect_traffic_light.value, True)
                self.fnLaunch(self.Launcher.launch_control_lane.value, True)
                self.fnLaunch(self.Launcher.launch_detect_level.value, False)

                self.fnLaunch(self.Launcher.launch_control_tunnel.value, False)
                
            rospy.sleep(2)

            self.pub_tunnel_order.publish(msg_pub_tunnel_order)

        self.is_triggered = False

    def fnLaunch(self, launch_num, is_start):
        if launch_num == self.Launcher.launch_camera_ex_calib.value:
            if is_start == True:
                if self.launch_camera_launched == False:
                    self.launch_camera = roslaunch.scriptapi.ROSLaunch()
                    self.launch_camera = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_camera/launch/turtlebot3_autorace_extrinsic_camera_calibration.launch"])
                    self.launch_camera_launched = True
                    self.launch_camera.start()
                else:
                    pass
            else:
                if self.launch_camera_launched == True:
                    self.launch_camera_launched = False
                    self.launch_camera.shutdown()
                else:
                    pass
        elif launch_num == self.Launcher.launch_detect_sign.value:
            if is_start == True:
                if self.launch_detect_sign_launched == False:
                    self.launch_detect_sign = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_sign = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_sign.launch"])
                    self.launch_detect_sign_launched = True
                    self.launch_detect_sign.start()
                else:
                    pass
            else:
                if self.launch_detect_sign_launched == True:
                    self.launch_detect_sign_launched = False
                    self.launch_detect_sign.shutdown()
                else:
                    pass                
        elif launch_num == self.Launcher.launch_detect_lane.value:
            if is_start == True:
                if self.launch_detect_lane_launched == False:
                    self.launch_detect_lane = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_lane.launch"])
                    self.launch_detect_lane_launched = True
                    self.launch_detect_lane.start()
                else:
                    pass
            else:
                if self.launch_detect_lane_launched == True:
                    self.launch_detect_lane_launched = False
                    self.launch_detect_lane.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_control_lane.value:
            if is_start == True:
                if self.launch_control_lane_launched == False:
                    self.launch_control_lane = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_lane = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_lane.launch"])
                    self.launch_control_lane_launched = True
                    self.launch_control_lane.start()
                else:
                    pass
            else:
                if self.launch_control_lane_launched == True:
                    self.launch_control_lane_launched = False
                    self.launch_control_lane.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_detect_parking.value:
            if is_start == True:
                if self.launch_detect_parking_launched == False:
                    self.launch_detect_parking = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_parking.launch"])
                    self.launch_detect_parking_launched = True
                    self.launch_detect_parking.start()
                else:
                    pass
            else:
                if self.launch_detect_parking_launched == True:
                    self.launch_detect_parking_launched = False
                    self.launch_detect_parking.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_control_parking.value:
            if is_start == True:
                if self.launch_control_parking_launched == False:
                    self.launch_control_parking = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_parking = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_parking.launch"])     
                    self.launch_control_parking_launched = True
                    self.launch_control_parking.start()
                else:
                    pass
            else:
                if self.launch_control_parking_launched == True:
                    self.launch_control_parking_launched = False
                    self.launch_control_parking.shutdown()
                else:
                    pass
        elif launch_num == self.Launcher.launch_detect_level.value:
            if is_start == True:
                if self.launch_detect_level_launched == False:
                    self.launch_detect_level = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_level = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_level.launch"])     
                    self.launch_detect_level_launched = True
                    self.launch_detect_level.start()
                else:
                    pass
            else:
                if self.launch_detect_level_launched == True:
                    self.launch_detect_level_launched = False
                    self.launch_detect_level.shutdown()
                else:
                    pass                  
        elif launch_num == self.Launcher.launch_detect_traffic_light.value:
            if is_start == True:
                if self.launch_detect_traffic_light_launched == False:
                    self.launch_detect_traffic_light = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_traffic_light = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_traffic_light.launch"])     
                    self.launch_detect_traffic_light_launched = True
                    self.launch_detect_traffic_light.start()
                else:
                    pass
            else:
                if self.launch_detect_traffic_light_launched == True:
                    self.launch_detect_traffic_light_launched = False
                    self.launch_detect_traffic_light.shutdown()
                else:
                    pass    
                    
        elif launch_num == self.Launcher.launch_detect_tunnel.value:
            if is_start == True:
                if self.launch_detect_tunnel_launched == False:
                    self.launch_detect_tunnel = roslaunch.scriptapi.ROSLaunch()
                    self.launch_detect_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_detect/launch/turtlebot3_autorace_detect_tunnel.launch"])     
                    self.launch_detect_tunnel_launched = True
                    self.launch_detect_tunnel.start()
                else:
                    pass
            else:
                if self.launch_detect_tunnel_launched == True:
                    self.launch_detect_tunnel_launched = False
                    self.launch_detect_tunnel.shutdown()
                else:
                    pass    
        elif launch_num == self.Launcher.launch_control_tunnel.value:
            if is_start == True:
                if self.launch_control_tunnel_launched == False:
                    self.launch_control_tunnel = roslaunch.scriptapi.ROSLaunch()
                    self.launch_control_tunnel = roslaunch.parent.ROSLaunchParent(self.uuid, [self.ros_package_path + "turtlebot3_autorace_control/launch/turtlebot3_autorace_control_tunnel.launch"])     
                    self.launch_control_tunnel_launched = True
                    self.launch_control_tunnel.start()
                else:
                    pass
            else:
                if self.launch_control_tunnel_launched == True:
                    self.launch_control_tunnel_launched = False
                    self.launch_control_tunnel.shutdown()
                else:
                    pass

    def main(self):
        rospy.spin()

if __name__ == '__main__':
    rospy.init_node('core_node_controller')
    node = CoreNodeController()
    node.main()

1from ament_index_python import get_package_share_directory
2from launch import LaunchDescription
3from launch.actions import DeclareLaunchArgument
4from launch.actions import IncludeLaunchDescription
5from launch.launch_description_sources import PythonLaunchDescriptionSource
6from launch.substitutions import LaunchConfiguration
7from launch_ros.actions import Node
8
9import os
10
11
12def generate_launch_description():
13    aichallenge_sample_pkg_prefix = get_package_share_directory('aichallenge_sample')
14
15    aichallenge_sample_launch = IncludeLaunchDescription(
16        PythonLaunchDescriptionSource([aichallenge_sample_pkg_prefix, '/launch/aichallenge_sample.launch.py']),
17        launch_arguments={}.items()
18    )
19
20    return LaunchDescription([
21        aichallenge_sample_launch,
22    ])
23

Source: aichallenge_submit_launch.launch.py

from ament_index_python import get_package_share_directory
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node

import os


def generate_launch_description():
    aichallenge_sample_pkg_prefix = get_package_share_directory('aichallenge_sample')

    aichallenge_sample_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([aichallenge_sample_pkg_prefix, '/launch/aichallenge_sample.launch.py']),
        launch_arguments={}.items()
    )

    return LaunchDescription([
        aichallenge_sample_launch,
    ])

1'use strict';
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.LaunchUIComponent = undefined;
7
8var _string;
9
10function _load_string() {
11  return _string = require('nuclide-commons/string');
12}
13
14var _react = _interopRequireDefault(require('react'));
15
16var _AtomInput;
17
18function _load_AtomInput() {
19  return _AtomInput = require('nuclide-commons-ui/AtomInput');
20}
21
22var _UniversalDisposable;
23
24function _load_UniversalDisposable() {
25  return _UniversalDisposable = _interopRequireDefault(require('nuclide-commons/UniversalDisposable'));
26}
27
28var _nuclideUri;
29
30function _load_nuclideUri() {
31  return _nuclideUri = _interopRequireDefault(require('nuclide-commons/nuclideUri'));
32}
33
34var _nuclideDebuggerBase;
35
36function _load_nuclideDebuggerBase() {
37  return _nuclideDebuggerBase = require('../../nuclide-debugger-base');
38}
39
40var _classnames;
41
42function _load_classnames() {
43  return _classnames = _interopRequireDefault(require('classnames'));
44}
45
46function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
47
48class LaunchUIComponent extends _react.default.Component {
49
50  constructor(props) {
51    super(props);
52
53    this._handleLaunchClick = () => {
54      // TODO: perform some validation for the input.
55      const launchExecutable = this.refs.launchExecutable.getText().trim();
56      const coreDump = this.refs.coreDump.getText().trim();
57      const launchArguments = (0, (_string || _load_string()).shellParse)(this.refs.launchArguments.getText());
58      const launchEnvironmentVariables = (0, (_string || _load_string()).shellParse)(this.refs.launchEnvironmentVariables.getText());
59      const launchWorkingDirectory = this.refs.launchWorkingDirectory.getText().trim();
60      const stdinFilePath = this.refs.stdinFilePath.getText().trim();
61      const launchTarget = {
62        executablePath: launchExecutable,
63        arguments: launchArguments,
64        environmentVariables: launchEnvironmentVariables,
65        workingDirectory: launchWorkingDirectory,
66        stdinFilePath,
67        coreDump
68      };
69      // Fire and forget.
70      this.props.actions.launchDebugger(launchTarget);
71
72      (0, (_nuclideDebuggerBase || _load_nuclideDebuggerBase()).serializeDebuggerConfig)(...this._getSerializationArgs(), {
73        launchExecutable: this.state.launchExecutable,
74        launchArguments: this.state.launchArguments,
75        launchEnvironmentVariables: this.state.launchEnvironmentVariables,
76        launchWorkingDirectory: this.state.launchWorkingDirectory,
77        stdinFilePath: this.state.stdinFilePath,
78        coreDump: this.state.coreDump
79      });
80    };
81
82    this._disposables = new (_UniversalDisposable || _load_UniversalDisposable()).default();
83    this.state = {
84      launchExecutable: '',
85      launchArguments: '',
86      launchEnvironmentVariables: '',
87      launchWorkingDirectory: '',
88      stdinFilePath: '',
89      coreDump: ''
90    };
91  }
92
93  _getSerializationArgs() {
94    return [(_nuclideUri || _load_nuclideUri()).default.isRemote(this.props.targetUri) ? (_nuclideUri || _load_nuclideUri()).default.getHostname(this.props.targetUri) : 'local', 'launch', 'native'];
95  }
96
97  setState(newState) {
98    super.setState(newState);
99    this.props.configIsValidChanged(this._debugButtonShouldEnable());
100  }
101
102  _debugButtonShouldEnable() {
103    return true;
104  }
105
106  componentDidMount() {
107    (0, (_nuclideDebuggerBase || _load_nuclideDebuggerBase()).deserializeDebuggerConfig)(...this._getSerializationArgs(), (transientSettings, savedSettings) => {
108      this.setState({
109        launchExecutable: savedSettings.launchExecutable,
110        launchArguments: savedSettings.launchArguments,
111        launchEnvironmentVariables: savedSettings.launchEnvironmentVariables,
112        launchWorkingDirectory: savedSettings.launchWorkingDirectory,
113        stdinFilePath: savedSettings.stdinFilePath,
114        coreDump: savedSettings.coreDump || ''
115      });
116    });
117
118    const launchExecutableInput = this.refs.launchExecutable;
119    if (launchExecutableInput != null) {
120      launchExecutableInput.focus();
121    }
122
123    this._disposables.add(atom.commands.add('atom-workspace', {
124      'core:confirm': () => {
125        this._handleLaunchClick();
126      }
127    }));
128
129    this.props.configIsValidChanged(true);
130  }
131
132  componentWillUnmount() {
133    this._disposables.dispose();
134  }
135
136  render() {
137    // TODO: smart fill the working directory textbox.
138    // TODO: make tab stop between textbox work.
139    // Reserve tabIndex [1~10] to header portion of the UI so we start from "11" here.
140    return _react.default.createElement(
141      'div',
142      { className: 'block' },
143      _react.default.createElement(
144        'label',
145        null,
146        'Executable: '
147      ),
148      _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
149        ref: 'launchExecutable',
150        tabIndex: '11',
151        placeholderText: 'Input the executable path you want to launch',
152        value: this.state.launchExecutable,
153        onDidChange: value => this.setState({ launchExecutable: value })
154      }),
155      _react.default.createElement(
156        'label',
157        null,
158        'Core dump file: '
159      ),
160      _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
161        ref: 'coreDump',
162        tabIndex: '12',
163        placeholderText: 'Optional path to a core dump file to offline debug a crash',
164        value: this.state.coreDump,
165        onDidChange: value => this.setState({ coreDump: value })
166      }),
167      _react.default.createElement(
168        'div',
169        { className: 'nuclide-native-launch-small-text' },
170        'Be sure to copy the core dump to a location where Nuclide has read access. (Nuclide server does not run as root).'
171      ),
172      _react.default.createElement(
173        'div',
174        {
175          className: (0, (_classnames || _load_classnames()).default)({
176            'nuclide-native-launch-disabled': this.state.coreDump !== ''
177          }) },
178        _react.default.createElement(
179          'label',
180          null,
181          'Arguments: '
182        ),
183        _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
184          ref: 'launchArguments',
185          tabIndex: '13',
186          disabled: this.state.coreDump !== '',
187          placeholderText: 'Arguments to the executable',
188          value: this.state.launchArguments,
189          onDidChange: value => this.setState({ launchArguments: value })
190        }),
191        _react.default.createElement(
192          'label',
193          null,
194          'Environment Variables: '
195        ),
196        _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
197          ref: 'launchEnvironmentVariables',
198          tabIndex: '14',
199          disabled: this.state.coreDump !== '',
200          placeholderText: 'Environment variables (e.g., SHELL=/bin/bash PATH=/bin)',
201          value: this.state.launchEnvironmentVariables,
202          onDidChange: value => this.setState({ launchEnvironmentVariables: value })
203        }),
204        _react.default.createElement(
205          'label',
206          null,
207          'Working directory: '
208        ),
209        _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
210          ref: 'launchWorkingDirectory',
211          tabIndex: '15',
212          disabled: this.state.coreDump !== '',
213          placeholderText: 'Working directory for the launched executable',
214          value: this.state.launchWorkingDirectory,
215          onDidChange: value => this.setState({ launchWorkingDirectory: value })
216        }),
217        _react.default.createElement(
218          'label',
219          null,
220          'Stdin file: '
221        ),
222        _react.default.createElement((_AtomInput || _load_AtomInput()).AtomInput, {
223          ref: 'stdinFilePath',
224          tabIndex: '16',
225          disabled: this.state.coreDump !== '',
226          placeholderText: 'Redirect stdin to this file',
227          value: this.state.stdinFilePath,
228          onDidChange: value => this.setState({ stdinFilePath: value })
229        })
230      )
231    );
232  }
233
234}
235exports.LaunchUIComponent = LaunchUIComponent; /**
236                                                * Copyright (c) 2015-present, Facebook, Inc.
237                                                * All rights reserved.
238                                                *
239                                                * This source code is licensed under the license found in the LICENSE file in
240                                                * the root directory of this source tree.
241                                                *
242                                                * 
243                                                * @format
244                                                */