Motors Control with the Vespa

Understanding the Code

The code above begins with the inclusion of the "RoboCore_Vespa" library, and then the motors object is created as an instance of the VespaMotors library, that will allow us to control the motors connected to the Vespa. To finalize the global declarations of the code, we declare a variable to store the maximum speed at which the motors are activated (MAXIMUM_VELOCITY) and a variable to store the waiting interval between state changes of the motor control (PAUSE_TIME).

At this moment, it is worth noting that the maximum and minimum speeds for controlling Vespa DC motors are 100 and 0, respectively.

In the code settings (function void setup()), is not necessary to execute any command.

The loop of the code (function void loop()) is started with the function forward() of the library, which is called through the command motors.forward(MAXIMUM_VELOCITY) in the code. It is responsible for driving both motors counterclockwise with the requested speed in parentheses (in the case of this example, it is the maximum speed). After starting the motors, the motors are kept turning during the time stored in the PAUSE_TIME variable, and then the motors are stopped thanks to the stop() function, which is called through the command motors.stop(). With the motors stopped, the time stored in the variable PAUSE_TIME is waited again before executing another control function.

At this point, it is worth remembering the correlation between the directions of rotation of the motors with their polarities in the circuit. The forward() function activates both motors in the same way, thinking about moving the robot forward, in other words, they rotate in the same direction. However, this is only possible because the motor connections are reversed at the terminals, since the motors are mirrored on the robot chassis. If one of the motors is incorrectly connected, it will rotate in the opposite direction to the expected and the robot will keep rotating instead of moving forward. If this happens in your tests, invert the connection of the motor that is turning in the opposite direction on the Vespa terminals.

After driving the motors counterclockwise (forward), they are driven clockwise (backwards), by the function backward(), which is called in the code by the command motors.backward(MAXIMUM_VELOCITY). As with the forward() function, the backward() function also depends on a number between 0 and 100 to be called. Then, in the same way as with the front movement activation, the time saved in the variable PAUSE_TIME is waited to stop the motors and for a new repetition of the loop.

Understanding the Code

This code starts exactly the same as the previous project code, with the inclusion of the "RoboCore_Vespa" library and the creation of the motors object as a VespaMotors instance from the library.

Then we have the declaration of the variables MAXIMUM_VELOCITY, CURVE_VELOCITY, PAUSE_TIME and ACCELERATION_TIME, which store the maximum speed value for activating the motors, the speed at which one of the motors will assume for a curve, the pause time that will exist between motor status updates and the time for acceleration and deceleration delay to the individual control of the motors, respectively.

In the code configuration (function void setup()), we just initialize the serial monitor, so that it is possible to keep track of the code execution.

At the beginning of the code loop (function void loop()), we have the joint control functions of the motors, in other words, the functions that allow the motors to be activated at the same time. The first of these are the forward() and backward() functions, as shown earlier. These functions keep the motors turning during the time saved in the PAUSE_TIME variable, and then keep then stopped during this same interval after the execution of the stop() function.

The next function used by the code is the library's turn() function, which must be called with two parameters (values). The first one is the speed value for the left motor and the second one is the speed value for the right motor. In other words, the function must be called through the command motors.turn(LEFT_SPEED, RIGHT_SPEED), where both values can be numbers from 0 to 100. This function also allows the use of negative values, which causes the motors to drive backwards (clockwise) as the positive value by default drives the motors forward (counterclockwise). In the code above, four possibilities of use are shown to rotate a robot, which are: the curve to the left going forward; the turn to the right going forward; the left turn going backwards; and the turn to the right going backwards. Remembering that it is possible to make several combinations of speeds for different movements of a robot.

After executing the turn() function in different ways, we finished the demonstration of joint control functions from the Vespa library and now we will see the individual control functions of the motors. To control the speed of each motor separately, you can use the setSpeedLeft() and setSpeedRight() functions for the left and right motor, respectively. These functions depend only on the desired speed parameter to be called between parentheses in order to activate the motors, and again it is possible to use a value between 0 and 100, and a negative value is also possible for the rotation to be inverted.

In the code above, the use of these functions is done through acceleration and deceleration ramps, which can be very useful to reduce current consumption peaks of DC motors and even for the robot to start more smoothly.

After demonstrating the functions, double the time stored in the variable TEMPO_PAUSA is waited before repeating the code.