SLAM A 02
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 76 | |
| Author | ||
| License | CC Attribution - NonCommercial - NoDerivatives 3.0 Germany: You are free to use, copy, distribute and transmit the work or content in unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/49050 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | |
| Genre |
SLAM and path planning7 / 76
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
00:00
Arithmetic meanAreaRange (statistics)RoboticsSurface of revolutionCountingNumberCodierung <Programmierung>NeuroinformatikGame controllerTerm (mathematics)Metropolitan area networkComputer fileJSONXML
00:51
CodeArithmetic meanLine (geometry)Execution unitNumberRoboticsCodierung <Programmierung>Set (mathematics)Reading (process)Computer fileMultiplication signRight angleInformationOrder (biology)Network topologyCategory of beingState of matterComputer virusPoint (geometry)2 (number)Computer animation
02:32
Plot (narrative)Reading (process)File formatComputer fileXMLComputer animation
02:38
Plot (narrative)File formatData modelOpen setLine (geometry)RoboticsComputer fileMultiplication signRight anglePosition operatorLetterpress printingOpen setComputer animation
03:10
Gastropod shellPlot (narrative)Reading (process)File formatCommon Intermediate LanguageLine (geometry)Electronic mailing listXMLComputer animation
03:21
Plot (narrative)File formatElectronic mailing listLine (geometry)NumberComputer animation
03:44
Plot (narrative)DivisorFile formatString (computer science)NumberHeegaard splittingComputer animation
03:54
Plot (narrative)File formatHacker (term)Reading (process)Module (mathematics)PredictabilityTunisElectronic mailing listTexture mappingString (computer science)IntegerComputer animation
04:12
Twin primeGastropod shellPlot (narrative)File formatModule (mathematics)Reading (process)Electronic mailing listComputer animation
04:19
Gastropod shellPlot (narrative)File formatOrder (biology)PlotterCodierung <Programmierung>CodeElectronic mailing listSource codeXML
04:27
File formatPlot (narrative)PlotterElectronic mailing listRight angleBitRoboticsBlock (periodic table)Computer animation
04:35
BitTrajectoryRoboticsCodierung <Programmierung>Right angleNumberAbsolute valueVideo projectorDiagram
05:10
InformationNumberAbsolute valueSocial classComputer fileDifferent (Kate Ryan album)XML
05:25
Default (computer science)InformationRow (database)Order (biology)Data loggerSocial classDifferent (Kate Ryan album)Equaliser (mathematics)Computer fileXML
05:54
Gastropod shellLetterpress printingInformationSocial classComputer animation
06:02
Gastropod shellDifferent (Kate Ryan album)Multiplication signComputer animation
06:09
BitRoboticsDifferent (Kate Ryan album)Computer animation
06:16
Gastropod shellLetterpress printingRoboticsBitMeasurementDifferent (Kate Ryan album)Multiplication signService (economics)Computer animation
06:45
Meta elementGastropod shellXMLComputer animation
06:52
Plot (narrative)Order (biology)PlotterBlock (periodic table)RoboticsCodierung <Programmierung>Computer animationDiagram
Transcript: English(auto-generated)
00:00
Now that we ran our robot through our arena, let's look at motor control. So this is our robot, here is our LiDAR, the scanner, which will scan somewhere in that range and will have an invisible area here. And these are two motors. And the two motors drive these axes, meaning if they go at a certain speed, the robot
00:24
will also go at this speed. And if one of them goes faster, then the robot will somehow make a turn. Now these motors, they do have wheel encoders, meaning there is encoders that count the number of turns, actually not single turns, but they count many ticks for a single revolution.
00:45
This tick count is sent to our control computer. Our control computer just locks all those values. Here is one of those lock files. And this lock file is also in the set of files that you have for the current unit.
01:01
So this file is called robot4 underscore motors dot text. And we made some code at the start of each line. So here we are writing M for motor, motor information, and then all the data. So from this data I actually don't need very much. So this is a timestamp.
01:20
So this means that millisecond 204, the motor readings were as follows. This number here is the encoder value for the left motor. And we don't need these three values. And this is for the right motor we'll encounter. And there's actually a third motor, which would be this one, but which we are not using.
01:42
So all the other values are not interested. If you want to read this file, just keep in mind, what we need is we have to check if this is an M, so this will be the motor readings, we could use the milliseconds here. Then we need this value and that value. Meaning if we count, this is 0, 1, 2, 3, 4, 5, and 6.
02:06
So we are actually just interested in the value 2 and in the value 6. So also, if you look at this, the encoder values, they do not start at 0. So they start at a certain number. And then when the robot moves forward, they start to increment at a certain point in time.
02:25
So remember, left, that's the second column. And right, that's the sixth column we are interested in. So now let's try to read out the motor file. So in this file, we have those lines, which are M, then a timestamp, then the position left,
02:44
then three other values, which we are not interested in, and then the position right, both in ticks. So first of all, let's open the file. The file is robot4motors.txt. And so we open it, and first of all, let's just print out all the values.
03:04
So we say, for line in file, print the line. Then we run it. And you can see, it brings out those lines that we've just seen on the last slide. So now let's read out the left and the right motor ticks.
03:22
So I start by making a left list, which is empty, and a right list, which is empty. And then I have to split up the line into its columns. So I say, sp is a split up of the line. In fact, let's just print sp to see what happens.
03:45
The split command splits up the string in parts, and it will have the M, column number zero, column number one, two, three, and so on. And so we can just grab the columns we'd like to have. So we take the left list, but actually we're interested in the integer and not in the string.
04:04
So we convert it to an integer. And we append to the right list the sixth column. Let's try this. It works, but we can't see anything. So let's just ask for left list. So this is all values of the left encoder.
04:24
So now that we have this, let's just plot this. In order to plot, we import PyLab, and then we just plot both lists, plot left list and plot right list. Let's run it. So that's the outcome. So these are the values of the two incremental encoders.
04:43
So the left one starts at a little bit more than 20,000. The right one starts at more than 15,000. And then the robot starts to move, and they just increment. And we can see that the left one starts at a higher value, but in the end, it ends up in a lower value.
05:00
So this means the right wheel encoder has more ticks along the entire trajectory than the left one. So the robot does a left turn. So the absolute tick numbers are not really so meaningful. And so it's hard to interpret the drawings that we just made. So let us build the difference of ticks.
05:22
And now we could just program this, but I'll show you something else. So there is a class which is in the package that you downloaded for this course, which is called Lego log file. You can import that. And the purpose of this class is to import all different kinds of records
05:41
that we will produce throughout this class. So in order to read a file, you can just say log file equals Lego log file, and then just read it like that. And if you run that, now we have this class. And for example, we can ask for the motor ticks.
06:03
And those ticks are the differences from one time step to the next one. So let's just print out the first 20 motor ticks. And here they are. As you can see, in the beginning, the robot does not move.
06:23
And then after a while, it starts to move, it starts to accelerate, it gets faster. And then here's a little bit of difference. So the left motor goes one tick faster than the right motor. And then we're also having something else here. We do have some time lag. And due to this time lag,
06:40
we have zero zero values spread across our measurements. If I make that longer, you will see that occurs more often. See, at about every five movements or so, we have a zero zero. Now let's plot those values in order to see what's going on. So I'm adding the import from PyLab, and then it is as simple
07:01
as just adding the plot command down here. Now let's see what happens. Now in this plot, we can see the incremental values for the motor encoders. And we see those spikes going down to zero, which is not what we actually want.
07:20
But we can also see the robot drives straight and then the right motor gets faster, whereas the left motor gets slower. So the robot makes a turn, then it goes straight again, and so on. So you also can use this to have a closer look.