/*! */ void MonitorServer::parseMonitorInit( const char * msg, const QHostAddress & addr, const quint16 port ) { double ver = 1.0; if ( ! std::strcmp( msg, "(dispinit)" ) ) { RemoteMonitor * mon = new RemoteMonitor( this, 1 ); if ( ! mon->connect( addr, port ) ) { delete mon; return; } std::cout << "a new (v1) monitor connected" << std::endl; M_monitors.push_back( mon ); sendInit( *mon ); return; } if ( std::sscanf( msg, "(dispinit version %lf)", &ver ) == 1 ) { if ( ver < 1.0 || 5.0 <= ver ) { std::cout << "Unsupported monitor protocol version. " << ver << std::endl; return; } // a new monitor connected RemoteMonitor * mon = new RemoteMonitor( this, static_cast< int >( ver ) ); if( ! mon->connect( addr, port ) ) { delete mon; return; } std::cout << "a new (v" << ver << ") monitor connected" << std::endl; M_monitors.push_back( mon ); // send server parameter information & current display data to monitor sendInit( *mon ); return; } }
int main() { srand(time(NULL)); std::cout.sync_with_stdio(0); unsigned char myID; hlt::GameMap presentMap; getInit(myID, presentMap); sendInit("C++Bot"); std::set<hlt::Move> moves; while(true) { moves.clear(); getFrame(presentMap); for(unsigned short a = 0; a < presentMap.height; a++) { for(unsigned short b = 0; b < presentMap.width; b++) { if (presentMap.getSite({ b, a }).owner == myID) { bool movedPiece = false; for(int d : CARDINALS) { if(presentMap.getSite({ b, a }, d).owner != myID && presentMap.getSite({ b, a }, d).strength < presentMap.getSite({ b, a }).strength) { moves.insert({ { b, a }, d }); movedPiece = true; break; } } if(!movedPiece && presentMap.getSite({ b, a }).strength < presentMap.getSite({ b, a }).production * 5) { moves.insert({ { b, a }, STILL }); movedPiece = true; } if(!movedPiece) { moves.insert({ { b, a }, (bool)(rand() % 2) ? NORTH : WEST }); movedPiece = true; } } } } sendFrame(moves); } return 0; }
void Client::step(float dtime) { DSTACK(FUNCTION_NAME); // Limit a bit if(dtime > 2.0) dtime = 2.0; if(m_ignore_damage_timer > dtime) m_ignore_damage_timer -= dtime; else m_ignore_damage_timer = 0.0; m_animation_time += dtime; if(m_animation_time > 60.0) m_animation_time -= 60.0; m_time_of_day_update_timer += dtime; ReceiveAll(); /* Packet counter */ { float &counter = m_packetcounter_timer; counter -= dtime; if(counter <= 0.0) { counter = 20.0; infostream << "Client packetcounter (" << m_packetcounter_timer << "):"<<std::endl; m_packetcounter.print(infostream); m_packetcounter.clear(); } } // UGLY hack to fix 2 second startup delay caused by non existent // server client startup synchronization in local server or singleplayer mode static bool initial_step = true; if (initial_step) { initial_step = false; } else if(m_state == LC_Created) { float &counter = m_connection_reinit_timer; counter -= dtime; if(counter <= 0.0) { counter = 2.0; Player *myplayer = m_env.getLocalPlayer(); FATAL_ERROR_IF(myplayer == NULL, "Local player not found in environment."); // Send TOSERVER_INIT_LEGACY // [0] u16 TOSERVER_INIT_LEGACY // [2] u8 SER_FMT_VER_HIGHEST_READ // [3] u8[20] player_name // [23] u8[28] password (new in some version) // [51] u16 minimum supported network protocol version (added sometime) // [53] u16 maximum supported network protocol version (added later than the previous one) char pName[PLAYERNAME_SIZE]; char pPassword[PASSWORD_SIZE]; memset(pName, 0, PLAYERNAME_SIZE * sizeof(char)); memset(pPassword, 0, PASSWORD_SIZE * sizeof(char)); std::string hashed_password = translatePassword(myplayer->getName(), m_password); snprintf(pName, PLAYERNAME_SIZE, "%s", myplayer->getName()); snprintf(pPassword, PASSWORD_SIZE, "%s", hashed_password.c_str()); sendLegacyInit(pName, pPassword); if (LATEST_PROTOCOL_VERSION >= 25) sendInit(myplayer->getName()); } // Not connected, return return; } /* Do stuff if connected */ /* Run Map's timers and unload unused data */ const float map_timer_and_unload_dtime = 5.25; if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime)) { ScopeProfiler sp(g_profiler, "Client: map timer and unload"); std::vector<v3s16> deleted_blocks; m_env.getMap().timerUpdate(map_timer_and_unload_dtime, g_settings->getFloat("client_unload_unused_data_timeout"), g_settings->getS32("client_mapblock_limit"), &deleted_blocks); /* Send info to server NOTE: This loop is intentionally iterated the way it is. */ std::vector<v3s16>::iterator i = deleted_blocks.begin(); std::vector<v3s16> sendlist; for(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) { if(sendlist.empty()) break; /* [0] u16 command [2] u8 count [3] v3s16 pos_0 [3+6] v3s16 pos_1 ... */ sendDeletedBlocks(sendlist); if(i == deleted_blocks.end()) break; sendlist.clear(); } sendlist.push_back(*i); ++i; } } /* Handle environment */ // Control local player (0ms) LocalPlayer *player = m_env.getLocalPlayer(); assert(player != NULL); player->applyControl(dtime); // Step environment m_env.step(dtime); /* Get events */ for(;;) { ClientEnvEvent event = m_env.getClientEvent(); if(event.type == CEE_NONE) { break; } else if(event.type == CEE_PLAYER_DAMAGE) { if(m_ignore_damage_timer <= 0) { u8 damage = event.player_damage.amount; if(event.player_damage.send_to_server) sendDamage(damage); // Add to ClientEvent queue ClientEvent event; event.type = CE_PLAYER_DAMAGE; event.player_damage.amount = damage; m_client_event_queue.push(event); } } else if(event.type == CEE_PLAYER_BREATH) { u16 breath = event.player_breath.amount; sendBreath(breath); } } /* Print some info */ float &counter = m_avg_rtt_timer; counter += dtime; if(counter >= 10) { counter = 0.0; // connectedAndInitialized() is true, peer exists. float avg_rtt = getRTT(); infostream << "Client: avg_rtt=" << avg_rtt << std::endl; } /* Send player position to server */ { float &counter = m_playerpos_send_timer; counter += dtime; if((m_state == LC_Ready) && (counter >= m_recommended_send_interval)) { counter = 0.0; sendPlayerPos(); } } /* Replace updated meshes */ { int num_processed_meshes = 0; while (!m_mesh_update_thread.m_queue_out.empty()) { num_processed_meshes++; MinimapMapblock *minimap_mapblock = NULL; bool do_mapper_update = true; MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_frontNoEx(); MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p); if (block) { // Delete the old mesh if (block->mesh != NULL) { delete block->mesh; block->mesh = NULL; } if (r.mesh) { minimap_mapblock = r.mesh->moveMinimapMapblock(); if (minimap_mapblock == NULL) do_mapper_update = false; } if (r.mesh && r.mesh->getMesh()->getMeshBufferCount() == 0) { delete r.mesh; } else { // Replace with the new mesh block->mesh = r.mesh; } } else { delete r.mesh; } if (do_mapper_update) m_mapper->addBlock(r.p, minimap_mapblock); if (r.ack_block_to_server) { /* Acknowledge block [0] u8 count [1] v3s16 pos_0 */ sendGotBlocks(r.p); } } if (num_processed_meshes > 0) g_profiler->graphAdd("num_processed_meshes", num_processed_meshes); } /* Load fetched media */ if (m_media_downloader && m_media_downloader->isStarted()) { m_media_downloader->step(this); if (m_media_downloader->isDone()) { received_media(); delete m_media_downloader; m_media_downloader = NULL; } } /* If the server didn't update the inventory in a while, revert the local inventory (so the player notices the lag problem and knows something is wrong). */ if(m_inventory_from_server) { float interval = 10.0; float count_before = floor(m_inventory_from_server_age / interval); m_inventory_from_server_age += dtime; float count_after = floor(m_inventory_from_server_age / interval); if(count_after != count_before) { // Do this every <interval> seconds after TOCLIENT_INVENTORY // Reset the locally changed inventory to the authoritative inventory Player *player = m_env.getLocalPlayer(); player->inventory = *m_inventory_from_server; m_inventory_updated = true; } } /* Update positions of sounds attached to objects */ { for(std::map<int, u16>::iterator i = m_sounds_to_objects.begin(); i != m_sounds_to_objects.end(); ++i) { int client_id = i->first; u16 object_id = i->second; ClientActiveObject *cao = m_env.getActiveObject(object_id); if(!cao) continue; v3f pos = cao->getPosition(); m_sound->updateSoundPosition(client_id, pos); } } /* Handle removed remotely initiated sounds */ m_removed_sounds_check_timer += dtime; if(m_removed_sounds_check_timer >= 2.32) { m_removed_sounds_check_timer = 0; // Find removed sounds and clear references to them std::vector<s32> removed_server_ids; for(std::map<s32, int>::iterator i = m_sounds_server_to_client.begin(); i != m_sounds_server_to_client.end();) { s32 server_id = i->first; int client_id = i->second; ++i; if(!m_sound->soundExists(client_id)) { m_sounds_server_to_client.erase(server_id); m_sounds_client_to_server.erase(client_id); m_sounds_to_objects.erase(client_id); removed_server_ids.push_back(server_id); } } // Sync to server if(!removed_server_ids.empty()) { sendRemovedSounds(removed_server_ids); } } // Write server map if (m_localdb && m_localdb_save_interval.step(dtime, m_cache_save_interval)) { m_localdb->endSave(); m_localdb->beginSave(); } }
void Client::step(float dtime) { // Limit a bit if(dtime > 2.0) dtime = 2.0; if(m_ignore_damage_timer > dtime) m_ignore_damage_timer -= dtime; else m_ignore_damage_timer = 0.0; m_animation_time += dtime; if(m_animation_time > 60.0) m_animation_time -= 60.0; m_time_of_day_update_timer += dtime; ReceiveAll(); /* Packet counter */ { float &counter = m_packetcounter_timer; counter -= dtime; if(counter <= 0.0) { counter = 20.0; infostream << "Client packetcounter (" << m_packetcounter_timer << "):"<<std::endl; m_packetcounter.print(infostream); m_packetcounter.clear(); } } // UGLY hack to fix 2 second startup delay caused by non existent // server client startup synchronization in local server or singleplayer mode static bool initial_step = true; if (initial_step) { initial_step = false; } else if(m_state == LC_Created) { float &counter = m_connection_reinit_timer; counter -= dtime; if(counter <= 0.0) { counter = 2.0; LocalPlayer *myplayer = m_env.getLocalPlayer(); FATAL_ERROR_IF(myplayer == NULL, "Local player not found in environment."); sendInit(myplayer->getName()); } // Not connected, return return; } /* Do stuff if connected */ /* Run Map's timers and unload unused data */ const float map_timer_and_unload_dtime = 5.25; if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime)) { ScopeProfiler sp(g_profiler, "Client: map timer and unload"); std::vector<v3s16> deleted_blocks; m_env.getMap().timerUpdate(map_timer_and_unload_dtime, g_settings->getFloat("client_unload_unused_data_timeout"), g_settings->getS32("client_mapblock_limit"), &deleted_blocks); /* Send info to server NOTE: This loop is intentionally iterated the way it is. */ std::vector<v3s16>::iterator i = deleted_blocks.begin(); std::vector<v3s16> sendlist; for(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) { if(sendlist.empty()) break; /* [0] u16 command [2] u8 count [3] v3s16 pos_0 [3+6] v3s16 pos_1 ... */ sendDeletedBlocks(sendlist); if(i == deleted_blocks.end()) break; sendlist.clear(); } sendlist.push_back(*i); ++i; } } /* Send pending messages on out chat queue */ if (!m_out_chat_queue.empty() && canSendChatMessage()) { sendChatMessage(m_out_chat_queue.front()); m_out_chat_queue.pop(); } /* Handle environment */ // Control local player (0ms) LocalPlayer *player = m_env.getLocalPlayer(); assert(player); player->applyControl(dtime, &m_env); // Step environment m_env.step(dtime); m_sound->step(dtime); /* Get events */ while (m_env.hasClientEnvEvents()) { ClientEnvEvent envEvent = m_env.getClientEnvEvent(); if (envEvent.type == CEE_PLAYER_DAMAGE) { if (m_ignore_damage_timer <= 0) { u8 damage = envEvent.player_damage.amount; if (envEvent.player_damage.send_to_server) sendDamage(damage); // Add to ClientEvent queue ClientEvent *event = new ClientEvent(); event->type = CE_PLAYER_DAMAGE; event->player_damage.amount = damage; m_client_event_queue.push(event); } } } /* Print some info */ float &counter = m_avg_rtt_timer; counter += dtime; if(counter >= 10) { counter = 0.0; // connectedAndInitialized() is true, peer exists. float avg_rtt = getRTT(); infostream << "Client: avg_rtt=" << avg_rtt << std::endl; } /* Send player position to server */ { float &counter = m_playerpos_send_timer; counter += dtime; if((m_state == LC_Ready) && (counter >= m_recommended_send_interval)) { counter = 0.0; sendPlayerPos(); } } /* Replace updated meshes */ { int num_processed_meshes = 0; while (!m_mesh_update_thread.m_queue_out.empty()) { num_processed_meshes++; MinimapMapblock *minimap_mapblock = NULL; bool do_mapper_update = true; MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_frontNoEx(); MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p); if (block) { // Delete the old mesh delete block->mesh; block->mesh = nullptr; if (r.mesh) { minimap_mapblock = r.mesh->moveMinimapMapblock(); if (minimap_mapblock == NULL) do_mapper_update = false; bool is_empty = true; for (int l = 0; l < MAX_TILE_LAYERS; l++) if (r.mesh->getMesh(l)->getMeshBufferCount() != 0) is_empty = false; if (is_empty) delete r.mesh; else // Replace with the new mesh block->mesh = r.mesh; } } else { delete r.mesh; } if (m_minimap && do_mapper_update) m_minimap->addBlock(r.p, minimap_mapblock); if (r.ack_block_to_server) { /* Acknowledge block [0] u8 count [1] v3s16 pos_0 */ sendGotBlocks(r.p); } } if (num_processed_meshes > 0) g_profiler->graphAdd("num_processed_meshes", num_processed_meshes); } /* Load fetched media */ if (m_media_downloader && m_media_downloader->isStarted()) { m_media_downloader->step(this); if (m_media_downloader->isDone()) { delete m_media_downloader; m_media_downloader = NULL; } } /* If the server didn't update the inventory in a while, revert the local inventory (so the player notices the lag problem and knows something is wrong). */ if(m_inventory_from_server) { float interval = 10.0; float count_before = floor(m_inventory_from_server_age / interval); m_inventory_from_server_age += dtime; float count_after = floor(m_inventory_from_server_age / interval); if(count_after != count_before) { // Do this every <interval> seconds after TOCLIENT_INVENTORY // Reset the locally changed inventory to the authoritative inventory LocalPlayer *player = m_env.getLocalPlayer(); player->inventory = *m_inventory_from_server; m_inventory_updated = true; } } /* Update positions of sounds attached to objects */ { for (auto &m_sounds_to_object : m_sounds_to_objects) { int client_id = m_sounds_to_object.first; u16 object_id = m_sounds_to_object.second; ClientActiveObject *cao = m_env.getActiveObject(object_id); if (!cao) continue; m_sound->updateSoundPosition(client_id, cao->getPosition()); } } /* Handle removed remotely initiated sounds */ m_removed_sounds_check_timer += dtime; if(m_removed_sounds_check_timer >= 2.32) { m_removed_sounds_check_timer = 0; // Find removed sounds and clear references to them std::vector<s32> removed_server_ids; for (std::unordered_map<s32, int>::iterator i = m_sounds_server_to_client.begin(); i != m_sounds_server_to_client.end();) { s32 server_id = i->first; int client_id = i->second; ++i; if(!m_sound->soundExists(client_id)) { m_sounds_server_to_client.erase(server_id); m_sounds_client_to_server.erase(client_id); m_sounds_to_objects.erase(client_id); removed_server_ids.push_back(server_id); } } // Sync to server if(!removed_server_ids.empty()) { sendRemovedSounds(removed_server_ids); } } m_mod_storage_save_timer -= dtime; if (m_mod_storage_save_timer <= 0.0f) { verbosestream << "Saving registered mod storages." << std::endl; m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval"); for (std::unordered_map<std::string, ModMetadata *>::const_iterator it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) { if (it->second->isModified()) { it->second->save(getModStoragePath()); } } } // Write server map if (m_localdb && m_localdb_save_interval.step(dtime, m_cache_save_interval)) { m_localdb->endSave(); m_localdb->beginSave(); } }
int main(int argc, char **argv) { // parameters that are provided. char *srv = "127.0.0.1"; int port = DEFAULT_PORT; // this data object will be passed to all the callback routines. Initialise it. data_t data; data.handle = -1; data.msg_id = 0; data.latest_msg_id = 0; data.name = NULL; // get the command line options. int c; while ((c = getopt(argc, argv, "p:s:h")) != -1) { switch (c) { case 'p': port = atoi(optarg); assert(port > 0); break; case 's': srv = strdup(optarg); assert(srv != NULL); break; case 'h': printf("usage:\n\nrisp_chat_stream2 [-s server] [-p port] [-h]\n"); exit(1); break; default: fprintf(stderr, "Illegal argument \"%c\"\n", c); return 1; } } // set the signal trap, so we can break out of the loop when user presses Ctrl-C. signal(SIGINT, sig_handler); // get an initialised risp structure. RISP_PTR risp = risp_init(); assert(risp); // add the callback routines for the commands we are going to receive. risp_add_command(risp, CMD_NOP, &cmdNop); risp_add_command(risp, CMD_HELLO_ACK, &cmdHelloAck); risp_add_command(risp, CMD_MSG_ID, &cmdMsgID); risp_add_command(risp, CMD_LATEST_MSG_ID, &cmdLatestMsgID); risp_add_command(risp, CMD_NAME, &cmdName); risp_add_command(risp, CMD_MESSAGE, &cmdMessage); risp_add_invalid(risp, &cmdInvalid); // connect to the remote socket. We will leave it in blocking mode. When we do the recv, we // will specify that the recv operation is non-blocking. assert(srv && port > 0); data.handle = sock_connect(srv, port); if (data.handle <= 0) { printf("Unable to connect to %s:%d\n", srv, port); } else { // now that we are connected, first we need to send the HELLO and NO_FOLLOW commands. // These commands could have been lumped together in a single send, but for the purpose of // demonstrating RISP, this code does each operationg specifically. if (sendInit(data.handle) != 0) { // couldn't send the command, close the handle, and exit. close(data.handle); data.handle = -1; } // setup the initial buffer. Since we dont really know how much data we will receive from // the server, we will grow the buffer as needed. int max = 0; char *buffer = NULL; int used = 0; int goodbye_sent = 0; // if we have sent a GOODBYE, we dont want to // we will loop until the socket is closed. If the user presses Ctrl-C, we will send a // GOODBYE command to the server, which will then close the socket. If the user presses // Ctrl-C more than once, we will not wait for the server, and will close the socket // directly. Every time the user presses Ctrl-C, it should break out of the sleep, so it // should respond pretty quickly. while (data.handle >= 0) { // printf("."); assert(used <= max); if (max-used < CHUNK_SIZE) { max += CHUNK_SIZE; buffer = realloc(buffer, max); assert(buffer); // fprintf(stderr, "Increased Max Buffer to %d\n", max); } // check for data on the socket. We will do the receive in non-blocking mode, so if // there is no data, it will return immediately. If we received no data, we will wait for // 1 second before trying again. If we have waited for 5 seconds, then we need to // send a NOP to keep the connection alive. char *ptr = buffer + used; int avail = max - used; // fprintf(stderr, "About to recv. avail=%d\n", avail); int result = recv(data.handle, ptr, avail, MSG_DONTWAIT); // printf("Recv: result=%d, used=%d, max=%d\n", result, used, max); if (result < 0) { assert(result == -1); if (errno == EWOULDBLOCK || errno == EAGAIN) { // there was no data to read from the socket. // we will now sleep for 1 second. If the user pressed Ctrl-C, then the sleep // function will exit immediately. Only do the sleep if Ctrl-C hasn't been hit. if (_sigtrap == 0) { sleep(1); } } else { fprintf(stderr, "Unexpected result received from socket. errno=%d '%s'\n", errno, strerror(errno)); } } else if (result == 0) { // socket has closed. close(data.handle); data.handle = -1; } else { assert(result > 0); assert(result <= avail); assert(used >= 0); used += result; assert(used <= max); // if we have some data received, then we need to process it. // fprintf(stderr, "Processing: %d\n", used); risp_length_t processed = risp_process(risp, &data, used, buffer); // fprintf(stderr, "Processed: %ld\n", processed); assert(processed >= 0); assert(processed <= used); if (processed < used) { // Our commands have probably been fragmented. // fprintf(stderr, "Fragmented commands: processed=%ld, used=%d, max=%d\n", processed, used, max); fflush(stdout); if (processed > 0) { // we need to remove from the buffer the data that we have processed. // This is a simple approach, but not the most efficient. assert(sizeof(*buffer) == 1); char *ptr = buffer+processed; size_t length = used-processed; assert((processed + length) == used); // fprintf(stderr, "Moving data. length=%ld\n", length); memmove(buffer, ptr, length); used -= processed; assert(used > 0); assert(used < max); // fprintf(stderr, "After move. used=%d, max=%d\n", used, max); } } else { used = 0; } assert(used >= 0 && used <= max); } if (data.handle >= 0) { if (_sigtrap == 1 && goodbye_sent == 0) { fprintf(stderr, "Closing...\n"); // TODO: shouldn't just close the socket. Should instead send GOODBYE command and wait for socket to close. if (sendGoodbye(data.handle) != 0) { close(data.handle); data.handle = -1; } goodbye_sent ++; } else if (_sigtrap > 1) { close(data.handle); data.handle = -1; } } } } // clean up the risp structure. risp_shutdown(risp); risp = NULL; return 0; }
bool OscProxyEventHandler::handle (const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa, osg::Object *, osg::NodeVisitor *) { bool do_send(false); switch(ea.getEventType()) { case osgGA::GUIEventAdapter::FRAME: if (_firstRun) { _firstRun = false; sendInit(ea); do_send = true; } break; case osgGA::GUIEventAdapter::RESIZE: sendInit(ea); do_send = true; break; case osgGA::GUIEventAdapter::SCROLL: _oscStream << osc::BeginMessage("/osgga/mouse/scroll") << ea.getScrollingMotion() << ea.getScrollingDeltaX() << ea.getScrollingDeltaY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PRESSURE: _oscStream << osc::BeginMessage("/osgga/pen/pressure") << ea.getPenPressure() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_ORIENTATION: _oscStream << osc::BeginMessage("/osgga/pen/orientation") << ea.getPenRotation() << ea.getPenTiltX() << ea.getPenTiltY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PROXIMITY_ENTER: _oscStream << osc::BeginMessage("/osgga/pen/proximity/enter") << ea.getTabletPointerType() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PROXIMITY_LEAVE: _oscStream << osc::BeginMessage("/osgga/pen/proximity/leave") << ea.getTabletPointerType() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PUSH: _oscStream << osc::BeginMessage("/osgga/mouse/press") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::RELEASE: _oscStream << osc::BeginMessage("/osgga/mouse/release") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::DOUBLECLICK: _oscStream << osc::BeginMessage("/osgga/mouse/doublepress") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::MOVE: case osgGA::GUIEventAdapter::DRAG: _oscStream << osc::BeginMessage("/osgga/mouse/motion") << ea.getX() << ea.getY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::KEYDOWN: _oscStream << osc::BeginMessage("/osgga/key/press") << ea.getKey() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::KEYUP: _oscStream << osc::BeginMessage("/osgga/key/release") << ea.getKey() << osc::EndMessage; do_send = true; break; default: break; } if (do_send) { OSG_INFO << "OscDevice :: sending event per OSC " << std::endl; _transmitSocket.Send( _oscStream.Data(), _oscStream.Size() ); _oscStream.Clear(); } return false; }
void OscSendingDevice::sendEvent(const osgGA::GUIEventAdapter &ea) { bool do_send(false); switch(ea.getEventType()) { case osgGA::GUIEventAdapter::RESIZE: sendInit(ea); do_send = true; break; case osgGA::GUIEventAdapter::SCROLL: _oscStream << osc::BeginMessage("/osgga/mouse/scroll") << ea.getScrollingMotion() << ea.getScrollingDeltaX() << ea.getScrollingDeltaY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PRESSURE: _oscStream << osc::BeginMessage("/osgga/pen/pressure") << ea.getPenPressure() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_ORIENTATION: _oscStream << osc::BeginMessage("/osgga/pen/orientation") << ea.getPenRotation() << ea.getPenTiltX() << ea.getPenTiltY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PROXIMITY_ENTER: _oscStream << osc::BeginMessage("/osgga/pen/proximity/enter") << ea.getTabletPointerType() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PEN_PROXIMITY_LEAVE: _oscStream << osc::BeginMessage("/osgga/pen/proximity/leave") << ea.getTabletPointerType() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::PUSH: _oscStream << osc::BeginMessage("/osgga/mouse/press") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::RELEASE: _oscStream << osc::BeginMessage("/osgga/mouse/release") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::DOUBLECLICK: _oscStream << osc::BeginMessage("/osgga/mouse/doublepress") << ea.getX() << ea.getY() << getButtonNum(ea) << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::MOVE: if (_firstRun) { _firstRun = false; sendInit(ea); do_send = true; break; } // break missing by intent; case osgGA::GUIEventAdapter::DRAG: _oscStream << osc::BeginMessage("/osgga/mouse/motion") << ea.getX() << ea.getY() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::KEYDOWN: _oscStream << osc::BeginMessage("/osgga/key/press") << ea.getKey() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::KEYUP: _oscStream << osc::BeginMessage("/osgga/key/release") << ea.getKey() << osc::EndMessage; do_send = true; break; case osgGA::GUIEventAdapter::USER: if (ea.getUserDataContainer()) { std::string key = ea.getUserDataContainer()->getName(); if (key.empty()) key = ea.getName(); if (key.empty()) key = "user_data"; sendUserDataContainer(transliterateKey(key), ea.getUserDataContainer(), true); do_send = true; } default: break; } if (do_send) { OSG_INFO << "OscDevice :: sending event per OSC " << std::endl; _transmitSocket.Send( _oscStream.Data(), _oscStream.Size() ); _oscStream.Clear(); } }
int main(void) { // Alles TriState DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; // save power MCUCR |= _BV(JTD); PRR |= _BV(PRTWI) | _BV(PRSPI) | _BV(PRADC); //ADCSRA &= ~_BV(ADEN); //ACSR |=_BV(ACD); // Power Led DDRA|=_BV(7); PIN_SET(A,7); sei(); // Init: Subsysteme uart_init(UART_BAUD_SELECT(BAUD,F_CPU)); stella_init(); // curtain_init(); //sensors_init(); // Init: Variablen enum stateEnum { StateCommands, StateCurtainValue, StateLedChannel, StateLedValue } laststate, state = StateCommands; uint8_t slowdown_counter = 0; uint8_t slowdown_counter2 = 0; uint8_t panic_counter = 0; uint8_t panic_counter_led = 0; uint8_t panic_counter_brightness = 0; uint8_t stella_channel = 0; enum stella_set_function stella_fading = STELLA_SET_IMMEDIATELY; uint8_t packetPosition = 0; unsigned char lastChar, haslastChar = 0; slowdown_counter = 0; slowdown_counter2 = 0; stella_setValue(STELLA_SET_IMMEDIATELY, 0, 0); stella_process(); wdt_enable(WDTO_250MS); #define PANIC_THRESHOLD 150 // Hauptprogramm while (1) { wdt_reset(); stella_process(); curtain_process(); //sensors_process(); //panic counter if (++slowdown_counter == 0) { if (++slowdown_counter2==0) { if (panic_counter < PANIC_THRESHOLD) ++panic_counter; } if (panic_counter == PANIC_THRESHOLD) { panic_counter = PANIC_THRESHOLD+1; panic_counter_led = 0; panic_counter_brightness = 0; packetPosition = 0; storeValues(); PIN_SET(A,6); } if (panic_counter == PANIC_THRESHOLD+1) { if (panic_counter_brightness==255) { panic_counter=PANIC_THRESHOLD+2; continue; } stella_setValue(STELLA_SET_FADE, panic_counter_led, ++panic_counter_brightness); } if (panic_counter == PANIC_THRESHOLD+2) { if (panic_counter_brightness==0) { panic_counter=PANIC_THRESHOLD+1; if (++panic_counter_led >= STELLA_CHANNELS) panic_counter_led = 0; continue; } stella_setValue(STELLA_SET_FADE, panic_counter_led, --panic_counter_brightness); } } uint16_t r = uart_getc(); uint8_t info = r >> 8; if (r == UART_NO_DATA) continue; else if (info!=0) { PIN_SET(A,6); PIN_SET(A,7); packetPosition = 0; continue; } const unsigned char temp = haslastChar ? lastChar : 0; haslastChar = 1; lastChar = r & 0xff; if (lastChar == 0xff && temp == 0xff) { // two proceeding 255-values start a valid packet packetPosition = 1; state = StateCommands; continue; } if (!packetPosition) continue; // reset panic counter if (panic_counter) { if (panic_counter>=110) { restoreValues(); PIN_CLEAR(A,6); } panic_counter = 0; } laststate = state; switch (state) { case StateCommands: switch (lastChar) { case 0xef: // get values sendInit(); sendStella(); //sendSensor(); sendMotor(); break; case 0xdf: // prepare for a curtain value state = StateCurtainValue; break; case 0xcf: // prepare for a led channel and value (fade:immediately) state = StateLedChannel; stella_fading = STELLA_SET_IMMEDIATELY; break; case 0xbf: // prepare for a led channel and value (fade:fade) state = StateLedChannel; stella_fading = STELLA_SET_FADE; break; case 0xaf: // prepare for a led channel and value (fade:fade flashy) state = StateLedChannel; stella_fading = STELLA_SET_FLASHY; break; case 0x9f: // prepare for a led channel and value (fade:fade immediately+relative) state = StateLedChannel; stella_fading = STELLA_SET_IMMEDIATELY_RELATIVE; break; case 0x00: // reset panic counter and acknowdlegde sendAck(); break; } break; case StateCurtainValue: state = StateCommands; curtain_setPosition(lastChar); break; case StateLedChannel: state = StateLedValue; stella_channel = lastChar; break; case StateLedValue: state = StateCommands; stella_setValue(stella_fading, stella_channel, lastChar); break; } // the state has not changed -> a full packet has been received -> prepare for the next one if (laststate==state) { packetPosition=0; } } return 0; }
// // Core Functions // int P2OSPtz::setup() { int err = 0; int num_inits = 7; is_on_ = true; for (int i = 1; i < num_inits; i++) { switch(i) { // case 0: // do // { // ROS_DEBUG("Waiting for camera to power off."); // err = setPower(POWER_OFF); // } while (error_code_ == CAM_ERROR_BUSY); // break; case 1: do { ROS_DEBUG("Waiting for camera to power on."); err = setPower(POWER_ON); } while (error_code_ == CAM_ERROR_BUSY); break; case 2: do { ROS_DEBUG("Waiting for camera mode to set"); err = setControlMode(); } while (error_code_ == CAM_ERROR_BUSY); break; case 3: do { ROS_DEBUG("Waiting for camera to initialize"); err = sendInit(); } while (error_code_ == CAM_ERROR_BUSY); break; case 4: do { for(int i = 0; i < 3; i++) { ROS_DEBUG("Waiting for camera to set default tilt"); err = setDefaultTiltRange(); } } while (error_code_ == CAM_ERROR_BUSY); break; case 5: do { ROS_DEBUG("Waiting for camera to set initial pan and tilt"); err = sendAbsPanTilt(0, 0); } while (error_code_ == CAM_ERROR_BUSY); break; case 6: do { ROS_DEBUG("Waiting for camera to set initial zoom"); err = sendAbsZoom(0); } while (error_code_ == CAM_ERROR_BUSY); break; default: err = -7; break; } // Check for erros after each attempt if (err) { ROS_ERROR("Error initiliazing PTZ at stage %i", i); switch(error_code_) { case CAM_ERROR_BUSY: ROS_ERROR("Error: CAM_ERROR_BUSY"); break; case CAM_ERROR_PARAM: ROS_ERROR("Error: CAM_ERROR_PARAM"); break; case CAM_ERROR_MODE: ROS_ERROR("Error: CAM_ERROR_MODE"); break; default: ROS_ERROR("Error: Unknown error response from camera."); break; } return(-1); } else { ROS_DEBUG("Passed stage %i of PTZ initialization.", i); } } ROS_DEBUG("Finished initialization of the PTZ."); return 0; }