Colony » Colony Scout » Colony Scout OS

      , start_y(pos.y)

      , orient(orient)

      , name(scoutname)

  {

    scout = wxBitmap(scout_image);

  void GhostScout::paint(wxDC& dc)

  {

    wxSize scout_size = wxSize(scout.GetWidth(), scout.GetHeight());

    dc.DrawBitmap(scout, pos.x * PIX_PER_METER - (scout_size.GetWidth() / 2),

        pos.y * PIX_PER_METER - (scout_size.GetHeight() / 2), true);

  }

}

      void paint(wxDC& dc);

      void setPosition(const ::messages::ScoutPosition& msg);

    private:

      unsigned int rgb_to_grey(unsigned char r,

      ros::Subscriber position;

  };

}

                 wxBitmap *path_bitmap,

                 float orient)

        : path_bitmap(path_bitmap)

          , scout_image(scout_image)

          , pos(pos)

          , orient(orient)

            }

            sonar_dc.SetBrush(*wxGREEN_BRUSH);  //newest value

            {

                isFront = FALSE;

            }

            {

                isFront = TRUE; 

            }

        }

        return d;

        last_sonar_time = ros::Time::now();

        unsigned int d_front = trace_sonar(walls_image, x, y, robot_theta,

        unsigned int d_back = trace_sonar(walls_image, x, y, robot_theta,

        // Publish

        sonar::sonar_distance msg;

    /// TODO remove dt param

    geometry_msgs::Pose2D Scout::update(double dt, wxMemoryDC& path_dc,

                                        wxMemoryDC& sonar_dc,

                                        const wxImage& path_image,

                                        const wxImage& lines_image,

                                        const wxImage& walls_image,

                                        wxColour sonar_color,

                                        world_state state)

    {

        // Assume that the two motors on the same side will be set to

        // roughly the same speed. Does not account for slip conditions

        // when they are set to different speeds.

                         p.theta,sonar_dc);

        }

        // Figure out (and publish) the color underneath the scout

        {

            //wxSize scout_size = wxSize(scout.GetWidth(), scout.GetHeight());

        dc.DrawBitmap(scout, pos.x * PIX_PER_METER - (scout_size.GetWidth() / 2),

                      pos.y * PIX_PER_METER - (scout_size.GetHeight() / 2), true);

    }

}

                  const Vector2& pos, wxBitmap *path_bitmap, float orient);

            geometry_msgs::Pose2D update(double dt, wxMemoryDC& path_dc,

                                         const wxImage& path_image,

                                         const wxImage& lines_image,

                                         const wxImage& walls_image,

                                         wxColour background_color,

                                         world_state state);

            void paint(wxDC& dc);

        private:

            float absolute_to_mps(int absolute_speed);

    EVT_MENU(ID_TELEOP_NONE, scoutsim::SimFrame::stopTeleop)

    EVT_MENU(ID_TELEOP_PRECISE, scoutsim::SimFrame::startTeleopPrecise)

    EVT_MENU(ID_TELEOP_FLUID, scoutsim::SimFrame::startTeleopFluid)

END_EVENT_TABLE()

DECLARE_APP(ScoutApp);

        wxBitmap lines_bitmap;

        wxBitmap walls_bitmap;

        path_bitmap.LoadFile(wxString::FromAscii(display_map_name.c_str()));

        // Try to load the file; if it fails, make a new blank file

        if (!lines_bitmap.LoadFile(wxString::FromAscii(map_lines_name.c_str())))

        spawn_srv = nh.advertiseService("spawn",

                                        &SimFrame::spawnCallback, this);

        kill_srv = nh.advertiseService("kill",

        // Subscribe and publisher wirless from robots

        wireless_receive = nh.advertise< ::messages::WirelessPacket>(

            &SimFrame::wirelessCallback, this);

        // Teleop

        teleop_l_speed = 0;

        teleop_r_speed = 0;

        teleop_pub = nh.advertise<motors::set_motors>("/scout1/set_motors", 1000);

        menuFile->Append(ID_QUIT, _("E&xit"));

        wxMenu *menuSim = new wxMenu;

        menuSim->Append(ID_CLEAR, _("&Clear"));

        wxMenu *menuView = new wxMenu;

        menuTeleop->Append(ID_TELEOP_PRECISE, _("&Precise"));

        menuTeleop->Append(ID_TELEOP_FLUID, _("&Fluid"));

        wxMenuBar *menuBar = new wxMenuBar;

        menuBar->Append(menuFile, _("&File"));

        menuBar->Append(menuSim, _("&Sim"));

        menuBar->Append(menuView, _("&View"));

        menuBar->Append(menuTeleop, _("&Teleop"));

        SetMenuBar(menuBar);

        std::string name = spawnScout(req.name, req.x, req.y, req.theta);

        if (name.empty())

        {

            return false;

        }

        res.name = name;

        return true;

    }

        M_Scout::iterator it = scouts.find(req.name);

        if (it == scouts.end())

        {

            return false;

        }

        return true;

    }

    bool SimFrame::hasScout(const std::string& name)

    {

        return scouts.find(name) != scouts.end();

        std::string real_name = name;

        if (real_name.empty())

        {

            do

            {

                std::stringstream ss;

                ss << "scout" << ++id_counter;

                real_name = ss.str();

        }

        else

        {

        clear();

    }

    void SimFrame::showMap(wxCommandEvent& WXUNUSED(event))

    {

        display_map_name = map_base_name;

        {

            it->second->paint(dc);

        }

        {

            ghost_scouts.at(i)->paint(dc);

        }

        }

        else if (wxGetKeyState(WXK_LEFT))

        {

        }

        else if (wxGetKeyState(WXK_RIGHT))

        {

        }

    }

        for (; it != end; ++it)

        {

            it->second->update(SIM_TIME_REFRESH_RATE,

                               path_image, lines_image, walls_image,

                               path_dc.GetBackground().GetColour(),

                               sonar_dc.GetBackground().GetColour(),

                               state);

        }

        {

            ghost_scouts.at(i)->update(SIM_TIME_REFRESH_RATE, path_dc, sonar_dc,

                path_dc.GetBackground().GetColour(), state);

#include <std_srvs/Empty.h>

#include <scoutsim/Spawn.h>

#include <scoutsim/Kill.h>

#include <motors/set_motors.h>

#include <map>

#define ID_TELEOP_NONE 7

#define ID_TELEOP_PRECISE 8

#define ID_TELEOP_FLUID 9

// Absolute speeds (-128 - 127)

#define TELEOP_FLUID_MAX_SPEED 100

#define TELEOP_FLUID_INC 8

            void stopTeleop(wxCommandEvent& event);

            void startTeleopPrecise(wxCommandEvent& event);

            void startTeleopFluid(wxCommandEvent& event);

            DECLARE_EVENT_TABLE()

            bool spawnCallback(Spawn::Request&, Spawn::Response&);

            bool killCallback(Kill::Request&, Kill::Response&);

            void wirelessCallback(const messages::WirelessPacket::ConstPtr& msg);

            ros::Subscriber wireless_send;

            ros::ServiceServer reset_srv;

            ros::ServiceServer spawn_srv;

            ros::ServiceServer kill_srv;

            typedef std::map<std::string, ScoutPtr> M_Scout;

            M_Scout scouts;

            float width_in_meters;

            float height_in_meters;

            std::string map_base_name;

            std::string map_lines_name;

            std::string map_walls_name;

float32 theta

string name # Optional.  A unique name will be created and returned if this is empty

---