CE215 - Assignment 1 : Dead Reckoning Reg NO:

Transcription

1 CE215 - Assignment 1 : Dead Reckoning Reg NO: Abstract: The report aims to determine whether or not a robot can be constructed and controlled in such a way to make it move in a 1*1 meter square. This relies on a number of concepts, such as dead reckoning to determine the right course to take, and the accurate calculation of the robots turning circle, speed and distance. The code necessary to perform this relies primarily on the DifferentialPilot class to direct the robots direction, and supporting classes to log the data to a text file. The report has found that this is possible, with some minor errors due to a variety of factors including manufacturing errors and bugs in the code presented. Introduction The challenge for this project has been to construct robot, built with a differential drive mechanism that can circumnavigate a square with a perimeter of 4 meters, turning 90 degrees at each corner and logging the results along a 2D plane. The solution to the problem has been to create a four wheeled (or tracked) differential drive tracked robot, capable of carrying the NXT control module, and a java program using the TachoPilot and Pilot classes to control the robot and output telemetry to a specified file to a text file, to be interpreted by MS Excel. However, a number of technological constraints exist. Firstly, although this could have been achieved with classes such as TachoPilot and Pilot. It is unfortunate however that updates to the NXT api recent updates to the API[1] have rendered these classes obsolete. This means that alternative programming solutions have had to be found to make even the most basic task of moving the robot feasible. Secondly, as the NXT relies on explicit instructions to interact with. These instructions depend entirely on it s own interpretation of the outside world, and in order to determine it s current and relative position to another location it must rely on dead reckoning. This can only work when the device receives accurate information from the environment, through the robot s hardware. Thirdly, the hardware itself is a constraint. With only a Tachometer to determine the current position the robots dead reckoning technique is a best guess approach to it s environment. If obstructions, or the environment were to change it s possible that the robot would be unable to execute it s task as expected. Therefore, the project is technically challenging in terms of both the physical mechanisms of the robot and in the application of java programming with the NXT API. In order to understand the solution it s necessary to first understand the theory behind differential drive robots. A differential drive robot has the unique ability to independently change the speed, and direction of rotation for each of it s motors. As a result, the NXT robot is suited to the application of following a square it can pivot around any given point. In theory, these robots can change their heading by redefining the variables for calculating speed, or direction. As can be seen by examining the equations for determining how many times a wheel rotates (countsperrotation), the change in the wheels rotation (radians per count), and change in heading: countsperrotation = Pi * trackwidth/pi * WheelDiameter * countsperrevolution. radianspercount rpc = 2*Pi/counsPerRotation DeltaHeading (Change in heading in radians) rightcounts - leftcounts * radianspercount /2 From these equations it s possible to note the following. Firstly, that a change in the wheel diameter will have an affect on the counts per rotation because it will change the circumference (PI*diameter) of the wheel. The greater the circumference, the slower the wheel has to turn to cover the same distance and conversely the faster it will have to turn if the diameter is smaller. This same principle can be applied to the turning circle of the vehicle by varying the distance between the two wheels. As a result, supplying the magic numbers for the robot s track width and diameter is essential to ensuring the correct behavior of the robot. Secondly, the change in the robots heading given it s turning distance (radians Per count) and the difference in speed of both left and right counts. The point of origin in this case depends on the number of counts between the left and right wheels, and a negative count would mean that the robot had turned left and not right. Thirdly, it is insufficient on it s own to accurately record the change in heading of a robot along a 2D plane. It is necessary to use the deltadistance to 1

