diff --git a/wiki/faq.md b/wiki/faq.md
index 77b57240b859c6bd33b458ed5ac488c355df66d6..56da5fbf210369414c371478291df98119ab602d 100644
--- a/wiki/faq.md
+++ b/wiki/faq.md
@@ -107,7 +107,7 @@ This section contains those Frequently Asked Questions that pertain to common co
 The per motor command that your algorithm requests from the Crazyflie via setting the ``response.controlOutput.motorCmd1`` property in the function ``calculateControlOutput`` is subseuently cast as a ``uint16`` type variable. Hence you should consider saturating the per motor commands computed by your algorithm before setting the value of ``response.controlOutput.motorCmd1``.
 
 
-### Why does my crazyflie stop and ``Stuent GUI`` freeze when I enable my custom controller?
+### Why does my crazyflie stop and ``Stuent GUI`` freeze when I enable my student controller?
 
 This is most likely caused by your code causing a segmentation fault, which is commonly caused due to a division by zero. This is often observed in relation to the calculation of sampling time from frequency. You need to think carefully about the order in which variables are instantiated, set to a value, and subsequently used in your code. Specifically, in the template controller code provided contains the ``control_frequency`` variable that is set to a value loaded from the ``.yaml`` parameter file. It is common to instantiate a new variable as ``t_s = 1.0 / control_frequency``. However, if the ``t_s`` variable is accidentally used before it is set to this value then it is possible that you are dividing by zero. Remember also that the values from the ``.yaml`` parameter file are loaded during runtime, as they can be changed at any time during the running of the application, so those values are not present during compile time of your code.
 
@@ -119,12 +119,12 @@ In order to make information available between the laptops, you can use the publ
 In order to publish the position of your Crazyflie you need to introduce a variable of type ``ros::Publisher`` and you can use the ``Setpoint`` message type to publish the x,y,z, and yaw of your Crazyflie.
 
 To add a publisher follow these steps:
-- Add a ``ros::Publisher`` type class variable to your ``CustomControllerService.cpp`` file:
+- Add a ``ros::Publisher`` type class variable to your ``StudentControllerService.cpp`` file:
 ```
 ros::Publisher my_current_xyz_yaw_publisher
 ```
 
-- In the ``main()`` function of your ``CustomControllerService.cpp`` file initialise your publisher:
+- In the ``main()`` function of your ``StudentControllerService.cpp`` file initialise your publisher:
 ```
 ros::NodeHandle nodeHandle("~");
 my_current_xyz_yaw_publisher = nodeHandle.advertise<Setpoint>("/<ID>/my_current_xyz_yaw_topic", 1);
@@ -133,9 +133,9 @@ where ``<ID>`` should be replaced by the ID of your computer, for example the nu
 ```
 #include "d_fall_pps/Setpoint.h"
 ```
-added at the top of  your ``CustomControllerService.cpp`` file.
+added at the top of  your ``StudentControllerService.cpp`` file.
 
-- In the ``calculateControlOutput`` function of your ``CustomControllerService.cpp`` file you can publish the current position of your Crazyflie by adding the following:
+- In the ``calculateControlOutput`` function of your ``StudentControllerService.cpp`` file you can publish the current position of your Crazyflie by adding the following:
 ```
 Setpoint temp_current_xyz_yaw;
 temp_current_xyz_yaw.x   = request.ownCrazyflie.x;
@@ -148,19 +148,19 @@ my_current_xyz_yaw_publisher.publish(temp_current_xyz_yaw);
 In order to subscribe to a message that is published in the way described above from another student's laptop, you need to define a variable of type ``ros::Subscriber`` and you specify the function that should be called each time a message is receive on the topic to which you subscribe.
 
 To subscribe to a topic follw these steps:
-- In the ``main()`` function of your ``CustomControllerService.cpp`` file initialise the subscriber:
+- In the ``main()`` function of your ``StudentControllerService.cpp`` file initialise the subscriber:
 ```
 ros::NodeHandle nodeHandle("~");
 ros::Subscriber xyz_yaw_to_follow_subscriber = nodeHandle.subscribe("/<ID>/my_current_xyz_yaw_topic", 1, xyz_yaw_to_follow_callback);
 ```
