We are going to start by opening up
PI System Management Tools. That's called PI SMT.
You will find it under Program Files, PI
System, and this is called PI System
Management Tools. Now, we are going here because we
start in the Module Database. And this is where the Module Database
Editor is found. And I will choose,
under the SMT Menu, Operation
and then Module Database. I will
make this a little bigger. Now, if we traverse
through the Module Database, this is our -- well, our Asset
Database for tracking assets or
give you a kind of a, an asset-based view
and navigation tool for your system. And what we want to do
is we want to make this a
Reactor there, a Batch Reactor.
Now you will notice in the Learning Lab environment, we already have
configured Reactor 3, this module, to be a PI Unit Module.
Now, we -- that's what we are trying to do here in this
first step. We are trying to take an existing module, and we are going to
convert it to a module that will be used for Batch, and
with that assignment, it's also aware
how we are going to associate the Unit Name with these Batches
and also the Aliases that are associated with those
Batches. Now, it's already been done in your environment.
So, let me demonstrate how you would do it if you did not have this environment.
This is an exact duplicate of Reactor 3.
It's got Concentration, Temperature, or Tank Level and
Temperature as Aliases, but it has not been configured
yet to be a PI Unit Module.
Now we do that by choosing to edit it
and just setting this Is PI Unit switch.
By turning that on, what it does is it
indicates that we are going to be using this for Batch Records.
That's our first step.
Now, a second step is to just
take a look around and see what the different tools are that you can use with
Batch. So, we are going to be concentrating on Reactor 3.
Notice that if we go into this section here on
Interfaces -- whoops, wrong place -- into this section
on Batch, we can
take a look at the Batch Generator Applet
and with that Batch Generator Applet, we can also search for
these units. So, you can see, this,
this MDB view gives
us a view of the Module Database. We could actually have created
these modules right here, and then cre... created them
as PI Batch Modules through this Interface.
However, if you are interested in creating these Aliases, you do
have to do that in the Module Database Editor.
Our next step is to set up
something that we are calling the
Configuration Module Name for the
PIBaGen Interface in general. Now, this is something that only needs
to be one -- done once. It needs to be done up here
at the top of the -- at this Batch Generator
section. It only needs to be done once for
a Server, not once per unit. So
once for each Server, you would need to set up this --
it's the Configuration Module Name
and it's done at the root level of
this, this Module Database
View or under Registered Units.
These two tabs are two different ways of looking at
the configuration of units
for tracking Batches. But, in either
case, you choose this top level
and this is where you go -- or this is how
you then go in, specify this Configuration
Module Name. So, what is the
Configuration Module Name? Well, simply put, it's the
name that we are going to assign to
a module that's created in each Registered Batch Unit
to store the PIBaGen configuration
for that Unit. So let me demonstrate.
See, if we go back to our Module Database here --
I mentioned earlier that this has already been
set up in this particular exercise,
but it has not been registered yet.
Once we register this
PI Unit Module here, once we register
that, you are going to notice that there's a brand new
hierarchy organized underneath this Reactor
3 South. That hierarchy is
going to be named PIBaGen. It's going to be named
a Module PIBaGen and then there will be Aliases underneath
that. That's where we store the configuration
information for PIBaGen for
this particular PI Unit
Module. So, what have we done by
naming this PIBaGen? Well, it simply means that
that's going to be the name of the module that we
create in each PI Unit Batch that will contain
the configuration information for this particular interface.
And, as I mentioned, it only needs to be done
once per PI Server. Now, in the
case of the Learning Lab environment, it's already been done so you
do not need to do that. And, I hope it's not
belaboring the obvious, but just to illustrate what I am talking about,
let's take a look at our existing Registered Units.
If I go into the Module Database and look for these
Digesters, you should see
underneath them there is a Module called --
well, no surprise, it's called PIBaGen.
So, that's what we are talking about. We are naming the name
that it will be assigned to this Module, and
there will be a Module called that name for each
one of these units, and that Module is used,
it's used by the PIBaGen Interface
to actually specify those things that need
to be specified for how it's generating these Batches.
Let's
move on now to actually define
this new Reactor 3
South. Let's define what type of Batch
Records we are going to get. This first thing we need to
specify is the name of the Active
Point. This is going to be the Trigger Tag whose
val -- whose value changes will trigger when
a Batch starts and when that Batch ends. Now, notice
that I am working within a section called PIUnitBatches.
We also support SubBatches and
just PIBatches gen...in general. You know, this is a
lower on the hierarchy. This is higher on the hierarchy.
We are going to, in this example, use PIUnitBatches.
And so let's configure this the way it's shown
in your step-by-step Solution and in your,
in your Approach. We are going to use the Tag BA:
Active.1.
Now, I could just as easily, instead of typing it in like that, I could
have just gone out, using the Tag Search, looked for all
the tags that begin with the letter BA, and
found that active tag. Now, this is a tag
that takes an Active and an Inactive State. It goes
Active when there's -- when a Batch starts. It goes
Inactive when the Batch stops. So, that's
what we would call Pulse Behavior. It's going to go
Active and, and that's
the Batch; Inactive, and No Batch. Now, that,
that's different than something that might be sig... for example, like a Batch
ID in which each time the Batch ID changes,
it increments a new Batch or it indicates
a new Batch. That would be a Step Tag. So, we are going to choose
Pulse in this case, and let's just
fill out the rest of these. These are going to be the tags
whose value will be interrogated at the time
that this Active Tag triggers. So, when
the Active Tag triggers, we evaluate the names, or the
values of the tags that we place here, and then
it's those values that will we put -- we will put into
the Batch Records. So, the
ones we had chose here -- we have a BA:
BatchID that we have set up
in this Learning Lab environment. We also have a
BA:ProductName.
That's going to be what we get for the Product Name. And
for the Procedures, BA:Recipe.
Now, like when you work with most pieces of software,
there's all kinds of bells and whistles you can choose here.
So let's take a look at some of them. First of all, there's an
Evaluation Delay. What this means is, is, in
seconds, we will delay from the
triggering of the Active Tag until we actually evaluate
these, these, the values of these tags.
So, for example, if the Active Tag triggers
but you want to give it 15 seconds for these values to become up-to-date,
then you can just put the number 15 here.
Well, in this case, we do not want that. We are just going to be using zero.
Now, compare that to this:
Evaluate at the End of Each Unit Batch. What
this will do is, if it's chosen, then
we do not assign Batch Pro... ID, Product
Name, etc., anytime during when the Batch
is running. It's only when the Batch ends that we will
interrogate the value of this and assign the,
the appropriate values.
Now, this Merge Consecutive
here, when turned On, what this means is
if you have, for example --
well, let's say you have a, a tag that goes Active and then
it becomes Inactive.
So you would think that the Batch is over, right? But, actually, the
Batch is just paused, and then it goes Active again
without any of the values in these tags changing.
If that happens in, specifically, the Batch ID,
when Merge Consecutive is turned on, we will simply assume
that that is a -- that those two Batches that
would show up as two Batches, are, in fact, one Batch that just had a
pause in the middle. I am not going to use that in this example.
And this just controls the verbosity of how many
debug messages you, you might get. Now, I am also
going to choose a Recovery Option that says we are going to recover
all PIBatch Objects
going back one day.
Now, what this means -- and I can also specify
PIBatches and PIUnitBatches. Now, I think for this
example, I will go ahead and choose PIUnitBatches as well.
What we should see is when we
first register this, this is going to go back and actually
look at the -- or interrogate
the old data and then generate Batch Records
that would have triggered if this had been configured,
you know, going back one day. Now, I am pretty sure we are not
going to get great results in this particular example, as my
particular virtual machine's only been running about an hour. But we
should be able to generate some Unit Batches, and
depending on, you know, how long your une -- your virtual machine's
been running here, you may or may not see any results
there. So that
concludes the configuration that's required for this,
the PIUnitBatches.
Next up is to do some configuration for
[inaudible] SubBatch information.