2 the cos and sin for the absolute (compass) heading of the robot: deltax = deltadistance * cos(heading); deltay = deltadistance * sin(heading); The use of the cos and sin factors for the absolute heading is what enables the robot to interpret it s position relative to where it started in terms of X and Y. As the tachometer will record the counts for each wheel the only thing necessary to complete the solution is the correct track width and wheel diameter for it to turn accurately. However it would be unnecessarily complicated to write your own classes for each equation since the NXT API provides classes to do just that, and the features of these will be detailed in the next section. This will be followed by an experimental method and an explicit explanation of the software code, the results, an evaluation and a conclusion for the report s findings. Method: According[2] to the NXT robot specification, the following hardware is included with the device: 32-bit ARM7 microcontroller 256 Kbytes FLASH, 64 Kbytes RAM 8-bit AVR microcontroller 4 Kbytes FLASH, 512 Byte RAM Bluetooth wireless communication (Bluetooth Class II V2.0 compliant) USB full speed port (12 Mbit/s) 4 input ports, 6-wire cable digital platform (One port includes a IEC Type 4/EN compliant expansion port for future use) 3 output ports, 6-wire cable digital platform 100 x 64 pixel LCD graphical display Loudspeaker - 8 khz sound quality. Sound channel with 8-bit resolution and 2-16 KHz sample rate. Power source: 6 AA batteries The robot constructed for the project has a four wheeled configuration with a track between each set of wheels to ensure stability and equal torque distribution between each of the wheels. It carries on it s back the NXT controller that has a USB connection for PC access, and ports for connecting to sensors or to motors. The motors, in turn will provide output to the controller from the tachometer to keep track of the angle of the wheel. The corollary being that the more times the tachometer rotates, the further the robot has travelled towards it s destination. In order to regulate the speed, and heading the robot will also perform PID error correction to maintain the right course. The robot s wheel diameter was measured as 4.1cm and the track width was measured at cm. These figures are in reality not exactly the same as the actual track width and wheel diameter because of ambiguities in the granularity of the measurement. For example, given a tracked robot such as the one in this project the measurement may be taken from inside, the center or the outside of the track and the tracks themselves have a varying diameter based upon the divets in the tracks themselves. In order to control the robot, I ve elected to use the DifferentialPilot class as it is a class that has been created specifically for the purpose of controlling these robots. For this purpose, the following methods have been used: DifferentialPilot(Diameter, Radius, Motor,Motor): This creates a new pilot. The pilot manages the motors, including the current tacho count and the velocity of both motors under a single object. The subsequent methods are all public void travel(double distance, boolean immediatereturn) - this method immediately returns, allowing the program to continue running other operations in the meantime. public boolean ismoving() - the robot requires some way to determine where it is relative. travel(float distance) - allows the robot to travel a specified distance. setspeed(int) - makes the robot go faster setrotationspeed(int) - makes the robot turn quicker rotate(int degrees); - determines how far the robot will rotate in radians given the current position. Code explanation: For reference purposes the code has been explicitly mentioned in the appendix [1, Appendix i], and all references to NXT classes can be found in the API [1]. The code will be restated here for the purposes of explaining the methodology for the solution. 1) Construction: The program begins by constructing a new Assignment 1 object. An assignment 1 object has many fields, including: 2

3 Final fields for the diameter and track width (final since they won t change for the entirety of the program) FileOutputStreams to buffer data into a new file OdometryPoseProvider to track the current location of the DifferentialPilotClass. A DifferentialPilotClass to drive the robot to a specified length and and a DataOutputStream to extend the programs capabilities to write out character arrays. From this it s possible to note the following: 2.Moving 1) The final fields are initialized in the constructor with the specified track width and wheel diameters necessary for the pilot class to correctly determine it s position. They are also initialized with the motors that ultimately control the ovement of the robot. In real terms this means that the pilot is able to determine it s relative position from the diameter, and is able to calculate the rate of rotation from the track width. 2) The FileOutput stream is initialized with a new file out.txt. It is surrounded by a try/catch block in case the file cannot be created. 3) The OdometryPoseProvider is created to take the pilot as an argument. It augments the pilot by providing a means to get data through the.getpose() method later on. The documentation suggests that the.addlistener() method should be added, so this has been added in the constructor just in case. 4) The differentialpilot instance is created with the aforementioned variables and the motors. 5) A dataoutput stream has been created to take the FileOutputStream instance as an argument to write characters to. After construction, a new Assignment object is returned to the main method. Since the Assignment1 object extends thread, the main method calls a.run() method to start the thread running. Entering a for loop, the program will repeat the following process: start the robot moving in the current direction while the robot is moving, keep writing to the DataOutputStream the current position of the robot. This is obtained through the odometryposeprovider mentioned earlier, which can be extracted with.getpose().tostring and separated with a newline character at the end. when the robot stops moving it will then set the rotation and forward speeds to very fast and delay for 500ms. This makes it easier for the operator to debug where the stop and start points for the robot are. The rotation will then occur by 90 degrees and the robot will travel 1 meter. 3.Writing the file The fileoutputstream is then flushed, to make sure that it doesn t hold any further data. It is then closed to ensure that all the data is written to the file. Experimental method: In order to test the expectation that the robot will travel in a straight line for a set distance and then rotate. This will be tested with the following methodology: Load the software onto the robot by connecting the USB connector to it, and click on the NXJUpload option. Place the robot facing towards a point of reference Use the left, and right buttons on the NXJ controller to find the right assignment option. Select this and execute it. The robot should move 100cm forward, and rotate right 90 degrees. it should repeat this four times with the expected result that the robot should have traced a perfect square. Record the results by plugging in the device, and opening the NXJBrowse application. Results As the results demonstrate (see appendix), the robot has drawn a square with a perimeter of 1 meter. This clearly meets the expected requirements of the project s experiment. However, the results are not entirely perfect with a bowing of the squares first three sides. It s possible that some factor of the experiment s setup may have affected the results adversely. For the purposes of verifying the experiment s findings the java file used for the robot has been included in addition to the report. This can be uploaded to any NXJ robot with the same tracked configuration. 3

