>> Well, let's give Project
1 another try here. So, what we had attend to do
last week was make a short sort of a coaching video on the
Project 1 SunPass and it turned out that there was no
sound associate with that. And so, it was probably
quite difficult to follow. So, I'm making up for
that by making a recording on my desktop system,
not in the classroom. So, I want class participation
in this, but nevertheless, I think I can remember most
of what we talked about. So, this is Project 1, COP3330,
the project is called SunPass. It is a simulation of the Florida's
Turnpike Authority SunPass automated toll system which I think you'll enjoy. You probably have some
experience with that. It works with a little transponder
is taken the windshield of you car and then enables, you know, just sort
of fly through toll areas in some cases without even really slowing down
and there's an automated cache of the data for your vehicle. And an automated debit to
an account that you have with the Florida Turnpike Authority. So, there's a lot more though
that's important about this from your education point of
view and that is that this is one of the two assignments that assesses
the required outcomes for the course. But these are outcomes in
[inaudible] both ABET and SACS, the Southern Association
of Colleges of Schools which credits the entire university. So, this is important
for ABET Accreditation for the [inaudible] SACS program
but it's also [inaudible] in general for accreditation of all
of our degree programs. And the way this works is this-- there are certain outcomes
if you're expected to pass. If you don't pass on assessment with
those outcomes, then you're not-- we're not allowed to
pass you for the class. So, it's important. And there are five outcomes
assessed in the course, four of them are assessed
in this assignment. And we usually assess those with three
possible grades ineffective, effective and high effective, and a pass
is getting either effective or highly effective. What you're supposed to be able to do
is use arrays and pointers, use classes and objects, show that you know how to use object oriented
programming techniques that include inheritance
and polymorphism. Now, those aside, the
educational objectives for this particular assignment are-- you need to be able to find a
class hierarchy using inheritance and also multiple inheritance. You need to be able to find virtual
member functions in a class hierarchy and know why you're doing it. You need to be able to implement
all those things which we defend. You need to be able to use initialization list
with your constructors. And this will call parent
class constructors for derived class initialization
list and also initialize variables that are defined for the first
time in the derived classes. You need to know the call sequence for
constructors and inheritance chain, the call sequence with
destructors and an inheritance chain and define dynamic polymorphism. And we already use a class hierarchy
to implement dynamic polymorphism. Mentioned here static or compile time
polymorphism that really needs to-- that objective isn't exactly
associated with this project. It's really associated with Project 2. So-- but nevertheless, good to
[inaudible] in there because it lines up nicely with dynamic polymorphism. So, operationally, what you're supposed
to do is create classes for box, cylinder, plane, vehicle, car,
truck, van, tanker and flatbed. So, that's one, two, three,
four, five, six, seven, eight, nine classes here to define. And an object-oriented vehicle
counter for use by the Department of Transportation that object-oriented
vehicle counter is called Tracker in this assignment. So, deliverables are going to be
seven files, vehicles that are filed, vehicles implementation file, shapes
header file, shapes implementation file, skipping that for a moment, a
tracker implementation file. That is the client program. And as you makefile, we are--
we did supply makefile to you and that you're welcome to submit that
one to satisfy the makefile deliverable. But you should not submit it unless
you understand it because one of the things you need to get out of
this course is learning to do makefiles. Back to the verbose.cpp. Verbose really is the code base from
shapes and from vehicles together in one file and with the constructors
and destructors all modified to display something to screen that
tells you when they had been called, much like in the example
in the chapter-- the 4 chapter on classes on
polymorphism that we went through in the class lecture notes. They just announced that they had
been called to the screen, whereas-- so that's the verbose, and the shapes
and vehicles implementation files. Those classes are supposed
to be not verbose or silent. That's the only difference. So, you would concatenate that file
and that file to make that file. And then, there would be slight
differences between those to the concatenation
and this verbose file. We'll get into that a little bit later. So, the tracker project simulation
application called Tracker for the Turnpike Authority. So, data from SunPass
transponders as accumulated in the real time using
various sensing equipment. The sensors detect a
SunPass-equipped vehicle and actively inquire further data
when that vehicle is a truck. The data is using a lot of
things to charge or passage toll on the vehicle's SunPass
account thus eliminating the need to stop at toll booths. SunPass is valid in all toll
roads and bridges in Florida. And by the way, many other toll
roads throughout the eastern seaboard by agreement between
Florida and other states. So, for example, I believe
its in New Jersey's Turkpike. For all vehicles a serial
number is collected. The serial number can be decoded
to determine the vehicle type. And the vehicle type can be
a car, a truck, of a van, style or truck of a tanker style
or truck or a flatbed style. It can-- the serial number determines
the passenger capacity and for trucks, the dimension of its carrier. And its box on the back so to speak. And for trucks we also get
the DOT license number. So, the way tracker would workis
you set it up as a specific part on a roadway near a toll booth and-- or specific segment of
limited access highway. Once activated, it keeps running account
of the SunPass equipped vehicles. Report summary data when necessary. And basically, we're
simulating that system. So, procedurally, of course, you
began by making a directory inside of your COP 3330 directory
and call it Project 1. Copy files into that project directory. What you'll see there is tester.cpp,
some segment data, segment 0, segment 1, segment 2, a makefile or submit script
and some executables out of Area 51. A tester-- tester bad telling one of
the many ways tanks can get messed up and then executing tracker
program as well. So, you define these classes, the file shapes.h would contain the
class definition of Box, Cylinder and Plane, the three shapes
we're going to be dealing with. The file vehicles.h contain the
definitions of vehicle, car, truck, van, tanker and flatbed. Shapes.cpp should implement
the methods of shapes. And vehicles.cpp should implement
the methods for those classes. Now, here's verbose again. So, verbose should contain
the verbose versions of the various class implementations. I'll talk about that yet
again down at the bottom here. So, you develop all those
classes of steps, three, four, five and six and test that. Then you turn around and develop a
client program for those classes. It's all right to call that set of
classes or framework by the way. This perfectly into the
definition for the framework is. So, you're creating the vehicles
framework and then you're going to create a client of that
framework called tracker. And when you do that, and test
it and you're surely right, you submit them as Project 1. Now, let's take a look
at the specifications for these classes that
you've got to define. So, we're now talking about Code
Requirements and Specifications, Server Side meaning you're
developing the framework. Class Box has a volume function, and private length, width
and high variables. That is that we're sticking to
our convention of using a trail like underscore for class variables. So, class Cylinder and other one of the
Shapes, it also has a volume function and it has a length and a
radius, private variables. Plane really should be
maybe called a rectangle. It has an area, and a
length and a width. The areas are public const method
and of course private variables. So, then we get to Vehicle. Class Vehicle has a number of services. It's got the SerialNumber,
service returns. The SerialNumber as notice a C string. The PassengerCapacity
return is one sign integer. LoadCapacity return does
a floating point number. ShortName return as a
const char star C string. A Toll which is returns
a floating point number. And then there is a static method called
SnDecode and we may be read that longer and say SerialNumber Decode. This is a static function which
means that it doesn't really-- it doesn't use any of the class data. It just is a function in the name space
vehicle, that's basically what it means to make a static number function. It's a standalone function,
but it's tucked away in the name space defined by the class. We'll talk in a little bit about what
these things are supposed to mean. Now, I notice that there's a product
variable a char star SerialNumber and an unsigned integer
PassengerCapacity. Note again, the SerialNumber
is a C string PassengerCapacity as an unsigned integer. So, when you create a vehicle that
information and that information needs to be recorded in that vehicle object. OK, Car inherits from Vehicles. So, Car is a char class of vehicle. Car will override the short name
to return car to sort of identify to the world what kind of class
it is, what kind of object it is. I didn't say but short name for Vehicle in the base class returns
UNK for unknown. So, when you're at the
level of the vehicle, you don't really know what
kind of Vehicle it is. So, you go down to the more special
case of a CAR and, you know, your car. Truck also inherits from Vehicle. And its short name will
return TRK for Truck. Truck also adds the total service-- I'm
sorry-- overrides the total service. The total service is in
the base Vehicle class. Notice that Car didn't not
need to override total service. So, it's not mentioned
here in the services. Only ones we mentioned are the
ones that we have to change or the new services that
that derive class. So, anyway, truck, of course, inherits
from Vehicles so it's got SerialNumber, PassengerCapacity, LoadCapacity,
ShortName, Toll, and SnDecode. And of course, Truck inherits
those two class variables as well. But Truck is going to override
ShortName and override Toll both of which it is inheriting, is going to introduce a new service
called DOTLicense. It's only available for trucks. And the DOTLicense will note
via C string class variable that stored in the truck object. So, if you're a truck object, you
are starting a DOTLicense number but you're also restoring a
SerialNumber and a PassengerCapacity because you're also a vehicle. So, when you're a truck object you're
really restoring three things only one of which we mentioned
in the derived class because the other two are
inherited from the vehicle class. Now, then inherits from truck
meaning it inherits all these stuff. It also inherits from box meaning
it inherits those geometric entities associated with back up box objects. So, a Van is both a Truck
and a Box if you like. We're going to override load capacity
from the parent-- the Vehicle class. That's the LoadCapacity. And of course, we're going
to override ShortName. It's going to return VAN for Van. Similarly a Tanker is
a Truck and a Cylinder. And a Flatbed is a Truck and a Plane. [ Pause ] So, each one of these classes
should have the following, a default constructor, a
parameterized constructor that initializes the class
variables, a destructor. We're going to privatize
the copy constructor and privatize the assignment operator
prototypes and not implement that. There is a discussion of why one might
want to do this in the discussion forum. And I refer you to that place
understand what the implications are for that particular-- and over here. We're going to of course follow
the notation conventions. These are just notational
conventions that are all in our C++ style manual for the course. Now, there's an admonition here to be
sure to make exactly the methods virtual that are needed to be virtual. And those are precisely the methods that
are overridden in the derived classes. So, if a method is never overridden
it doesn't become virtual. I might add, I just remind
you that the destructors in all the classes should
be virtual as well. Now, we got a toll schedule is
minimal of $2 for all vehicles and its $10 for all trucks. That's a pretty simple toll schedule
but it's enough to give you the idea of how it would work and clearly
could be made more complicated. Now, during the development
and testing of these classes, each of the constructors and
destructor should include a line of code that sends an identifying message. So, for example the destructor for Van
would send a message till the Van paren, paren to the screen just
through standard output. And I would just tell you that the
Van destructors have been called. And later on, we'll go
and comment that out but for now you want to put those in. Now, there's this user-defined
type called VehicleType, it's an enumerator type. And that type name is of course
VehiclType and its values are badSn, vehicle car, truck, van,
tanker and flatbed. Now those-- those identifiers
there represent the actual values in the type VehicleType. So, badSn is an [inaudible]
of VehicleType, car as an [inaudible] of vehicle type. And there's only one, two, three, four,
five, six, seven items in this type. There's only seven instantiations
of that type. Now, the static method SnDecode text
the serial number and as I-- C string. And for now we're going to have a very
simple decoding mechanism just hooks with the very first character, the
zero index character of that string, which we would call SN
bracket 0, all right. And if SN bracket 0 is the character
0, that's suppose to be character by the way, then will turn badSn. If it's the character 1 or return
vehicle it's a character 2 will return car and so on up to character
6 return Flatbed. If it's any other character, you
probably would just return badSn. So, what you could do is say, OK, if
it's 1 return vehicle 2, car, 3, truck, 4, van, 5, tanker, 6, flatbed. And then make the default case in
the switch [inaudible] return badSn. So, not only will it return badSn
to 0 but for any other serial number which doesn't made the specs of
first character being 1 through 6. Now, after you've fully developed and
debugged your classes and they compile without warnings, then we're
going to create shapes, we're going to take shapes and vehicles
and concatenate them into verbose. And I will now going to log in to
linprog and show you a little bit about how some of this works. [ Noise ] OK, so [inaudible] and what I have
there is tester.x and tracker.x. And those are the client
programs that you have. Another way to-- what I wan to
do is show you how tester works. So, we're now at the
stage where we have, we think we have developed
the class that we got them at least we think they are right, we got
them at least compiling to object code. And now, what we want to
do is test those classes. I said before we begin
developing our client program. So, I'm going to create myself
another window, I put it here. Now, I'm going to show you
tester.cpp source code. So, you can say there is called
tester I wrote it, big deal. And it kind of explains what's going on. And the main thing, the
main loop goes like this. It's very much like the main loop in the
dynamic test harness that we illustrated in classes, the forth classes
chapter on polymorphism. And what we do as we-- how
to do file loop, we enter-- we prompt enter our SerialNumber,
enter x to quite. But you [inaudible] enters any serial
number and its run in as a string. If the serial character and that serial
number is X then that's how equipped this program. Otherwise, we call SerialNumber decode
on that serial number, that give us a V which is a variable of
type, VehicleType. And then we do a switch
type but on that type. And remember, vehicle,
car, truck, van, tanker, flatbed and badSn are
the types recognized in VehicleType, the type, VehicleType. So, if that is a vehicle, then we-- let's say we have a pointer
to type vehicle here, right? Then the vehicle is the base class. So, we have a pointer of the
TypeVehicle and if it is a vehicle, we make a new vehicle with the
SerialNumber that was ready and then give it a PassengerCapacity 1. If it's Car, then we make
a new car object out of that SerialNumber and
PassengerCapacity 2. If it's a truck, then we're
going to copy dot loop. I'll go back to the top
and show you this. But first we going to
make a C string called DOT and call the Truck constructor with that
SerialNumber and the PassengerCapacity of 3 and that dotLicense number. If it's a Van, we'll do the same thing
with the dotLicense and we'll do it-- make a Van object with that
SerialNumber, that PassengerCapacity, that dotLicense number and 20, 4
and 8, the dimensions of the box. If it's a tanker, we create a tanker
object with that SerialNumber, PassengerCapacity 5, that
dotLicense number of link of 40 and a radius of 3 for the tank. If it's a Flatbed, similarly
SerialNumber, PassengerCapacity, dotLicense number length
and width for the Flatbed. And finally, if it's a badSn, we're
going to make our vehicle object and give it the SerialNumber,
BadSerialNumber and 0 PassengerCapacity. Now, we should never really get here
because SnDecode, if it's correct, can only return values that our cases
for and so the default is there only to tell us if something really bad
is wrong because we're not going to ever get better if the
SnDecode is working correctly. And then what's going to happen is, OK, so what that do is create vehicle object
during run time of the program, right, and that vehicle object might be
a vehicle or car or truck, a van, a tanker, a flatbed or a vehicle with
BadSerialNumber, for that serial number. And what it does is ignore
that for the moment. It's this output of the ShortName and
we'll get to that by taking the pointer which is holding our object and
calling the ShortName method. We asked for the total and we
get that by taking the pointer and applying to the Toll method. The SerialNumber, we point to
SerialNumber method, PassengerCapacity, we point to the PassengerCapacity,
LoadCapacity. And then remember for trucks
only, we have the DOTLicense. So, if Vehicle is to the right, is
that truck or to the right of truck, you know, our numerated type. In other words, if it's a truck or a
more specialized version of the truck, then all I have to do is
dynamically cast that pointer which is a pointer to a vehicle. We have to dynamically cast it
down to a pointer to a truck which will let it know that
it's supposed to be able to have a DOTLicense function, and then
we will call that DOTLicense function. I noticed we didn't permanently
cast that pointer down. We just-- We cast it down just long
enough to make the call to DOTLicense. And so, those braces is back
to being just a pointer, the same pointer we had
before and we delete it which of course doesn't
delete the pointer itself but it deletes object and its points. And then we do it again, right? So, if the SerialNumber is
not 0, then we do it again. Now, there's a couple of subtleties
about copying strings back and forth that I'll show you later. What I want to do now is
run tester.x over here. And notice it's prompting
me for a SerialNumber, and that was right here,
a SerialNumber, OK? So, I'm going to try zero first. And remember, zero, so
that's the decode to a badSn. And so, we got the BadSerialNumber
result. Okay. The one end is supposed to decode to a normal vehicle but
with an unknown type. And so, we get-- again, unknown,
we got a PassengerCapacity. We get SerialNumber. I just entered 1 and so
that's the SerialNumber. One is supposed its Passenger Capacity
and the Load Capacity for a car of course is zero is not
a commercial vehicle. Two, we'll get a truck, I'm sorry. I'm sorry, I was thinking that was car. So, for Car, we get short amount of car,
a Toll Charge of $2, Serial Number 2, Passenger Capacity 2
and no Load Capacity. Three, we have a sort of
unknown or unspecified truck because it's a truck, its total is $10. Remember we said we're given Serial
Number 3 and Passenger Capacity 3. Because it's an unknown truck type but
still doesn't have a Load Capacity. Notice this, DOTLicense, OK. So, let me try 4 which is going to
be a van, $10 Toll, Serial Number, Passenger Capacity, Load
Capacity, DOT License OK. I want to show you something else
now that I'm into this [inaudible]. Notice that I got vehicle truck,
box, and van, constructor's calls. Those are triggered by the
new operator right here. When I create that van
object right there, that results in those
constructors calls. And so, that will happ-- should happen
in order you see them and that's because the van constructor
will have an initialization list which will call the truck
constructor first. The truck constructor will
have an initialization list and we'll call a vehicle constructor. The vehicle constructor being
a base class will then execute. And then the truck constructor
will execute. But then, Van will have a comma and call
box constructor which will then execute. And then finally, van, the
van constructor will execute. So, all four of those
constructor calls are caused by the creation of a van object. And then these are the cause to its
various functions, ShortName, Toll, SerialNumber, PassengerCapacity,
and LoadCapacity and DOTLicense. And then-- so, that was all of these
things, right, including that one. And then finally, will delete the object
and it's the deletion of the object that cause all of these destructors
and those are noticed called in the reverse order from the
way the constructors will call. So, the destructors get
called from the bottom up whereas the constructors
got called from topdown. And that's all inherit and correctly
defining the initialization list for the constructors for all
the classes in your framework. One other thing I want to show
you is how this is testing for a possible OOPSes. Notice that I have a special
snMessage and a dotMessage called OOPS, serial number not owned
by vehicle object. And notice that those get copied in
right here into SN and DOT in respect, those are our two string
C strings that we use to create a truck object for example. But notice that's happened after
the object has been created. So, if you create this,
let's say, truck object here, and then later copy something
else into that variable, that should not affect your truck object
because you've already made a copy of that SerialNumber and
that dotLicense number. You've made a copy that
the truck object owns. And so, if a client decides to
mess with his or her variable SN, that should not affect the truck
object that's been created already. On other hand, if you made a
mistake of just having a pointer to the client's C string, then on this change is made what you would
see here is you'd say an OOPS message her and an OOPS message here
instead of what you see there. So, that's a way of checking,
helping you check to be sure that you've done your
C strings correctly. Now, I should point out that we
did exactly this in Homework 3. You learned in Homework 3
how to instantiate a C string into an object with a constructor. And just briefly, first in
the initialization list, you make the pointer null or zero
and the body of the constructor, you've got about a four-step
process where you got to see how long the string is. You allocate space one
more than that length. And then, you copy all the
data from the client string into the object's own string. And however many steps that
is, that's the process. So, I'm going to quit that program and
go back to looking at our document. So, assuming you get that far that
means that you've successfully created and successfully tested your-- I want
to show you one other thing here. This-- you've tested your classes-- now,
how did I get make the verbose segment? Let me just do it quick. I'm going more out in my shapes.cpp. And just so you'll see
that I've commented out for playing this output statement. If I more have vehicles.cpp you'll see-- [ Noise ] I'm sorry, I didn't mean
to say vehicles. I have to say verbose. [ Noise ] So, was that a box we're looking at? [ Noise ] Well, box, plane whichever. For the plane constructor, we
have this output statement on-- that's active, right? And only here is doing
this and the shapes.cpp is that statement is commented
out in the shapes [inaudible] and it's not commented out
in the verbose as well. So, I recommend leaving
them uncommented both places until you completely debugged your
shapes classes because you want to make sure when you edit those
shapes class as you edit them in the source code files-- either
shapes or vehicles and not in verbose. And then, you just concatenate
shapes.cpp and vehicles.cpp into verbose.cpp to run tester again. And just kind of use that mode,
edit shapes or vehicles.cpp. Concatenate those two into verbose,
compile and run tester until you or completely convinced
everything is working right. Then you can go by and comment
out in shapes and verbose.cpp-- comment out those output statements. [ Pause ] So-- now, we go to the Client
Side which is a tracker system. What a tracker program is supposed
to do is of course we're pretending that its got a sensor and it's sitting
25 feet above the Florida Turnpike and reading, making conversations
with the transponder on the windshield of the vehicles that pass under it. Of course, we don't have
access to that hardware. So, we're simulating the
traffic by simply input. And everything here is written
with standard input and output. So, we will use file redirect to
simulate input into the tracker system. So, what tracker suppose to do
is the following, read the number of vehicles in a segment, OK. So, that's the number of vehicles
in the segment that's going to be a number in the file. If the number is zero, if there's
no vehicles in the segment exit. And then for each vehicle
in the segment, decode the vehicle serial number, if
other data is needed, read that data. Create a vehicle object
of the appropriate type. And then update various
summary information. After all vehicles in the
segment have been read and their corresponding object
created, report the summary of the various vehicles by type, along
with totals for tonnage and toll. And then finally after the summary
report show the data for each vehicle. And then finally release all the memory
used to store all those vehicles, and then go back and read
the next segment method. So, let me show you what
I found might look like. [ Pause ] And I'm still in my--
linprog login here. I'm going to get both of this up. So, what I want to show you in is what
the file segment0.data looks like. And-- so, that number there, that number1 says the segment
consists of only one vehicle. And then you read it serial
number and the first digit on the serial number is one
which tells you as a badSn, no I'm sorry, 1 tells you-- I forgot. It's an ordinary vehicle and
that's its PassengerCapacity. So, what this does is
how the segment of size 1 and instantiate exactly
one vehicle type car, first vehicle then car then truck
then van then tanker then flatbed. And finally, it has a
segment size 0 indicator which terminates the tracker program. So, I can now run tracking-- [ Noise ] -- on segment9.data. Notice I just named the executable
redirecting the file segment0.data and does simulating for
us over here in that file. It's kind of simulating
traffic on the Turnpike. And so, what you see is-- [ Pause ] -- trackers started, then
we get a segment summary and that were got only one
vehicle in that segment and it was that serial number first digit
one which was an unknown type. And doesn't have tonnage
therefore it got the minimum toll. And then here's our table
consisting of one vehicle because only one vehicle in the segment. So, the next segment has only
one item in it, it's got a car. The-- and so on down to the last segment
has only one vehicle that's a flatbed and there's its tonnage and there's
its tool and there it's summary. So, what this does is effectively
is go through the same thing that tester did one segment
for vehicle type. Now, we can do segment one that
may more have segment one for you. And segment one says, OK, I'm calling
it segment one but it's really a file of segments, segment file one. And this happens of begin with the
segment of six vehicles which has one of each type but all
in the same segment. And these are their PassengerCapacity
and so on. And let me point out a nuance here. For example, when the serial number
is 2-car, the first character in the serial number is two, that
tells you it's a car and we've kind of used the letter CAR
as so documentation. Yes, that is a serial number
of a car just for the purposes of transparency here and
that's its PassengerCapacity. OK, well, before a car and that's all
we know to read and so we stop reading. If it's a truck, then we know
it has a PassengerCapacity but also the DOTLicense number. And so, we continue reading, if we figure out it's a
truck to get the DOTLicense. If it's a Van, we get, we know to
read the PassengerCapacity for-- because its vehicle, we need-- it's
DOTLicense number because it's a truck. And we need a length, width
and height because it's a van. If it's a tanker, we
need a PassengerCapacity, DOTLicense length and radius. If it's a flatbed, we
need a PassengerCapacity, DOTLicense length and width. And by the way now there's a zero which
is the code that tells tracker, OK, the segment size zero means
I'm suppose to quit running. And so, now do that run--
so run through there. Let me clear my screen and run it again. So, I'm running tracker.x
on segment1.data. And so, the summary here was we have a
car, a truck, a van, a tanker, a flatbed and an unknown type, but in yet,
the badSns, you shouldn't expect to ever get any with us just a
little self check to make sure or something isn't going
on with our software. That's the total tonnage
which allows the total-- we're creating tonnage with area or
volume, area if it's flatbed and volume if it's tank or a van, so that's
the total tonnage for all the trucks and the total number-- the amount of
total dollars collected which was $2 for the car, $10 for the truck, and $2
for the unknown, $10 for each truck. So, there you see. And then there is-- so that
was the summary collect data. And then the segment details, these
are all vehicles in the segment, the total I paid, what
the PassengerCapacity was, what their LoadCapacity was,
what the DOTLicense number was, and what their SerialNumber was. And finally, let me look at segment
two and it has a segment of three, followed by segment of three. So, I'm going to clear on the
screen and run this for segment two. And let me just scroll this up
and you'll see how I got started. So, here's the start right
here, trackers started, right. And those are segments summary for the
first segment which had three vehicles in it, a van, a tanker and a
flatbed, a tonnage and toll. And there's a table. Then we start a new second segment
with 30 vehicles in it, all right. That starts right here and
there's the segment summary. So, I just scrolled my
screen and we get that back. So, there's the segment summary at
eight cars, three trucks, 11 vans, four tankers, three flatbeds,
one unknown. Here's the total tonnage,
there's the tolls we collected. And then here's the segment
details take in order, you know, in which we saw the vehicles. And then finally, because
of that zero right there, we turn right on our tracker
and use them to send some kind of message that says "I'm finished." And in this case, we set "Thank
you for using SunPAss tracker." So, that in a nutshell is
the way it supposed to work. I will not be able to take
questions from the class because I'm sitting among the desk. But certainly we'll take questions
in the Blackboard discussion forums and allow me to turn
this off now and see if I can turn it into
an uploadable movie.