Scribd Logo
Upload

Welcome to Scribd!

  • 101 views

    C++ Crash Course For ROS

    Uploaded by

    zakizadeh
    This document provides a crash course on C++ and building C++ packages in ROS. It begins with an overview of C++ concepts like classes, vectors, namespaces, pointers, references and more. It then demonstrates how to create a ROS package in C++ called cpp_tutorial that subscribes to random number messages and prints them out. It walks through creating the package, editing code to subscribe and print messages, building the package, and iterating on the code to compute an average of the random numbers.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd

    C++ Crash Course For ROS

    Uploaded by

    zakizadeh
    101 views25 pages
    This document provides a crash course on C++ and building C++ packages in ROS. It begins with an overview of C++ concepts like classes, vectors, namespaces, pointers, references and more. It then demonstrates how to create a ROS package in C++ called cpp_tutorial that subscribes to random number messages and prints them out. It walks through creating the package, editing code to subscribe and print messages, building the package, and iterating on the code to compute an average of the random numbers.

    Original Description:

    C++ crash course for ROS

    Original Title

    C++ crash course for ROS

    Copyright

    © © All Rights Reserved

    Available Formats

    PPTX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document provides a crash course on C++ and building C++ packages in ROS. It begins with an overview of C++ concepts like classes, vectors, namespaces, pointers, references and more. It then demonstrates how to create a ROS package in C++ called cpp_tutorial that subscribes to random number messages and prints them out. It walks through creating the package, editing code to subscribe and print messages, building the package, and iterating on the code to compute an average of the random numbers.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd
    Download as pptx, pdf, or txt
    101 views25 pages

    C++ Crash Course For ROS

    Uploaded by

    zakizadeh
    This document provides a crash course on C++ and building C++ packages in ROS. It begins with an overview of C++ concepts like classes, vectors, namespaces, pointers, references and more. It then demonstrates how to create a ROS package in C++ called cpp_tutorial that subscribes to random number messages and prints them out. It walks through creating the package, editing code to subscribe and print messages, building the package, and iterating on the code to compute an average of the random numbers.

    Copyright:

    © All Rights Reserved
    Download as PPTX, PDF, TXT or read online from Scribd
    Download as pptx, pdf, or txt
    of 25

    C++ crash course

    Justin Huang
    Jan 12, 2015
    Why C++?
    Fast
    Compile-time checks
    Slight improvement over C
    Widely used

    Why not?
    Complicated
    Slow compilation
    Hello, world
    # include < iostream > public class M ain {
    public static void m ain(String[] args) {
    int m ain(int argc, char** argv) { System .out.println("H ello, w orld!");
    std::cout < < "H ello, w orld!" < < std::endl; }
    return 0; }
    }
    Classes (Java)
    public class Robot { Robot r = new Robot("Rosie");
    private String nam e;

    public Robot(String nam e) {


    this.nam e = nam e;
    }

    public void sayN am e() {


    System .out.println(nam e);
    }
    }
    Classes (C++)
    // robot.h // robot.cpp
    # ifndef RO BO T_H _ # include < iostream >
    # define RO BO T_H _ # include < string>
    # include < string> # include "robot.h"

    class Robot { Robot::Robot(): nam e_("") {


    private: }
    std::string nam e_; Robot::Robot(const std::string& nam e):
    public: nam e_(nam e) {
    Robot(); }
    Robot(const std::string& nam e);
    void SayN am e() const; void Robot::SayN am e() const {
    }; std::cout < < nam e_ < < std::endl;
    # endif }
    Classes (C++)
    // m ain.cpp

    # include < iostream >


    # include "robot.h"

    int m ain() {
    Robot r("Rosie");
    r.SayN am e();
    Robot r2;
    r2.SayN am e();
    Robot* r3 = new Robot("Rosie");
    r3-> SayN am e();
    return 0;
    }
    Vectors
    # include < iostream > for(const Robot& robot : robots) {
    # include < vector> robot.SayN am e();
    # include "robot.h" }

    int m ain() { std::cout < < "There are " < < robots.size()
    Robot r("Rosie"); < < " robots" < < std::endl;
    Robot r2("M osie"); Robot rosie = robots[0];
    return 0;
    std::vector< Robot> robots; }
    robots.push_back(r);
    robots.push_back(*r2);

    Continued
    Hash tables
    # include < iostream > robots["Rosie"].SayN am e();
    # include < unordered_m ap> return 0;
    }
    int m ain() {
    Robot r("Rosie");
    Robot r2("M osie");

    std::unordered_m ap< std::string, Robot>


    robots;
    robots["Rosie"] = r;
    robots["M osie"] = r2;

    Continued
    Namespaces
    // robot.h // m ain.cpp
    # ifndef RO BO T_H _
    # define RO BO T_H _ nam espace m yproject {
    void inside() {
    nam espace m yproject { Robot r;
    class Robot { r.SayN am e();
    ... }
    }; };
    };
    int m ain() {
    # endif m yproject::Robot r;
    r.SayN am e();
    m yproject::inside();
    }
    using-directive
    # include < iostream > # include < iostream >
    # include < string> # include < string>

    using std::string; using nam espace std;

    int m ain() { int m ain() {


    string nam e = "Rosie"; string nam e = "Rosie";
    std::cout < < nam e < < std::endl; cout < < nam e < < endl;
    return 0; return 0;
    } }
    Transitivity of inclusion
    // robot.h // m ain.cpp
    # ifndef RO BO T_H _
    # define RO BO T_H _ # include "robot.h"

    # include < iostream > int m ain() {


    using nam espace std; cout < < "H ello w orld" < < endl;
    }
    # endif
    Pointers
    Code,
    0x00000000
    int test = 5555; data,
    Robot* r = new Robot("Rosie"); BSS
    0x0000001
    cout < < & test < < endl;
    cout < < r < < endl; Heap
    0x00001234 Robot {
    name = "Rosie"
    Robot r; // A Robot object }
    Robot* pr; // A pointer to a robot

    &r; // The address of r


    pr = r; // pr points ro r
    *pr; // A Robot, r
    0xfffffffe
    pr->SayName();
    (*pr).SayName(); 0xffffffff Stack
    Pass by reference
    void D oSom ething( Robot robot1("M osie");
    Robot& ref, Robot robot2("M osie");
    Robot value, Robot robot3("M osie");
    Robot* pointer
    ){ D oSom ething(robot1, robot2, robot3);
    ref.nam e = "Rosie"; robot1.nam e = = "Rosie";
    value.nam e = "Rosie"; robot2.nam e = = "M osie";
    pointer-> nam e = "Rosie"; robot3.nam e = = "Rosie";
    }
    Function convention
    void D oSom ething( Inputs first, then outputs.
    const Robot& input1, Inputs are const references except for
    const int input2,
    Robot* output1,
    primitive types.
    int* output2 Outputs are pointers.
    ){ Function return type is void.
    output1-> nam e = input1.nam e;
    *output2 = input2;
    } Robot r("M osie");
    int num 1 = 1;
    Robot r2;
    int num 2;

    D oSom ething(r, num 1, & r2, & num 2);


    Further reading
    C++ tutorial
    Learn C the Hard Way
    ROS C++ style guide
    Google C++ style guide
    Building a C++ package in
    ROS
    Setup for tutorial
    ssh hcrlab@ w alle.cs.w ashington.edu
    m kdir {U W N etID }
    cd {U W N etID }
    m kdir -p catkin_w s/src
    cd catkin_w s
    catkin_m ake
    source devel/setup.bash
    cd src
    Create the package
    catkin_create_pkg cpp_tutorialroscpp std_m sgs
    cd cpp_tutorial
    ls
    Look at random numbers
    rostopic info random_numbers
    rosmsg show std_msgs/Float64
    rostopic echo random_numbers
    Get the sample code
    Sample code is from the ROS tutorial,
    Writing a simple publisher and subscriber (C++)

    cp ~/samples/subscriber.cpp src
    vim src/subscriber.cpp
    Or nano src/subscriber.cpp
    Or emacs src/subscriber.cpp
    Tasks
    1. Change the node's name to be your UW NetID
    2. Subscribe to "random_numbers" instead of "chatter"
    3. Add #include "std_msgs/Float64.h"
    4. Change chatterCallback to be:
    void chatterCallback(const std_m sgs::Float64& m sg)
    5. Change ROS_INFO to say:
    RO S_IN FO ("Iheard: % f", m sg.data);
    CMakeLists.txt
    vim/nano/emacs CMakeLists.txt
    Go to near the bottom, where it says
    ###########
    # # BU ILD # #
    ###########

    Uncomment include_directories(...), add_executable(...),


    and target_link_libraries(...)

    Change src/cpp_tutorial_node.cpp to src/subscriber.cpp


    Build
    cd ../.. # You should be in ~/uwnetid/catkin_ws
    catkin_make
    rosrun cpp_tutorial cpp_tutorial_node
    Iterate
    Now go back and compute the average of the
    random numbers.

    You will need global variables to keep track of


    the average -- yuck!
    Further reading
    PCL Sample: a basic example of a C++ class,
    used to process the average point in a point
    cloud
    ROS tutorials (C++)
    ROS C++ Overview
    ROS C++ Code API (Hydro)

    You might also like