-where ``<ID>`` should be replaced by the ID of the computer from which you wish to subscribe, for example the number 8, ``my_current_xyz_yaw_topic`` must match the name of the topic being published, and ``xyz_yaw_to_follow_callback`` is the function in your ``CustomControllerService.cpp`` file that will be called when the message is received.
+where ``<ID>`` should be replaced by the ID of the computer from which you wish to subscribe, for example the number 8, ``my_current_xyz_yaw_topic`` must match the name of the topic being published, and ``xyz_yaw_to_follow_callback`` is the function in your ``StudentControllerService.cpp`` file that will be called when the message is received.
 
-- To add the callback function, first add the following function prototype to the top of your ``CustomControllerService.cpp`` file:
+- To add the callback function, first add the following function prototype to the top of your ``StudentControllerService.cpp`` file:
 ```
 void xyz_yaw_to_follow_callback(const Setpoint& newSetpoint);
 ```
 
-- Implement the ``xyz_yaw_to_follow_callback`` function in your ``CustomControllerService.cpp`` file to achieve the behaviour desired, the following example makes the setpoint of my own Crazyflie equal to the position received in the message:
+- Implement the ``xyz_yaw_to_follow_callback`` function in your ``StudentControllerService.cpp`` file to achieve the behaviour desired, the following example makes the setpoint of my own Crazyflie equal to the position received in the message:
 ```
 void xyz_yaw_to_follow_callback(const Setpoint& newSetpoint)
 {
@@ -175,9 +175,9 @@ void xyz_yaw_to_follow_callback(const Setpoint& newSetpoint)
 
 ### How can my controller receive the position of another object recognised by the Vicon system?
 
-The ``calculateControlOutput`` function of your ``CustomControllerService.cpp`` file is called everytime that the Vicon system provides new data, where this data is provided to the ``calculateControlOutput`` function in the ``request`` variable and the calculated control output to apply is returned in the ``response`` variable. In this way the ``calculateControlOutput`` function is performing in ROS what is referred to as a service. This service is advertised in the ``main()`` function of your ``CustomControllerService.cpp`` file by the line of code:
+The ``calculateControlOutput`` function of your ``StudentControllerService.cpp`` file is called everytime that the Vicon system provides new data, where this data is provided to the ``calculateControlOutput`` function in the ``request`` variable and the calculated control output to apply is returned in the ``response`` variable. In this way the ``calculateControlOutput`` function is performing in ROS what is referred to as a service. This service is advertised in the ``main()`` function of your ``StudentControllerService.cpp`` file by the line of code:
 ```
-ros::ServiceServer service = nodeHandle.advertiseService("CustomController", calculateControlOutput);
+ros::ServiceServer service = nodeHandle.advertiseService("StudentController", calculateControlOutput);
 ```
 This service is called on from the ``PPSClient.cpp`` file, and it is expected to adhere to the data structures described in ``/srv/Controller.srv``:
 ```
@@ -225,7 +225,7 @@ for(std::vector<CrazyflieData>::const_iterator it = viconData.crazyflies.begin()
 
 		if ( thisObject.crazyflieName == "name_of_object_I_am_searching_for" )
 		{
-				otherObject = thisCrazyflie;
+				otherObject = thisObject;
 				break;
 		}
 }
