bool ChatServer::start(int, char*[], int& status) { _timer = new IceUtil::Timer(); // Timeout for reaping polling sessions. int timeout = communicator()->getProperties()->getPropertyAsIntWithDefault("ReaperTimeout", 10); bool traceEnabled = communicator()->getProperties()->getPropertyAsIntWithDefault("Server.Trace", 0) != 0; Ice::LoggerPtr logger = communicator()->getLogger(); ReaperTaskPtr reaper = new ReaperTask(timeout, traceEnabled, logger); _timer->scheduleRepeated(reaper, IceUtil::Time::seconds(timeout)); try { _adapter = communicator()->createObjectAdapter("ChatServer"); ChatRoomPtr chatRoom = new ChatRoom(traceEnabled, logger); if(traceEnabled) { ostringstream os; os << "Chat room created ok."; logger->trace("info", os.str()); } _adapter->add(new ChatSessionManagerI(chatRoom, traceEnabled, logger), communicator()->stringToIdentity("ChatSessionManager")); if(traceEnabled) { ostringstream os; os << "Chat session manager created ok."; logger->trace("info", os.str()); } _adapter->add(new PollingChatSessionFactoryI(chatRoom, reaper, traceEnabled, logger), communicator()->stringToIdentity("PollingChatSessionFactory")); if(traceEnabled) { ostringstream os; os << "Polling chat session factory created ok."; logger->trace("info", os.str()); } _adapter->activate(); if(traceEnabled) { ostringstream os; os << "Chat server started ok."; logger->trace("info", os.str()); } } catch(const Ice::LocalException&) { status = EXIT_FAILURE; _timer->destroy(); throw; } status = EXIT_SUCCESS; return true; }
void ServoGroup::setStarted(bool started) { IceUtil::Mutex::Lock lock(this->hw_mutex); if(this->is_started == false && started == true) {// start static const size_t servo_gpio = 11; this->mem_fd = pwm_open_devmem(); if(this->mem_fd == -1) { Ice::LoggerPtr logger = Ice::Service::instance()->communicator()->getLogger(); string msg = "Unable to open /dev/mem, are you root?"; logger->error(msg); throw runtime_error(msg); } // Enable ICLK clock pwm_iclken_clock(this->mem_fd, true, true); // Enable FCLK clock pwm_fclken_clock(this->mem_fd, true, true); // Set instances 10 and 11 to use the 13 Mhz clock pwm_config_clock(this->mem_fd, true, true); this->gpio_timer = pwm_mmap_instance(mem_fd, servo_gpio); // Get the resolution for 20ms period (50Hz) PWM this->resolution = pwm_calc_resolution(50, PWM_FREQUENCY_13MHZ); pwm_config_timer(this->gpio_timer, this->resolution, this->current_duty); // middle position } else if(this->is_started == true && started == false) {// stop pwm_munmap_instance(this->gpio_timer); // Disable ICLK clock pwm_iclken_clock(this->mem_fd, false, false); // Disable FCLK clock pwm_fclken_clock(this->mem_fd, false, false); pwm_close_devmem(this->mem_fd); this->mem_fd = -1; } this->is_started = started; }
IceApp::sensorinfo_t IceApp::connectToSensor(const std::string &sensor_name) const { Ice::PropertiesPtr props = this->communicator()->getProperties(); Ice::LoggerPtr log = this->communicator()->getLogger(); try { log->print(string("Connecting to ") + sensor_name + " sensor"); const string prop_name = sensor_name + ".proxy"; string sensor_str_proxy = props->getProperty(prop_name); sensors::SensorGroupPrx sensor_prx; if(sensor_str_proxy.empty()) log->warning(prop_name + string(" property is not set. No ") + sensor_name + "."); else { Ice::ObjectPrx objprx = this->communicator()->stringToProxy(sensor_str_proxy); sensor_prx = sensors::SensorGroupPrx::checkedCast(objprx); if(!sensor_prx) log->warning(string("Can not connect to ") + sensor_name + string(" sensor. No ") + sensor_name + "."); else { string msg = "Connected to sensor group "; log->print(msg + sensor_name); sensors::SensorDescriptionSeq descr = sensor_prx->getSensorDescription(); for(sensors::SensorDescriptionSeq::const_iterator d = descr.begin(); d != descr.end(); ++d) { ostringstream os; os << " Vendor id: " << d->vendorid << endl; os << " Description: " << d->description << endl; os << " Id: " << d->id << endl; os << " Min value: " << d->minvalue << endl; os << " Max value: " << d->maxvalue << endl; os << " Recommended refresh rate, Hz: " << d->refreshrate; log->print(os.str()); } return make_pair(sensor_prx, descr); } } } catch(const Ice::Exception& ex) { ostringstream os; os << "Can not connect to " << sensor_name << " sensor. No " << sensor_name + ".\n"; ex.ice_print(os); log->warning(os.str()); } return make_pair(sensors::SensorGroupPrx(), sensors::SensorDescriptionSeq()); }
IceApp::actuatorinfo_t IceApp::connectToActuator(const std::string &actuator_name) const { Ice::PropertiesPtr props = this->communicator()->getProperties(); Ice::LoggerPtr log = this->communicator()->getLogger(); try { log->print(string("Connecting to ") + actuator_name + " actuators"); const string prop_name = actuator_name + ".proxy"; string actuator_str_proxy = props->getProperty(prop_name); actuators::ActuatorGroupPrx actuator_prx; if(actuator_str_proxy.empty()) log->warning(prop_name + string(" property is not set. No ") + actuator_name + "."); else { Ice::ObjectPrx objprx = this->communicator()->stringToProxy(actuator_str_proxy); actuator_prx = actuators::ActuatorGroupPrx::checkedCast(objprx); if(!actuator_prx) log->warning(string("Can not connect to ") + actuator_name + string(" actuator. No ") + actuator_name + "."); else { string msg = "Connected to actuator group "; log->print(msg + actuator_name); actuators::ActuatorDescriptionSeq descr = actuator_prx->getActuatorDescription(); for(actuators::ActuatorDescriptionSeq::const_iterator d = descr.begin(); d != descr.end(); ++d) { ostringstream os; os << " Vendor id: " << d->vendorid << endl; os << " Description: " << d->description << endl; os << " Id: " << d->id << endl; log->print(os.str()); } return make_pair(actuator_prx, descr); } } } catch(const Ice::Exception &ex) { std::ostringstream os; os << "Can not connect to actuator " + actuator_name + ".\n"; ex.ice_print(os); log->warning(os.str()); } return make_pair(actuators::ActuatorGroupPrx(), actuators::ActuatorDescriptionSeq()); }
IceInternal::ACMConfig::ACMConfig(const Ice::PropertiesPtr& p, const Ice::LoggerPtr& l, const string& prefix, const ACMConfig& dflt) { string timeoutProperty; if((prefix == "Ice.ACM.Client" || prefix == "Ice.ACM.Server") && p->getProperty(prefix + ".Timeout").empty()) { timeoutProperty = prefix; // Deprecated property. } else { timeoutProperty = prefix + ".Timeout"; }; this->timeout = IceUtil::Time::seconds(p->getPropertyAsIntWithDefault(timeoutProperty, static_cast<int>(dflt.timeout.toSeconds()))); int hb = p->getPropertyAsIntWithDefault(prefix + ".Heartbeat", static_cast<int>(dflt.heartbeat)); if(hb >= static_cast<int>(ICE_ENUM(ACMHeartbeat, HeartbeatOff)) && hb <= static_cast<int>(ICE_ENUM(ACMHeartbeat, HeartbeatAlways))) { this->heartbeat = static_cast<Ice::ACMHeartbeat>(hb); } else { l->warning("invalid value for property `" + prefix + ".Heartbeat" + "', default value will be used instead"); this->heartbeat = dflt.heartbeat; } int cl = p->getPropertyAsIntWithDefault(prefix + ".Close", static_cast<int>(dflt.close)); if(cl >= static_cast<int>(ICE_ENUM(ACMClose, CloseOff)) && cl <= static_cast<int>(ICE_ENUM(ACMClose, CloseOnIdleForceful))) { this->close = static_cast<Ice::ACMClose>(cl); } else { l->warning("invalid value for property `" + prefix + ".Close" + "', default value will be used instead"); this->close = dflt.close; } }
int IceApp::run(int argc, char *argv[]) { RouterHelperPtr rh; Glacier2::RouterPrx defaultRouter; Ice::PropertiesPtr props = this->communicator()->getProperties(); Ice::LoggerPtr log = this->communicator()->getLogger(); // Try to create router with firewall support using Glacier service try { rh = new RouterHelper(this->communicator()); defaultRouter = rh->getRouter(); } catch(const Ice::Exception& ex) { ostringstream os; ex.ice_print(os); log->warning(os.str()); } // Create object adapter for sensor callback and keyboard sensor servants Ice::ObjectAdapterPtr adapter; if(defaultRouter) adapter = communicator()->createObjectAdapterWithRouter("Cockpit", defaultRouter); else adapter = communicator()->createObjectAdapter("Cockpit"); if(this->visuals.init(log, props)) { log->error("Visuals initialization failed"); return EXIT_FAILURE; } Ice::ObjectPrx objprx; // Initialize keyboard sensor (and admin) servants KeyboardAdminIPtr keyboard_admin = new KeyboardAdminI(); objprx = adapter->add(keyboard_admin, this->communicator()->stringToIdentity("keyboard-sensor-admin")); admin::StatePrx keyboard_admin_prx = admin::StatePrx::uncheckedCast(objprx); this->keyboard_sensor = new KeyboardSensorI(keyboard_admin_prx); keyboard_admin->setSensorGroup(this->keyboard_sensor); objprx = adapter->add(this->keyboard_sensor, this->communicator()->stringToIdentity("keyboard-sensor")); adapter->activate(); admin::StatePrx state_prx; // Initialize actuators list // Our chassis has two motors actuatorinfo_t cactinfo = this->connectToActuator("Chassis"); actuators::ActuatorGroupPrx cactuator_prx = cactinfo.first; //actuators::ActuatorDescriptionSeq cactdescr = actinfo.second; // Servo motor to rotate the head with cameras and front sonar actuatorinfo_t hactinfo = this->connectToActuator("Head"); actuators::ActuatorGroupPrx hactuator_prx = hactinfo.first; //actuators::ActuatorDescriptionSeq hactdescr = actinfo.second; // Initialize joystick callback servant sensorinfo_t info = this->connectToSensor("Joystick"); sensors::SensorGroupPrx sensor_prx = info.first; sensors::SensorDescriptionSeq descr = info.second; ActuatorControllerPtr joy_chassis_ctl; ActuatorControllerPtr joy_head_ctl; if(sensor_prx && !descr.empty()) { actctlkey_t key = std::make_pair(descr[0].id, descr[0].type); if(cactuator_prx) { joy_chassis_ctl.reset(new JoystickChassisCtl(cactuator_prx)); this->actuator_map.insert(std::make_pair(key, joy_chassis_ctl.get())); this->chassis_state_prx = cactuator_prx->getStateInterface(); this->chassis_state_prx->start(); } if(hactuator_prx) { joy_head_ctl.reset(new JoystickHeadCtl(hactuator_prx)); this->actuator_map.insert(std::make_pair(key, joy_head_ctl.get())); state_prx = hactuator_prx->getStateInterface(); state_prx->start(); } SensorFrameReceiverIPtr joystick_callback = new SensorFrameReceiverI(descr[0].type, descr[0].minvalue, descr[0].maxvalue, &this->buffer_queue, &this->visuals.tile_manager, &this->visuals.sensor_animations_map, &this->actuator_map); objprx = adapter->add(joystick_callback, rh->makeId("joystickcallback")); sensors::SensorFrameReceiverPrx joystick_callback_prx = sensors::SensorFrameReceiverPrx::uncheckedCast(objprx); sensor_prx->setSensorReceiver(joystick_callback_prx); state_prx = sensor_prx->getStateInterface(); state_prx->start(); } // Initialize keyboard callback servant info = this->connectToSensor("Keyboard"); sensor_prx = info.first; descr = info.second; ActuatorControllerPtr kbd_chassis_ctl; ActuatorControllerPtr kbd_head_ctl; if(sensor_prx && !descr.empty()) { actctlkey_t key = std::make_pair(descr[0].id, descr[0].type); if(cactuator_prx) { kbd_chassis_ctl.reset(new KeyboardChassisCtl(cactuator_prx)); this->actuator_map.insert(std::make_pair(key, kbd_chassis_ctl.get())); state_prx = cactuator_prx->getStateInterface(); state_prx->start(); } if(hactuator_prx) { kbd_head_ctl.reset(new KeyboardHeadCtl(hactuator_prx)); this->actuator_map.insert(std::make_pair(key, kbd_head_ctl.get())); state_prx = hactuator_prx->getStateInterface(); state_prx->start(); } SensorFrameReceiverIPtr kbd_callback = new SensorFrameReceiverI(descr[0].type, descr[0].minvalue, descr[0].maxvalue, &this->buffer_queue, &this->visuals.tile_manager, &this->visuals.sensor_animations_map, &this->actuator_map); objprx = adapter->add(kbd_callback, this->communicator()->stringToIdentity("kbdcallback")); sensors::SensorFrameReceiverPrx kbd_callback_prx = sensors::SensorFrameReceiverPrx::uncheckedCast(objprx); sensor_prx->setSensorReceiver(kbd_callback_prx); state_prx = sensor_prx->getStateInterface(); state_prx->start(); } // Initialize sonars callback servant info = this->connectToSensor("Sonars"); sensor_prx = info.first; descr = info.second; if(sensor_prx && !descr.empty()) { SensorFrameReceiverIPtr sonars_callback = new SensorFrameReceiverI(descr[0].type, descr[0].minvalue, descr[0].maxvalue, &this->buffer_queue, &this->visuals.tile_manager, &this->visuals.sensor_animations_map, NULL); objprx = adapter->add(sonars_callback, rh->makeId("sonarscallback")); sensors::SensorFrameReceiverPrx sonars_callback_prx = sensors::SensorFrameReceiverPrx::uncheckedCast(objprx); sensor_prx->setSensorReceiver(sonars_callback_prx); admin::StatePrx state_prx = sensor_prx->getStateInterface(); state_prx->start(); } // Initialize compass callback servant info = this->connectToSensor("Compass"); sensor_prx = info.first; descr = info.second; if(sensor_prx && !descr.empty()) { SensorFrameReceiverIPtr compass_callback = new SensorFrameReceiverI(descr[0].type, descr[0].minvalue, descr[0].maxvalue, &this->buffer_queue, &this->visuals.tile_manager, &this->visuals.sensor_animations_map, NULL); objprx = adapter->add(compass_callback, rh->makeId("compasscallback")); sensors::SensorFrameReceiverPrx compass_callback_prx = sensors::SensorFrameReceiverPrx::uncheckedCast(objprx); sensor_prx->setSensorReceiver(compass_callback_prx); admin::StatePrx state_prx = sensor_prx->getStateInterface(); state_prx->start(); } // Initialize camera callback servant info = this->connectToSensor("Camera"); sensor_prx = info.first; descr = info.second; if(sensor_prx && !descr.empty()) { const std::string prop_name = "Decoding.Pipeline"; std::string dec_pipeline = props->getProperty(prop_name); if(dec_pipeline.empty()) { log->warning(prop_name + " property not set. No video."); } else { this->video_decoder.initAndStart(argc, argv, dec_pipeline.c_str(), this->visuals.video_painters, &this->buffer_queue); SensorFrameReceiverIPtr camera_callback = new SensorFrameReceiverI(descr[0].type, descr[0].minvalue, descr[0].maxvalue, &this->buffer_queue, &this->visuals.tile_manager, &this->visuals.sensor_animations_map, NULL); objprx = adapter->add(camera_callback, rh->makeId("cameracallback")); sensors::SensorFrameReceiverPrx camera_callback_prx = sensors::SensorFrameReceiverPrx::uncheckedCast(objprx); sensor_prx->setSensorReceiver(camera_callback_prx); state_prx = sensor_prx->getStateInterface(); state_prx->start(); } } this->mainloop(); // Be nice and stop chassis motors on exit if(this->chassis_state_prx) { this->chassis_state_prx->stop(); this->chassis_state_prx = 0; } return EXIT_SUCCESS; }