Model Based Methodology and Framework for Design and Management of Next-Gen IoT Systems
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 | 12 | |
| Author | ||
| Contributors | ||
| License | CC Attribution - ShareAlike 4.0 International: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/51307 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
00:00
Information securityModel theoryElectronic mailing listLink (knot theory)Drag (physics)Software frameworkNetzwerkverwaltungSystem programmingScherbeanspruchungUniform boundedness principleMaxima and minimaSystem programmingModel theoryInternet der DingeAreaGoodness of fitSoftware frameworkData managementUbiquitous computingScanning tunneling microscopeIntelligent NetworkUniverse (mathematics)Projective planeLink (knot theory)Solitary confinementElectric generatorSource code
01:10
System programmingComplex (psychology)Data managementKolmogorov complexityModel theoryComputing platformAbstractionConstraint (mathematics)Internet der DingeUsabilityEndliche ModelltheorieFormal grammarFormal verificationCode generationMixed realitySoftwareEmailSoftware frameworkDemonModemRepository (publishing)Modeling languageCodeComputer wormPhysicsMaxima and minimaCartesian coordinate systemPhysicalismComputing platformComponent-based software engineeringComplex (psychology)VirtualizationReal numberDifferent (Kate Ryan album)World Wide Web ConsortiumSimulationData modelLaplace transformComputerLevel (video gaming)Server (computing)Modeling languagePhase transitionValidity (statistics)TelecommunicationHash functionSystem administratorResultantFormal verificationWärmestrahlungRun time (program lifecycle phase)PeripheralSoftware frameworkModel theorySystem programmingInternet der DingeSoftware developerOrder (biology)ThetafunktionoutputService (economics)Formal languageFormal grammarPoint (geometry)CodeMixed realityConstraint (mathematics)Descriptive statisticsGroup actionTheoremAbstractionFocus (optics)SoftwareSynchronizationInteractive televisionProcedural programmingComputer animation
06:21
Model theoryModemSystem programmingInternet der DingeSoftware frameworkRepository (publishing)Modeling languageCodeDemonGamma functionEndliche ModelltheorieTwin primePhysicsEmailSoftwareEmbedded systemControl flowLinear programmingCode generationImplementationTerm (mathematics)Model theoryModeling languageLink (knot theory)Execution unitPeripheralCartesian coordinate systemConnected spaceInternet der DingeSoftwareProcess (computing)Service (economics)Data structureSoftware frameworkRun time (program lifecycle phase)MicroprocessorSystem programmingData modelRepresentation (politics)Repository (publishing)BEEPCodeFiber bundleElectric generatorGateway (telecommunications)Level (video gaming)DemosceneModul <Datentyp>Order (biology)Point (geometry)MereologySlide ruleDescriptive statisticsStandard deviationTransformation (genetics)VirtualizationFormal languageInternet service providerValidity (statistics)ThetafunktionPhysicalismOcean currentComputer animation
11:32
CodeCodierung <Programmierung>Data storage deviceRobotAreaAutomationMachine visionService (economics)RoboticsCASE <Informatik>Software frameworkService (economics)RoboticsAreaCASE <Informatik>Model theoryObservational studyQR codeData storage deviceInteractive televisionPlastikkarteIntegrated development environmentDecision tree learningDiagramComputer animation
13:10
System programmingModel theoryService (economics)RoboticsCASE <Informatik>Run time (program lifecycle phase)AerodynamicsRobotControl flowJava appletCodeLinear programmingInterface (computing)System programmingCodeCartesian coordinate systemModel theoryRoboticsInternet der DingeJava applet2 (number)Observational studyState of matterSynchronizationSource codeCASE <Informatik>MathematicsPlastikkarteConfiguration spaceLevel (video gaming)Component-based software engineeringInteractive televisionSoftwareNumberPapierloses BüroBlock (periodic table)BEEPData modelRun time (program lifecycle phase)INTEGRALComputer animationProgram flowchart
16:03
PlastikkarteAdaptive behaviorControl flowEndliche ModelltheoriePredictionPressure volume diagramInformation securityCASE <Informatik>NetzwerkverwaltungWater vaporData managementSystem programmingData managementVirtual machinePrice indexOrder (biology)Model theoryGame controllerInformation securityDecision theorySystem programmingCASE <Informatik>Water vaporAdaptive behaviorComputer animation
17:19
Control flowSystem programmingTwin primeDigital signalAdaptive behaviorIntegrated development environmentModel theoryState of matterEndliche ModelltheorieSimulationNetzwerkverwaltungCASE <Informatik>Water vaporMachine learningSoftware bugSoftware frameworkCodeSoftwareService (economics)Representation (politics)Modeling languageOSI modelSet (mathematics)Point (geometry)Group actionoutputCorrespondence (mathematics)Internet der DingeMereologyModel theoryVirtual machineSystem programmingEnterprise architectureDatabaseAlgorithmMeasurementSoftwareOperations support systemCartesian coordinate systemGame controllerSoftware frameworkRun time (program lifecycle phase)Slide ruleLevel (video gaming)Term (mathematics)Case moddingMultiplication signCodeUniverse (mathematics)Code division multiple accessWorkloadOrder (biology)Validity (statistics)Complex (psychology)Descriptive statisticsElectric generatorAsynchronous Transfer ModeFunctional (mathematics)ThetafunktionControl systemPeripheralConstraint (mathematics)Ocean currentGateway (telecommunications)Modeling languageAdaptive behaviorComplex systemContent (media)World Wide Web ConsortiumComputer animation
24:21
Programmer (hardware)Link (knot theory)Content (media)Software frameworkRun-time systemReal-time operating systemLattice (order)Multiplication signControl flowOnline chatSolitary confinementRun time (program lifecycle phase)Order (biology)Computer animation
25:22
Model theoryRun time (program lifecycle phase)PrototypeRight angleOrder (biology)Configuration spaceMathematicsSoftware frameworkSystem programmingInternet der DingeComputer animation
Transcript: English(auto-generated)
00:00
We have one last paper for this modeling session. It's going to be presented by Shu Tao. So, Shu Tao is a researcher of the IoT and pervasive technologies area from the LINZ Foundation, which is located in Torino, Italy. She will be presenting today a paper called
00:23
Model-Based Methodology and Framework for Design and Management of Next-Generation IoT Systems. Okay. Good afternoon, everyone. I'm Shu Tao from LINZ Foundation. Now I'm going to present a model-based methodology and framework
00:42
for design and management of next-generation IoT systems. And this work has been done within the scope of the EU 2020 project, Bring IoT. And thanks for the contributors from LINZ Foundation,
01:02
C.A. Simmons, STM, and the University of Grenoble. Nowadays, with emerging and more complex scenarios in IoT domain, it introduced many challenges, such as the communication between the
01:25
different IoT platforms, and consequently, the IoT system management and the monitoring become harder and harder. As a result, the complexity of the IoT applications development has been increased dramatically.
01:45
What's more, the cost-efficient requirements and the physical constraints of the IoT system validation is becoming a harsh issue. So, to cope with these hardships, we proposed a model-based engineering approach
02:06
to ease the development of the IoT systems. And in this approach, it offers first is a modeling methodology based on different abstraction layers,
02:20
and then it enables the IoT service composition to support the interoperability among the data engineers' systems. And a formal verification and validation of the models is also supported.
02:41
There is also a code generator to automatically generate the application artifacts in such a way to ease the development phase of the IoT application developers. And in the end, we also provide a co-simulation approach,
03:02
which is enabled to monitor the IoT device and with the mixed virtual and real entities at runtime. So, the modeling methodology we proposed is shown in this slide.
03:21
And as you can see here, we have three different abstraction levels. From high to low, there is the system models, which focus on the IoT services composability provided by the IoT devices.
03:44
And then this model can be refined as software models, which is the formal component models and to provide the computing capabilities of the components to validate the applications
04:06
and before deploying it. It also enables to visualize the physical devices, so there is also the possibility to develop these virtual IoT physical device models
04:26
in order to validate the system before deploying in a real infrastructure. So, based on this methodology, we have designed this modeling and verification framework.
04:43
In this framework, there are four main components. The first one is the reality modeling language. And here we have the system modeling language, the software modeling language, and also the physical layer modeling language.
05:00
Each of the language is corresponding to each abstraction layer. Just one point to be highlighted here is in the system modeling language, and we can model the interaction behaviors, the procedure behaviors, as well as the event-based behaviors.
05:25
And the system modeling language is extended to be integrated with the W3C standards is the SYNC description, which aims to describe the IoT services provided by the IoT platforms.
05:44
And this language is also extended to synchronize with the SYNC model. As a reminder, the SYNC is an industrial getaway for different IoT devices and to provide the APIs
06:03
to the upper layer applications. And then the second component is the reality modeling tool. In this modeling tool, we have the Theta model, which will take the Theta modeling language as input and generate these Theta level models. And these models will be refined
06:29
by the syntactical transformation to the software models. And another model is the physical device model, which is enabled to
06:45
develop with virtual IoT devices. And these software models will pass through the code generator, and this generator will generate the software artifacts to be stored in this
07:06
artifacts repository. And on the other hand, the code generator also provides the capability to generate the monitoring description. And this modeling description is ready to be
07:24
deployed to the IoT getaways and in order to provide the features, like the monitor at runtime features. All the models created developed by the modeling language
07:44
and they are reusable, will be eventually stored in the modeling language. So it will be easier to retrieve, to search, and also to update. So in order to implement such a framework, we adopted the technologies as shown in this
08:05
picture. Starting from the Theta level models, we used the IoT ML model, which can be modeled leveraging the Papyrus modeling tool. So from the left side, you can see this model provided
08:25
the possibility to refine this Theta model to the BIP model. And the BIP model is the representation of the software level models, and it provides the capability for the formal
08:46
validation of the models. And from the right side, we can see the IoT ML model is enabled to generate and also synchronize with the data model used by the IoT getaways. And in this way,
09:09
from the model, we can monitor and also control the behaviors of the IoT devices. And here, since we will generate the software artifacts from the BIP model and the software
09:27
artifacts here will be Java-based and also will be packaged as the OSGI bundles. And this is because leveraging the OSGI, we can adopt features like modularity
09:45
and also the dynamic deployment. And the third point here is from the model, and it is extended to generate a same description, which is compliant with W3C
10:06
standard. So by this link, we can link the IoT device service with concrete models we modeled here as a high-level model. And in the two models of IoT physical devices,
10:26
and we leverage the work from our partner, from ST, and as shown in the lower part of the slides. And in this model, we have a microprocessor unit, and it is implemented using the current
10:50
text for STM32. And it can take the data from the sensors and process it and also
11:01
foment the structure of the data. And here there is another unit, is to provide the connectivity towards the outside world. And this connectivity enables the upper layer applications to train the data from this simulated model.
11:25
So how our approach and the framework is used in the real scenario. And here I'm going to give two use case studies to illustrate how this modeling framework can be used in the
11:46
real infrastructure. And the first one is based in the scenario of service robotics. And as shown in the diagram here, and here the scenario is we have a
12:01
warehouse, and in the warehouse we have a loading area and the storage area. In the loading area, we have a fleet of robots and also a couple of carts. And the carts is waiting to be carried by the robots and to unload data in the storage area. And within the way towards to the storage
12:28
area, and the robots have to pass through the door. So here it includes the interaction between our robots and the environment like the door. We can see it as the blockage
12:46
of the environment. And just to be more clear and the robot is equipped with a camera and it can scan the QR code on the cart and also on the door. So to implement this such
13:10
a system, and we are starting from the LTML system models, and we modeled the
13:22
there is an OTS street is to control the overall behaviors and of the door of the robots. And then we defined the interface of the interactions between each component. And this system models, and as mentioned before, and it will be refined as more
13:48
as the software level components models, which is a BIP model. And then pass through the Java code generator and we can get the functional code of the OTS street, the door, and also the
14:05
robots. And then we wrapping this plain Java code and as the OSGF bundles, and to be deployed in the real infrastructure. So, and the user block, the upper block, and it demonstrates,
14:24
and there is this approach, and is to ease the work of the IoT application developers. And instead of from scratching all the source code, and we can leverage a model-based approach.
14:45
And then at one time, after the generated artifacts is running in the real infrastructure, and here and in the left, we can see, and by integrating with the papyrus modeling tool,
15:03
and the status of the robot can be monitored and at runtime, and we can visualize the status change of the robot from one state to another state. And in the other side, by the integrating
15:23
with synchronize with the system data model, and we can monitor to initialize the configuration of the warehouse map. For example, we can configure the coordinates of the robots,
15:41
of the cards, and of the destination of each card. And in the other side, and we also can control the robots, and how many robots will be in a fleet, like the robot numbers, and it can be dynamically changed. And the second use case study is based on a critical
16:08
water infrastructure, management infrastructure, and here this use case is based on the city water supply, which is a partner from Columbia in Spain. And the goal is to develop an
16:27
adaptive smart, automatic, controllable management system, and this system will be leveraging some machine learning, like the predictable models, and to first increase the
16:44
security of the water supplies. And then we also aim to optimize the underlying cost, as the last goal is to give them more accurate indicators for the decision-making.
17:04
And for example, like the also provide us some adaptive control behaviors, and in order to react to some abnormal situations. And here in this slide, and there it shows
17:24
the system architecture, and as we can see here, and at first there is the end device, and the end device is like the sensors, which is giving the measurements, and these
17:43
measurements will pass through the travel from the network, and then stored in a database. And then the data will be analyzed by using an analyze detection algorithm, and in order to
18:03
detect the abnormal measurements, and in order to give the warnings to the operators. But here since we aim to use our approach, and to design and implement a control system,
18:23
so this part will be no more manually, but it will be automatically to realize the resilience control. And this control system will give the commands to the actuators, like the pumps, like the valves, and to open and close, and in order to
18:45
make the current abnormal situation, to reduce the damage of the current abnormal situation. So in this system architecture, how can we modeling framework helps? Here we have three
19:05
main contributions in this architecture, and the first point is before we like develop all the IoT applications, and then since we have to use the machine learning
19:25
technology, and to train the model for the anomalous detection, but due to the physical device constraints, and we cannot collect such a big amount of data, and in order to train
19:43
this model, so we use our modeling approach, and to model the IoT devices, and in order to generate the reliable data, and in order to train this model as the input data set.
20:00
And the second point here is this control system, and we developed the data using the brain IoT system models, and in order to model these adaptive behaviors, and then we analyzed the possible abnormal situations, and then also identified the corresponding
20:30
reactor actions, and so we could use our model, and to model this control system. And then the second, the third, last point is after the system is running, and we are also
20:48
intended, we also have the value to know what's the current status of your critical device, like the valves, and you want to know how much data is open now, all the pumps,
21:05
and what's the status of it now, and so by integrating this device, and with the gateway, and we are able to supervise the current values, the current status of such kind of
21:22
critical device. So this is how our proposed modeling approach can be used in the real industrial systems, and how can we like to easier our work in such critical and also complex
21:44
systems. So just to be conclude, and our work, in this work, and we propose the model-based methodology, and the framework is to aim to help for the next generation IoT systems.
22:07
And first, the system-level models, which is to capture the system functionalities and behaviors in order to refine the software modeling, and also through these system-level
22:24
models, and we can create a comprehensive system, and also universe the modeling languages. And the second point is by integrating with the W3C description, we can link our model to the
22:54
upland in the IoT device, and it can be dynamically linked towards this real device.
23:03
And the third point is that leveraging this code generator, and we can simply reduce the workload of the IoT application developers, and the system application validation, it can help
23:23
the end user to reduce first the physical infrastructure like the device budget cost, and then it also can guarantee the safety of your system before deploying your
23:44
applications in the real infrastructure to avoid some possible damage and directly to your physical device, and especially in the critical infrastructures. And the last but not the least
24:01
features is the model at runtime, and leveraging this approach, and we can remotely visualize and also control the IoT device runtime status. Okay, this is all the contents
24:25
for this work, and thanks for your attention. If you have some questions, you can ask. Okay, we are just six minutes late, but I think we managed to
24:44
sustain time, so if someone from the audience has any questions, please just put them in the chat. Since this is the last session, we will have the breakout session also here, so there's no need for you to switch to meetings. So, what we can do now is we can – well,
25:05
since we already had this talk, I do have a question, Shu. I don't know if I understood correctly, but this runtime environment you have in this framework is for monitoring, right? For monitoring in real time. Have you thought about extending this runtime in order to also
25:28
execute – I don't know – modify the system somehow? Yeah, actually, I know now by the modeling framework now, and leveraging these IoT ML data
25:43
models, and the final goal is not only to monitor the status, but we also aim to prototype the behaviors, and directly to push these behavior models in the remote device. So,
26:03
there might be some more like a runtime configuration change, and now we are working on this aspect, and to control it directly from the model. Okay, so the idea is that you actually implement this feature, right? Yes. Yes.