@@ -246,7 +246,7 @@ and immediately after these existing lines of code, add the following new lines
 coordinatesToLocal(otherObject);
 controllerCall.request.otherCrazyflies.push_back(otherObject);
 ```
-Now the ``.otherCrazyflies`` property of the ``request`` variable that is passed to the ``calculateControlOutput`` function of your ``CustomControllerService.cpp`` file will contain the position of the ``otherObject`` as the first entry in the array, i.e., you can access the data via ``request.otherCrazyflies[0].{x,y,z,roll,pitch,yaw}``.
+Now the ``.otherCrazyflies`` property of the ``request`` variable that is passed to the ``calculateControlOutput`` function of your ``StudentControllerService.cpp`` file will contain the position of the ``otherObject`` as the first entry in the array, i.e., you can access the data via ``request.otherCrazyflies[0].{x,y,z,roll,pitch,yaw}``.
 
 
 
@@ -297,31 +297,10 @@ where ``/namespace/topicname`` needs to be replaced with the topic that you wish
 
 ## Connect to custom buttons
 
-The Graphical User Interface for flying your Crazyflie offers three buttons that can be used to trigger functions within your ``CustomControllerService.cpp`` file. In order to connect the button with a function within your controller, perform the following steps.
-
-Add the following include:
-```
-#include "d_fall_pps/CustomButton.h"
-```
-
-Add the following function prototype:
-```
-// CUSTOM COMMAND RECEIVED CALLBACK
-void customCommandReceivedCallback(const CustomButton& commandReceived);
-
-```
-
-Add the following subscriber within the ``main`` function and before the ``ros::spin();`` command:
-```
-// Instantiate the local variable "customCommandSubscriber" to be a "ros::Subscriber"
-// type variable that subscribes to the "StudentCustomButton" topic and calls the class
-// function "customCommandReceivedCallback" each time a messaged is received on this topic
-// and the message received is passed as an input argument to the callback function.
-ros::Subscriber customCommandReceivedSubscriber = PPSClient_nodeHandle.subscribe("StudentCustomButton", 1, customCommandReceivedCallback);
-```
+The Graphical User Interface for flying your Crazyflie offers three buttons that can be used to trigger functions within your ``StudentControllerService.cpp`` file. The buttons are already connected to your code and you can respond to button presses by locating the following function within your
 
+``StudentControllerService.cpp`` file:
 
-Add the following function somewhere within your ``CustomControllerService.cpp`` file:
 ```
 //    ----------------------------------------------------------------------------------
 //     CCCC  U   U   SSSS  TTTTT   OOO   M   M
diff --git a/wiki/workflow_for_students.md b/wiki/workflow_for_students.md
index a8db98aabc03ebae742c92031a6e0c28a707fd27..114c154de9184293c9fc43ff88bbbc51911f01ea 100644
--- a/wiki/workflow_for_students.md
+++ b/wiki/workflow_for_students.md
@@ -49,7 +49,7 @@ gyrosensor needs to initialize.
   Crazyflie, and a text label containing the current flying state. **It is
   important to know that we can only take off when we are in the state "Motors
   OFF", and we can only land if we are NOT in the state "Motors OFF"**<br><br>
-    * In the middle-bottom part of the GUI there are two tabs: Safe and Custom
+    * In the middle-bottom part of the GUI there are two tabs: Safe and Student
   controller. <br><br>
   In the left part of these tabs, there is information about the
   current position of the Crazyflie, and also the difference between the current
@@ -72,10 +72,10 @@ gyrosensor needs to initialize.
     `SafeController.yaml`, in the folder param (use `roscd d_fall_pps/param` in a
     terminal to go there).* **These are the safe controller parameters and should NOT be
     changed.** *Take a look at the file and get familiar with the format used,
-    since may have to write your own for the custom controller.*
+    since may have to write your own for the student controller.*
 
-### Creating your own custom controller!
-In this part, we will learn how to design our own custom controller and actually
+### Creating your own controller!
+In this part, we will learn how to design our own controller and actually
 deploy it and see it working in our Crazyflie. For this, there are a set of
 important files that should be taken into account.
 
@@ -83,27 +83,27 @@ important files that should be taken into account.
 
 * In `d_fall_pps/src`
 
-  * _CustomControllerService.cpp_ <br>
+  * _StudentControllerService.cpp_ <br>
   The file where students can implement their own controller. It provides already the ros service with the teacher. It can be used as a template.
 
 * In `d_fall_pps/param`
 
   * _ClientConfig.yaml_ <br><br>
           <img src="./pics/client_config_yaml.png" style="width: 400px;"/> <br><br>
-  This file needs to be changed to define names for the custom controller. **The safeController property shouldn't be changed!** <br>
+  This file needs to be changed to define names for the student controller. **The safeController property should not be changed!** <br>
 
       *Usage:*
 
-      *`customController: "SERVICENAME/TOPICNAME"`*
+      *`studentController: "SERVICENAME/TOPICNAME"`*
 
-      *where SERVICENAME is the name of the cpp-file that contains the custom controller (e.g. the provided template CustomControllerService) and
+      *where SERVICENAME is the name of the cpp-file that contains the student controller (e.g. the provided template StudentControllerService) and
       where TOPICNAME is the defined name for the topic which is defined insided
       the controller's code.*
 
       *`strictSafety: <bool>`*
 
       *By setting _strictSafety_ to true you limit