4 Evaluation: As alluded to in the results, the project was a success because the robot moved as expected along a square path, but it did not give exactly the results expected. This may be for a variety of reasons : As no set of motors are exactly alike because of manufacturing differences, even the most accurate calculation of the change in distance may be inaccurate. The wheel and track dimensions had to be continually modified to get approximately the right result. As such, no perfect measurement appears to exist to get the robot to behave exactly as expected. This was compounded by the fact that the device had to be shared with another project in. The fact that the speed was manually set for the robots forward motion and rotation means that the PID error correction may have over-compensated when used in combination with the Report Conclusions: The report demonstrates that it is possible to not only construct but to control a robot to move in a 2D plane using the principles of dead reckoning. 4

5 References: [1] Lejos (N.D). Overview (LEJOS NXT API Documentation). Internet: lejos.sourceforge.net/nxt/nxj/api/overviewsummary.html [20th feb, 2013] [2] N.A (N.D). Welcome to the lejos nxt. Internet: cosc465/nxt/welcome_to_nxt.html [20th feb, 2013] 5

6 Appendix: [1] program code here. package Class1; import java.io.dataoutputstream; import java.io.file; import java.io.fileoutputstream; import java.io.ioexception; import lejos.nxt.sound; import lejos.nxt.motor; import lejos.robotics.localization.odometryposeprovider; import lejos.robotics.navigation.differentialpilot; import lejos.util.delay; public class Assignment1 extends Thread {!! final static double LENGTH = 100; final static double DIAMETER = 4.1; final static double TRACKWIDTH = 19.85;! private static DifferentialPilot pilot ;! private FileOutputStream fos; private DataOutputStream dout; private OdometryPoseProvider positionhistory;!! public Assignment1(){ pilot = new DifferentialPilot(DIAMETER, TRACKWIDTH, Motor.A, Motor.C);! try { File file = new File("out.txt");! fos = new FileOutputStream(file); } catch (IOException e) {!! // TODO Auto-generated catch block! e.printstacktrace(); }! dout = new DataOutputStream(fos); positionhistory = new OdometryPoseProvider(pilot); pilot.addmovelistener(positionhistory);! }! public void run()! {!! try{! for(int i = 0; i<4 ; i++)! { pilot.travel(length, true); while(pilot.ismoving()){! dout.writechars(positionhistory.getpose().tostring()+"\n");! Thread.sleep(500); } pilot.settravelspeed(50); pilot.setrotatespeed(2000); pilot.rotate(90);! Delay.msDelay(500);! }! fos.flush();! fos.close(); } catch(ioexception e){! Sound.beep(); } catch (InterruptedException e) { // TODO Autogenerated catch block e.printstacktrace();! }! }! public static void main(string[] args)! {! Assignment1 as1 = new Assignment1();! as1.run();!! } } 6

7 [2] Table/Graph of results. 7