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
Program → Include library → Add Zip library
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
File → Open → <HELLOWORLD_EXAMPLE>
Tools → Board → Arduino Due
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.
Methods
This Section provides important information for the resolution of Practice2. 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 all fies must be studied.
Given some restrictions to the Arduino software structure, some function prototypes are defined in the main file. However, sections related to the header files refer to its implementation.
Encoder
This library is in charge of calculating the movement of the motor related to the encoder. The functions to control the encoder are defined as follows:
- void ENCODER_Init (void) : It configures the pinout of the encoder and launches the interrupts related to channel A and B.
- void ENCODER_StartSpeedCalculation ( long l_sampling_time ) : It configures a timer in charge of calculating the speed average of the motor.
- long l_sampling_time : It defines the sampling period in milliseconds.
- long ENCODER_GetCount ( void ) : It returns the actual count of the encoder, that is, the position of the motor related to its initial condition.
- return : It returns a long value related to the pulses of the encoder, positive or negative, related to the initial position of the encoder.
- long ENCODER_GetCountInSpeedInterval ( void) : It returns an averge speed, expressed in counts per second.
- return : It returns a long value related to the pulses per second of the encoder, positive or negative.
Motor
This library is in charge of moving the motor. The motor is moved based on PWM which is executed at a sampling period.
The functions to control the motor are defined as follows:
- void MOTOR_Init ( void ) : It configures the pinout of the H-bridge to control the motor and inits the PWM peripheral to control it.
- void MOTOR_SetVoltage ( float f_voltage ) : If sets up a voltage to be sent to the motor. Remember the motor is controlled through a PWM, so it really sets up a PWM to controlthe H-Bridge.
- flot f_voltage : This is the value of the voltage to be applied to the motor. It can be positive or negative, and the function limits the maximum and minimum values according to the MOTOR_MAX_VOLTAGE variable defined in motor.h
Communication
This library is in charge of managing periodic communications through the serial port.
The functions are defined as follows:
- void COMMUNICATION_Init ( int speed ); : It configures the serial port at a speficif speed.
- int speed : The speed, in bauds, to configure and open the serial port.
- void COMMUNICATION_Start ( long l_sampling_time ) : It starts a timer to handle periodically the communications. This timer calls the COMMUNICATION_ROB function at l_sampling_time
- long l_sampling_time : It defines the sampling period in milliseconds.
- void COMMUNICATION_Stop ( void ) : It stops the timer in charge of calling COMMUNICATION_ROB , so communication stops.
Controller
This library is in charge of managing a periodic timer to implement the controller developed.
The functions are defined as follows:
- long l_sampling_time : It defines the sampling period in milliseconds.
P2Template.ino
- 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(t0)) to another point (Q(tf)).
Q(t0) and Q(tf) are defined as generalized coordinates Q={q1,q2,q3,q4,q5}.
Moreover, Q(t0) is defined as the coordinates at which the robot is located once the instruction is set.
- double *f_pos :
Q(tf) 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(t0)) to Q(tf),that is: tf - t0 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);
- double *f_pos :
Q(tf) is coded as double * , for example:
- 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(t0)) to another point (Q(tf)) passing by a point (Q(tv)).
Q(t0), Q(tf) and Q(tv) are defined as generalized coordinates Q={q1,q2,q3,q4,q5}.
Moreover, Q(t0) is defined as the coordinates at which the robot is located once the instruction is set.
- double *f_pos1 :
Q(tv) is coded as double * , for example:
double m_fCoordTest[] = {0,M_PI/2,-M_PI/2,0,0}; - double *f_pos2 : Q(tv) is coded as double * .
- uint16_t un_time1 , represents the time that it takes to travel from (Q(t0)) to Q(tv),that is: tv - t0 in milliseconds.
- uint16_t un_time2 , represents the time that it takes to travel from (Q(tv)) to Q(tf),that is: tf - tv 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);
- double *f_pos1 :
Q(tv) is coded as double * , for example:
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.