-      your custom controller from assuming certain angles before the safe controller
+      your student controller from assuming certain angles before the safe controller
       takes over. Set it to false and the safe controller only takes over when the
       crazyflie flies out of its defined range.*
 
@@ -163,8 +163,8 @@ important files that should be taken into account.
 <!--   * _StudentFollow.launch_ : as an example<br> -->
 <!--   As the circle launcher, this starts another service that enables one crazyflie to _copy_ the behavior of another crazyflie. For this to work, two student groups have to collaborate because some things have to manipulated manually in the cpp files of the Circle and Follow code. -->
 
-#### Steps to create a custom controller
-1. Open the file `CustomControllerService.cpp` and go through it. You should see
+#### Steps to create a student controller
+1. Open the file `StudentControllerService.cpp` and go through it. You should see
    that the file is already filled with some code. This code is a simple LQR
    controller that is offered as a template for the student to start developing
    their own controller. Change the file as you wish with your own controller
@@ -173,7 +173,7 @@ important files that should be taken into account.
         <img src="./pics/custom_controller_src.png" style="width: 700px;"/> <br><br>
 
      In the template you can also see an example of how to use the
-     `CustomController.yaml` to load parameters that you may want to change
+     `StudentController.yaml` to load parameters that you may want to change
      without having to compile or restart the system. Here, as an example, we
      pass some parameters that can be seen below:<br><br>
         <img src="./pics/custom_controller_yaml.png" style="width: 400px;"/> <br><br>
@@ -183,12 +183,12 @@ important files that should be taken into account.
    `roslaunch d_fall_pps Student.launch`. This will run the student's GUI.
 
 4. Make sure that your Crazyflie is turned ON and connect to it. Choose the tab
-   called *Custom Controller* and click on the button *Enable Custom Controller*
+   called *Student Controller* and click on the button *Enable Student Controller*
 
 5. Press the *Take Off* button and you should see your crazyflie taking OFF.
 
       *Note: for take off and landing, the crazyflie uses the safe controller. Once we
-finish taking off, if the custom controller was enabled, we automatically switch
+finish taking off, if the student controller was enabled, we automatically switch
 to it*
 
 6. If everything went correctly, now your Crazyflie is using your own
@@ -203,16 +203,16 @@ to it*
    automatically enabled to try to recover the crazyflie and bring it to the
    center of your zone.*
 
-7. If you decided to put some parameter in the `CustomController.yaml` file, you
-   can now change it and press the *Load CustomController YAML file* button in
+7. If you decided to put some parameter in the `StudentController.yaml` file, you
+   can now change it and press the *Load StudentController YAML file* button in
    the GUI. This way, you can try and see the effect of changing some parameters
    on the fly.
 
 
-#### Steps to plot debug variables from Custom Controller in a graph
+#### Steps to plot debug variables from Student Controller in a graph
 
 1. Choose the variables that we want to see in a plot from the file
-   `CustomControllerService.cpp`. Inside the function `calculateControlOutput`,
+   `StudentControllerService.cpp`. Inside the function `calculateControlOutput`,
    a part where we fill a DebugMsg with data has been written (lines 133-145 in
    previous figure). Vicon data has already been filled in (vicon\_x,
    vicon\_y,...). Additionally, there are up to 10 general purpose variables
@@ -228,11 +228,11 @@ to it*
 4. In each subplot, to add data to plot, write the name of the topic you want to
    plot in the field "Topic", e.g., if we want to plot the Z position of our
    crazyflie, we would have to write here
-   `/<student_id>/CustomControllerService/DebugTopic/vicon_z`. You can see an
+   `/<student_id>/StudentControllerService/DebugTopic/vicon_z`. You can see an
    autocompletion of the
    list of all the topics available when you start typing in the field "Topic". <br><br>
-5. Start the Student node following the steps mentioned before (`roslaunch d_fall_pps Student.launch`) and enable the Custom Controller.<br><br>
-6. Once we are using the Custom Controller, we will be seeing how the data
+5. Start the Student node following the steps mentioned before (`roslaunch d_fall_pps Student.launch`) and enable the Student Controller.<br><br>
+6. Once we are using the Student Controller, we will be seeing how the data
    selected gets plotted in the rqt plots.
 
 <!-- --- -->