1DOF Haptic

Note: The electronics of the robot are based on a Arduino Due board: https://www.arduino.cc/en/Main/ArduinoBoardDue Moreover, the motor control is done through a H-Bridge board from ST: http://www.st.com/en/ecosystems/x-nucleo-ihm04a1.html

Configuring the environment

Setting up the Arduino Software

• Download the Arduino IDE 1.6.x according to your operating system from: https://www.arduino.cc/en/Main/Software .
• Install the Arduino IDE
• If you have chosen to download the installer, run the installer and install the software in a path of your convenience.
• If you have chosen to download the sources (Linux or zip on Windows), uncompress the software in a path of your convenience
• Open/run Arduino IDE, so it will create all the folders needed

Installing Tools and Libraries

• The 1DOF haptic robot uses a Arduino DUE board, so we need to install it on the Arduino IDE. Open Boards configurator:

Tools → Boards → Boards' Manager

Install support for SAM Boards - (32-bits ARM Cortex-M3

• Download the DueTimer.zip library from: https://github.com/ivanseidel/DueTimer/releases
• Install the library:

Program → Include library → Add Zip library

• Select the zip file were have been downloaded

Installing FTDI drivers

If you are using Linux or Mac, skip this step. If you are using Windows, power up the robot and connect it to your computer. Windows should ask you to install some FTDI drivers to be able to connect to the robot.

Hello World example

We have created a helloWorld example to test the communication with the robot. Please download it from here in your prefered destination. Untar the file:

tar -xvzf helloWorld.tgz

Compiling the code

• Open Arduino IDE and load the .ino file in your environment:

File → Open → <HELLOWORLD_EXAMPLE>

• Select the Arduino DUE board:

Tools → Board → Arduino Due

• Compile the program:

Program → Verify/Compile

Downloading the code to the robot

The Arduino Due has two usb ports. The one that is closer to the power jack is the programming port and the one used with the 1DOF Haptic Robot.

Select the correct port to download the binaries: In Linux, typically:

tools → Port → /dev/ttyUSBX

In Windows, typically:

tools → Port → COMX

where X depends on your system and the number of peripherals on it

Upload your code to the board:

Program → Upload

The IDE will notify that it is uploading and after some seconds it will say uploaded .

Playing with HelloWorld

This example allows you to see the functionality of some of the functions handcoded. Once the software has been loaded, the robot should move 1 second counterclockwise and 1 second clockwise. After those 2 seconds it should stop.

Once the code have been loaded, you can open the serial port:

Tools → Serial Monitor

You should see in real time the information provided by the helloworld example, basically:

• Count: The communication time, in timer ticks
• Pos: The position, in encoder pulses units
• Vel: The speed, in encoder pulses units

Practice 2 Template (P2)

For the implementation of Practice 2 of the "Control and Robotics in Medicine" subject of the "Master on Bioengineering" of the UPM, we have created a students template. You can download the template from here

Structure

The template has 5 different block of files:

• encoder.{c,h} : where functions related to the measurement of encoder are developed.
• motor.{c,h} : where functions related to the movement of the motor are developed.
• comm.{c,h} : where functions related to the serial port communication are developed.
• controller.{c,h} : where specific controllers could be developed. It will not be used on P2
• P2Template.ino : The place where the practice should be developed.

Libraries

This Section provides important information for the resolution of Practice1. It is based on the explanation of different methods to control the robot, but it does not explain the complete set of methods. To get and exahustive description of all methods the servos.h and robot.h files must be studied.

In principle, all interaction with the robot will be made by means of the robot.h library. Main methors are as follows:

• void ROBOT_GripperOpen(void) : It opens the gripper, so it can release an object if already grasped.
• void ROBOT_GripperClose(void) : It close the gripper, so it can grasp an object if correctly located.
• void ROBOT_SetSingleTrajectory ( double *f_pos, uint16_t un_time, uint8_t un_trajectory_type ) : It performs a trajectory form one point (Q(t₀)) to another point (Q(t_f)). Q(t₀) and Q(t_f) are defined as generalized coordinates Q={q₁,q₂,q₃,q₄,q₅}. Moreover, Q(t₀) is defined as the coordinates at which the robot is located once the instruction is set.
  • double *f_pos : Q(t_f) is coded as double * , for example:

    double m_fCoordTest[]       = {0,M_PI/2,-M_PI/2,0,0};
    

  • uint16_t un_time , represents the time that it takes to travel from (Q(t₀)) to Q(t_f),that is: t_f - t₀ in milliseconds.
  • uint8_t un_trajectory_type , represents the type of trajectory to perform: Linear (LINEAR = 0) or Cubic (CUBIC1 = 1)
    
    Therefore, if we want to move the robot for the actual position to position m_fCoordTest taking 2 seconds with a linear function, we need to execute:

    ROBOT_SetSingleTrajectory (m_fCoordTest, 2000, LINEAR);
    

    I we want to move the robot to the same coordinates but in 10 secons with a cubic function, we need to execute:

    ROBOT_SetSingleTrajectory (m_fCoordTest, 10000, CUBIC1);
    

• void ROBOT_SetDoubleTrajectory ( double *un_pos1, double *un_pos2, uint16_t un_time1, uint16_t un_time2, uint8_t un_trajectory_type ) : It performs a trajectory form one point (Q(t₀)) to another point (Q(t_f)) passing by a point (Q(t_v)). Q(t₀), Q(t_f) and Q(t_v) are defined as generalized coordinates Q={q₁,q₂,q₃,q₄,q₅}. Moreover, Q(t₀) is defined as the coordinates at which the robot is located once the instruction is set.
  • double *f_pos1 : Q(t_v) is coded as double * , for example:

    double m_fCoordTest[]       = {0,M_PI/2,-M_PI/2,0,0};
    

  • double *f_pos2 : Q(t_v) is coded as double * .
  • uint16_t un_time1 , represents the time that it takes to travel from (Q(t₀)) to Q(t_v),that is: t_v - t₀ in milliseconds.
  • uint16_t un_time2 , represents the time that it takes to travel from (Q(t_v)) to Q(t_f),that is: t_f - t_v in milliseconds.
  • uint8_t un_trajectory_type , represents the type of trajectory to perform. Only cubic trajectories are allowed (CUBIC2 = 2)
    
    Therefore, if we want to move the robot for the actual position to position m_fCoordTest taking 5 seconds passing by m_fCoordVia with 2 seconds from the start, we need to execute:

    ROBOT_SetDoubleTrajectory (m_fCoordVia, m_fCoordTest, 2000, 3000, CUBIC2);
    

Implementation

P1-Template.ino follows the same structure as the helloWorld.ino example. However, a new option has been included in the menu (Opcion A). This option calls the P1Solution method. If you open P1-Template.ino and go to the end of the file, you will see the following code:

void P1Solution ( void )
{
  /* START CODE TO BE IMPLEMENTED BY THE STUDENTS */

  /* END CODE TO BE IMPLEMENTED BY THE STUDENTS */
}

It is between those comments where you must implement all functions required to achive the task. Remember you may need some delay instructions, defined as void delay (uint16_t millisec) , to prevent some instructions to execute before you need them.




Moreover, in the poses.h file you can find some examples of how to define the generalized coordinates of your system.