So every PI System is concerned with taking data from items and things and measurements that are
important to you, and getting them to you and the people around you. So to start this off,
let's say you, you own things out there, like you own a building or you rent a
building. And you own equipment, like you have tanks or you own equipment like stuff
that runs and takes electricity like a pump or something. Or any collection of these things,
they're things that you own and there's things about them that we want know, so,
over here there are people, this is you and your peers, and they wanna know stuff,
they wanna know things like to see a chart and to be able to do some analysis on maybe
the running time of the pump or what's the RPM of it. Or maybe someone wants to see a
spreadsheet report of the production data for that tank. Or maybe somebody wants to see what
the temperature has been like in the building and get a notification if it goes too hot.
So these are things we want to be able to deliver about the stuff that we own and the
stuff that we are concerned about. Now how do we get those things connected to
each other? Well there is one video on the servers and the hardware that's in
between there that is actually delivering this in the PI System. But what I'm going to talk
about in this video is how do we organize this in the PI System? How do we kind of organize
the database that represents this data and makes it available to the end users? OK,
so that's going to be in three parts. There's PI Assets, There's PI Asset Attributes and there's PI
Tags. And those three things will be the building blocks for how we organize data in the PI System.
So, we're going to start off with PI Assets. Or, perhaps to be a little more precise, PIAF Assets.
So this is something from the asset framework (that's AF). And the first step in representing
this data that we can use over there, is to take the items that we have and represent them in our
database. And that's what we do in PIAF database. We actually take these concrete items and we just
give them digital representations. We just give it a little spot in the database for the building,
and you could say we represent it with a little block. Sometimes, this is how it appears in
OSIsoft products. And maybe we have a tank and we represent that by a little block and this
is this just represents, in our database, tank. And maybe we have one for our pumps. And it has
a little element as well And then, when one of our users logs on to one of the OSIsoft products,
they're able to see these different spots in the database and that represents a building.
It's pretty straightforward and you've probably seen a lot of tree structures that are organized
like this. Often a building will then have things inside of it like, maybe each floor and then each
floor will have a set of rooms on it. And we can organize the whole hierarchy of how the different
pieces of the building fit together and then users can look at that tree and browse it. And all they
need to know is, how the building is organized. They don't even need to anything particularly
about the depth of the PI System. OK, so that's PI AF Assets. It's a way of defining an item,
a thing, that's either a concrete thing or maybe some organization like, the maintenance
organization could be a asset that we own. Sometimes, this is also called an element but,
we're going to use the word asset for now but if you hear the element we're also referring to this.
So the next step in actually delivering data to these guys so that they can use it is that
we need to have something to grab or, something to chart. Right now I can't just chart pump and
I can't just chart tank That's an item, it's not a stream of data. So, the next thing is we need
to have some way of describing this asset so this tank has things about it that are of interest and
we would call those all, attributes. Attributes. PIAF Attributes. Now an attribute is something
that describes an asset. So, for example, for the building maybe one thing would have is,
the temperature. Because the temperature is very important in a building like that.
Another attribute of a building a room maybe, would be the square footage. So how big is
the building? How big is the floor plan? For a tank, we might be interested in something like
what's the capacity? So what's the capacity of the tank? We might also be interested in,
what's the height of the tank? Like how full is the tank right now? That would be something of
interest. For something like a pump maybe we are interested in what's the rotations per minute of
the pump right now? We might be interested in the install date. So when was the last time..
I'm going to draw a little wrench here for the last time that we did some maintenance on it.
So when was the calendar date that we last did maintenance on this pump? So these are
all attributes that describe something important about an asset. That's what an attribute is,
it describes something important about our asset. And an attribute is something that
we could actually put into a spreadsheet or put into a graph. Or put into an email. They are all
things like that. That's what a PI attribute is, that's what a PI asset is. And this can
actually be represented in the PI System. When you go in and you find an AF structure or asset,
you can find an attribute. And they have a variety of different types that we could use.
We can have ones that refer to just the constant value. So something like the capacity,
that's just the constant value for this tank. It's set, it never changes. It's
just a constant value. So we can have constants. We can also have something that is a formula.
So it's the result of a calculation and the result of the calculation is the attribute.
So perhaps the height here is the result of a calculation. Or not the height but
the volume. If we also had an attribute that was the volume, something like the volume,
well the volume is going to be the height multiplied by the circle area on top. So we
get a cylindrical volume. Well that volume is going to be the result of a formula.
Also we can have data references, so table look-ups. And this is where we might access
some other database. So say that there was a maintenance database, we want to access when it
was last maintained, we can pull this data in from an outside database. Then it's a table look-up
versus a formula that's actually calculated within the PI System. And then lastly and perhaps most
notably for the PI System is something called a PI point. And a PI point is the super duper storage
point for the PI System that stores real time data, also known as a PI tag which I'll talk about
in just one moment. So a PI point, PI tag, they are the same thing. So PI attributes can be a big
variety of things and one of them in particular is this, a PI tag, which is some way of storing real
time data. It's a way of storing data in real time. So PI tags are always probably usually
going to be graphable. It's like you could take a PI tag and graph it against time somehow. And
it might be of different types of values. Maybe there are some that are digital state sets against
time. There is some that are slowly ramping up against time. But they are all against time.
That's the super power of PI tags and it really is what makes the PI System extremely powerful.
PI tags can be referenced against time. Now PI tags, because they are such a core piece of the
PI System and really they are what is classically what the PI System was built on for decades,
PI tags. And now we have attributes to be able to bring in all sorts of
other data that really isn't time based. Constants don't change over time. So just
having PI tags was limited. But now with PI AF attributes, we can include formulas, constants,
table look-ups and things like that. And we can bring in data changing against time right here
with a PI tag. Now PI tags can come in different data types, they can come in .. we can just have a
decimal place. We also might call this a floating point number. They can be integers. They can be
boolean. We can have something called a blob a binary object. There are different levels of
floating point and integers. They can be string values. And they can be digital states. So red,
blue, green etc. So all of this data stored against time, that's what a PI tag is.
PI tags also have a few particular attributes of their own that describe the PI tag. One is a
name. Every PI tag on a PI server has a name. It's a unique string name and if you are ever searching
for PI tags, often you search for it based on the PI tag name. So there is a tag name. There is also
something called a point source which often refers to where the data is coming from. There are a few
other attributes as well including a description. So we can have a description for all us humans to
know what this tag is recording. So what we are really interested in with the PI tag is
connecting it to the data. So in our items that we own, we have sensors that are actually recording
stuff like a temperature in a building or some kind of height sensor for a tank. Or some kind
of RPM gauge for a pump. And the way this works is then those sensors are sent over to a PI tag where
they enter a PI server and they are stored as a PI tag. And then that PI tag is forwarded onto
the PI attributes -- so the temperature up here, the RPMs of the pump, the height of the tank.
And then that's sent onto the user through PI AF. And the user can do really great things like for
instance here, he could compare the rotations per minute of the pump over the last 3 months.
So maybe the average or the peak running state of the pump against when it was last maintained.
And you couldn't do this before because these are from different systems and that's difficult
because that's in that system and this is in the PI System and bringing them together
would take a lot of manual collection. And that's what the PI System excels at,
taking data from anywhere and putting it together and then getting it to anywhere
else. And it does that through PI assets, PI attributes and PI tags. It allows you
to scale out your system to a wide degree. Now once you have this setup, you can go places.
Once you have a PI asset configured and you have attributes configured for it,
guess what? You can just copy and paste that asset to create another one. So say I own 500 pumps,
well I can create just one pump asset with a set of attributes and a set of
PI tags for it. And then just copy and replicate that PI asset using something
called template. So we replicate that PI asset and now we can make all of our pumps
available to all of our users very easily just like we could with the first one.
So that's an overview of the basics of PI assets,
PI attributes and PI tags and their attributes and what describes them.