[ad_1]
Introduction
This weblog submit represents the second entry in a sequence on utilizing General Gear Effectiveness (OEE) with AWS IoT SiteWise. On this submit, we are going to do a deep dive on find out how to calculate OEE utilizing AWS IoT SiteWise native capabilities to gather, retailer, rework, and show calculations as an end-to-end answer. We’ll take a look at a Baggage Dealing with System (BHS) positioned at an airport as a use case for instance the method. Please, first learn half 1 of this sequence, Industrial General Gear Effectiveness (OEE) information with AWS IoT SiteWise, for extra context on the use case.
Moreover, we are going to present how one can automate OEE parts to streamline the implementation of this answer in lots of different use instances, like manufacturing manufacturing traces in pharmaceutical, meals and beverage industries. That will help you put into follow the ideas introduced on this weblog, we additionally present a code repository that allows you to stream artificial information to AWS IoT SiteWise to create an OEE dashboard utilizing the calculations introduced right here.
Use case
Earlier than diving deep into the OEE calculations, let’s outline the instance we will probably be utilizing as a body of reference. Our instance is a BHS and the required information factors for an OEE calculation are gathered from the put in {hardware} on the BHS within the carousel. The {hardware} consists of 4 sensors: two vibration sensors for motor monitoring, one velocity sensor for conveyor surveillance, and one picture electrical sensor counting the luggage throughput.
The structure of the answer is as follows:
Sensor information is collected and formatted through CloudRail, an AWS Companion whose answer significantly simplifies the gathering and streaming of IIoT information to AWS IoT SiteWise. This integration is configurable by the CloudRail administration Portal immediately. The structure contains further elements for making the sensor information obtainable to different AWS providers by an S3 bucket.
AWS IoT SiteWise pre-requisites
Earlier than sending information to AWS IoT SiteWise, you could create a mannequin and outline its properties. As talked about earlier, we’ve got 4 sensors that will probably be grouped into one mannequin, with the next measurements (information streams from gear):
Mannequin:Carousel
Asset Title: CarouselAsset
Property {
Measurement: Photograph.Distance
Measurement: Velocity.PDV1
Measurement: VibrationL.Temperature
Measurement: VibrationR.Temperature
}
Along with the measurements, we are going to add a couple of attributes (static information) to the asset mannequin. The attributes symbolize completely different values that we want within the OEE calculations.
Mannequin:Carousel
Asset Title: CarouselAsset
Property {
Attribute: SerialNumber
Attribute: Photograph.distanceBase
Attribute: Photograph.distanceThold
Attribute: Velocity.max_speed_alarm
Attribute: Velocity.min_speed_alarm
Attribute: Vibration.max_temp_c_alarm
Attribute: Ideal_Run_Rate_5_min
}
Now, let’s go to the and create the Carousel mannequin and asset that symbolize the airport BHS.
Open the navigation menu on the left, select Construct, Fashions, after which select Create Mannequin to outline the attributes and measurements for this mannequin:
For extra data on creating asset fashions go to the documentation.
Calculating OEE
Let’s check out the OEE definition and its elements.
The usual OEE method is:
Element | Formulation |
Availability | Run_time/(Run_time + Down_time) |
High quality | Successes / (Successes + Failures) |
Efficiency | ((Successes + Failures) / Run_Time) / Ideal_Run_Rate |
OEE | Availability * High quality * Efficiency |
Let’s take a look at the parameter definition for the BHS. For a full description of OEE parameters please go to the documentation.
- Ideal_Run_Rate: In our case, the best run fee is 300 baggage/hour, which is equal to 0.83333 baggage/second. This worth relies on the system and must be obtained from the producer or primarily based on discipline remark efficiency.
Availability
Availability = Run_time/(Run_time + Down_time)
We’ve got 4 sensors on the BHS and we have to outline what measurements (temperature, vibration, and so forth.) from the sensors we need to embody within the calculation. The temperature coming from the 2 vibration sensors (in Celsius) and the velocity of the carousel coming from the velocity sensor (m/s) will dictate the provision state.
The appropriate values for proper operation are primarily based on the next attributes of the Asset Mannequin.
Vibration.max_temp_c_alarm = 50
Velocity.min_speed_alarm = 28
Velocity.max_speed_alarm = 32
Let’s outline Equipment_State, an information rework that gives the present state of the BHS in numerical code:
1024 – The machine is idle
1020 – A fault, like an irregular operation of the system, excessive temperature or a velocity worth not throughout the regular vary outlined
1000 – A deliberate cease
1111 – A standard operation
The idle state of the BHS isn’t outlined on this simplified use case, nonetheless, it’s doable to combine different information streams into AWS IoT SiteWise and register data coming from Programmable Logic Controllers (PLCs) or different programs the place a human operator dictates if the system is idle or not.
So as to add a rework, go to the mannequin on the AWS IoT SiteWise console and select Edit. Scroll to the rework definitions and supply a Title, Knowledge kind (Double) and enter the next method on the respective discipline:
Equipment_state =
if((Velocity.PDV1>Velocity.max_speed_alarm) or (Velocity.PDV1<Velocity.min_speed_alarm) or (VibrationL.Temperature>Vibration.max_temp_c_alarm) or (VibrationR.temperature>Vibration.max_temp_c_alarm),1020).elif(eq(Velocity.PDV1,0),1000,1111)
The method ought to seem like this as you enter it within the console. The UI will deliver solutions so that you can choose attributes and measurements already outlined within the mannequin to construct the method.
As soon as Equipment_State is outlined, create the next derived transforms to seize the completely different states of the BHS. Transforms can reference different transforms.
Proceed to outline the next metrics to combination machine information over time. Hold the identical interval for every metric.
Fault_Time = statetime(Fault) – The machine’s complete fault time (in seconds)
Stop_Time = statetime(Cease) – The machine’s complete deliberate cease time (in seconds)
Run_Time = statetime(Working) – The machine’s complete time (in seconds) operating with out problem.
Down_Time = Idle_Time + Fault_Time + Stop_Time – The machine’s complete downtime
The metric definitions of the mannequin ought to seem like this:
High quality
High quality = Successes / (Successes + Failures)
Right here, we have to outline what constitutes successful and a failure. On this case our unit of manufacturing is a counted bag, so how can we outline when a bag is counted efficiently and when it’s not? we use the measurements and information which might be obtainable from the BHS’s 4 sensors.
The luggage are counted by trying on the distance the picture electrical sensor is offering, due to this fact when there’s an object passing the band, the sensor will report a distance that’s much less that the “base” distance. This can be a easy strategy to calculate the baggage passing, however on the identical time it’s vulnerable to a number of situations that may influence the accuracy of the measurement.
We use these mannequin attributes on the standard calculation:
Photograph.distanceBase = 108
Photograph.distanceThold = 0.1
The Photograph.distanceBase is the gap reported by the sensor, when there are not any objects in entrance of it. This worth may have to be calibrated frequently and adjusted, components like vibration and misalignment can result in false optimistic counts.
Photograph.distanceThold is used for outlining a threshold for the way delicate is the sensor, with a view to keep away from counting particles or small objects (like bag attachments or belts) as a daily bag.
We then set up two transforms for bag depend:
Bag_Count = if(Photograph.Distance < Photograph.distanceBase,1,0)
Dubious_Bag_Count = if((gt(Photograph.Distance,Photograph.distanceBase*(1-Photograph.distanceThold)) and lt(Photograph.Distance,Photograph.distanceBase*0.95)) or (Velocity.PDV1>Velocity.max_speed_alarm) or (Photograph.Distance>Photograph.distanceBase),1,0)
Bag_count will account for all baggage passing in entrance of the picture electrical sensor, and Dubious_Bag_Count will depend the objects detected as baggage beneath two irregular situations:
- The gap detected is throughout the vary of 95% and 90% of the bottom distance; accounting for small objects and really small variations within the measurements, indications of modifications resulting from vibration or a sensor not correctly connected.
- Baggage counted when the velocity of the carousel is above the restrict outlined; beneath this situation the sensor can miss counting baggage which might be too shut collectively on the carousel.
NOTE: the above situations are easy guidelines and the appropriate values for distance base and thresholds have to be reviewed and analyzed with discipline information for higher outcomes.
Let’s outline successes and failures as metrics:
Successes = sum(Bag_Count) – sum(Dubious_Bag_Count)
Failures = sum(Dubious_Bag_Count)
Lastly we will outline OEE Availability as a metric as properly:
High quality = Successes / (Successes + Failures)
Keep in mind to make use of the identical metric interval as in all different metric definitions.
Efficiency
Efficiency = ((Successes + Failures) / Run_Time) / Ideal_Run_Rate
We’ve got Successes and Failures from our High quality calculation, in addition to Run_Time from Availability. Subsequently, we simply want to make use of the Ideal_Run_Rate_5_min, which in our system is 300 baggage/hour = 0.0833333 baggage/second.
OEE Worth
Having Availability, High quality, and Efficiency we proceed to outline our final metric for OEE.
OEE = Availability * High quality * Efficiency
Simplify transforms and metric definitions
As a substitute, the OEE elements outlined as transforms and metrics might be outlined programmatically as a substitute of utilizing the AWS Console. That is significantly helpful when there are advanced formulation that contain a number of variables, just like the Equipment_State and Dubious_Bag_Count transforms; additionally, automated options are much less error inclined than handbook ones and might be configured constantly throughout a number of environments. Let’s check out how we will do it utilizing the AWS SDK for Python (Boto3).
First, establish the measurements and attributes property IDs that you’ll be referencing on the rework/metric calculation, in addition to the mannequin ID.
Then outline a JSON for the metric/rework. For example, to create a brand new rework to calculate the Equipment_State of the BHS we want the next attributes:
Vibration.max_temp_c_alarm
Velocity.max_speed_alarm
Velocity.min_speed_alarm
And the next measurements:
VibrationL.Temperature
VibrationR.Temperature
Velocity.PDV1
Create a file following this construction. Keep in mind to interchange the propertyIds and put it aside as equipment_state.json:
{
"title": "Equipment_State",
"dataType": "DOUBLE",
"kind": {
"rework": {
"expression": "if((var_speedpdv1>var_speedmax_speed_alarm) or (var_speedpdv1<var_speedmin_speed_alarm) or (var_vibrationltemperature>var_vibrationmax_temp_c_alarm) or (var_vibrationrtemperature>var_vibrationmax_temp_c_alarm),1020).elif(eq(var_speedpdv1,0),1000,1111)",
"variables": [
{
"name": "var_vibrationrtemperature",
"value": {
"propertyId": "b9554855-b50f-4b56-a5f2-572fbd1a8967"
}
},
{
"name": "var_vibrationltemperature",
"value": {
"propertyId": "e3f1c4e0-a05c-4652-b640-7e3402e8d6a1"
}
},
{
"name": "var_vibrationmax_temp_c_alarm",
"value": {
"propertyId": "f54e16fd-dd9f-46b4-b8b2-c411cdef79a2"
}
},
{
"name": "var_speedpdv1",
"value": {
"propertyId": "d17d07c7-442d-4897-911b-4b267519ae3d"
}
},
{
"name": "var_speedmin_speed_alarm",
"value": {
"propertyId": "7a927051-a569-41c0-974f-7b7290d7e73c"
}
},
{
"name": "var_speedmax_speed_alarm",
"value": {
"propertyId": "0897a3b4-1c52-4e80-80fc-0a632e09da7e"
}
}
]
}
}
}
The principle expression is as follows:
if((var_speedpdv1>var_speedmax_speed_alarm) or (var_speedpdv1<var_speedmin_speed_alarm) or (var_vibrationltemperature>var_vibrationmax_temp_c_alarm) or (var_vibrationrtemperature>var_vibrationmax_temp_c_alarm),1020).elif(eq(var_speedpdv1,0),1000,1111)
Receive the script update_asset_model_sitewise.py and extra particulars on find out how to stream information to AWS IoT SiteWise by visiting this public repository.
Then, run the next script passing the mannequin ID and the title of the file beforehand outlined.
#python3 update_asset_model_sitewise.py --assetModelId [Asset Model ID] --property_file [JSON File defining the new property] --region [AWS Region]
After the script returns a profitable response, the brand new property ID created might be obtained immediately from the AWS Console as described earlier than or by utilizing the AWS CLI to question the up to date mannequin definition and the jq utility to filter the end result.
#aws iotsitewise describe-asset-model --asset-model-id [model ID] | jq .'assetModelProperties[] | choose(.title=="Equipment_State_API")'.id
You’ll be able to then repeat the method with the opposite transforms and metrics with a view to create all of the required elements for the OEE calculation.
For extra data on updating an AWS IoT SiteWise asset mannequin please go to the API reference.
Conclusion
On this weblog submit, we explored how we will use sensor information from a real-life situation to calculate OEE and get insightful data from our bodily system by utilizing AWS IoT SiteWise native capabilities. We walked by the method of figuring out the obtainable information and we outlined the weather that represent the primary OEE parts, Availability, High quality and Efficiency, to lastly take a deep dive into the calculations and the way we will automate them.
As a name to motion, we invite you to take the content material introduced right here additional, making use of the OEE calculation course of to your personal use instances, in addition to utilizing the automation instruments supplied to simplify and streamline the creation of knowledge that helps monitor your industrial programs with accuracy.
Within the occasion you don’t have obtainable information to make use of, we encourage you to observe the steps outlined on this public repository to simply attempt AWS IoT SiteWise with artificial information and uncover the insightful data OEE can provide you.
Concerning the Authors
[ad_2]