Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications

Publikation: Beitrag in FachzeitschriftKonferenzaufsatz in FachzeitschriftForschungPeer-Review

Autoren

  • Daniel Gritzner
  • Joel Greenyer

Organisationseinheiten

Forschungs-netzwerk anzeigen

Details

OriginalspracheEnglisch
Seiten (von - bis)153-158
Seitenumfang6
FachzeitschriftProcedia Manufacturing
Jahrgang24
Frühes Online-Datum6 Juli 2018
PublikationsstatusVeröffentlicht - 2018
Veranstaltung4th International Conference on System-Integrated Intelligence: Intelligent, Flexible and Connected Systems in Products and Production, 2018 - Hannover, Deutschland
Dauer: 19 Juni 201820 Juni 2018

Abstract

Cyber-physical systems can be found in many areas, e.g., manufacturing, health care or smart cities. They consist of many distributed components cooperating to provide increasingly complex functionality. The design and development of such a system is difficult and error-prone. To help engineers overcome these challenges we created a formal, scenario-based specification language. Short scenarios, i.e., event sequences, specify requirements and the desired behaviors by describing how components may, must, or must not behave. Scenarios provide an intuitive way for creating formal assume-guarantee (GR(1)) specifications, giving engineers easy access to simulation, for validating the specified behavior, and controller synthesis, for creating controller software which is correct by construction. In this paper we present an approach for generating Programmable Logic Controller (PLC) code from a scenario-based specification. Previous code generation efforts, including our own, created large, verbose source files causing some tools, e.g., compilers or editors, to perform slowly or even become unresponsive. Our new approach creates compact files, shifting significant amounts of code from executable instructions to data, to reduce the burden on the compiler and other tools. The generated code is efficient and introduces minimal to no latency between the occurrence of an event and the system's reaction to it.

ASJC Scopus Sachgebiete

Ziele für nachhaltige Entwicklung

Zitieren

Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications. / Gritzner, Daniel; Greenyer, Joel.
in: Procedia Manufacturing, Jahrgang 24, 2018, S. 153-158.

Publikation: Beitrag in FachzeitschriftKonferenzaufsatz in FachzeitschriftForschungPeer-Review

Gritzner D, Greenyer J. Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications. Procedia Manufacturing. 2018;24:153-158. Epub 2018 Jul 6. doi: 10.1016/j.promfg.2018.06.046, 10.15488/3816
Gritzner, Daniel ; Greenyer, Joel. / Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications. in: Procedia Manufacturing. 2018 ; Jahrgang 24. S. 153-158.
Download
@article{9559fba4c8614087a8b7b82ad3725f92,
title = "Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications",
abstract = "Cyber-physical systems can be found in many areas, e.g., manufacturing, health care or smart cities. They consist of many distributed components cooperating to provide increasingly complex functionality. The design and development of such a system is difficult and error-prone. To help engineers overcome these challenges we created a formal, scenario-based specification language. Short scenarios, i.e., event sequences, specify requirements and the desired behaviors by describing how components may, must, or must not behave. Scenarios provide an intuitive way for creating formal assume-guarantee (GR(1)) specifications, giving engineers easy access to simulation, for validating the specified behavior, and controller synthesis, for creating controller software which is correct by construction. In this paper we present an approach for generating Programmable Logic Controller (PLC) code from a scenario-based specification. Previous code generation efforts, including our own, created large, verbose source files causing some tools, e.g., compilers or editors, to perform slowly or even become unresponsive. Our new approach creates compact files, shifting significant amounts of code from executable instructions to data, to reduce the burden on the compiler and other tools. The generated code is efficient and introduces minimal to no latency between the occurrence of an event and the system's reaction to it.",
keywords = "assume-guarantee specification, code generation, controller synthesis, programmable logic controller, scenarios",
author = "Daniel Gritzner and Joel Greenyer",
note = "Funding information: This research is funded by the DFG project EffiSynth.; 4th International Conference on System-Integrated Intelligence: Intelligent, Flexible and Connected Systems in Products and Production, 2018 ; Conference date: 19-06-2018 Through 20-06-2018",
year = "2018",
doi = "10.1016/j.promfg.2018.06.046",
language = "English",
volume = "24",
pages = "153--158",

}

Download

TY - JOUR

T1 - Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications

AU - Gritzner, Daniel

AU - Greenyer, Joel

N1 - Funding information: This research is funded by the DFG project EffiSynth.

PY - 2018

Y1 - 2018

N2 - Cyber-physical systems can be found in many areas, e.g., manufacturing, health care or smart cities. They consist of many distributed components cooperating to provide increasingly complex functionality. The design and development of such a system is difficult and error-prone. To help engineers overcome these challenges we created a formal, scenario-based specification language. Short scenarios, i.e., event sequences, specify requirements and the desired behaviors by describing how components may, must, or must not behave. Scenarios provide an intuitive way for creating formal assume-guarantee (GR(1)) specifications, giving engineers easy access to simulation, for validating the specified behavior, and controller synthesis, for creating controller software which is correct by construction. In this paper we present an approach for generating Programmable Logic Controller (PLC) code from a scenario-based specification. Previous code generation efforts, including our own, created large, verbose source files causing some tools, e.g., compilers or editors, to perform slowly or even become unresponsive. Our new approach creates compact files, shifting significant amounts of code from executable instructions to data, to reduce the burden on the compiler and other tools. The generated code is efficient and introduces minimal to no latency between the occurrence of an event and the system's reaction to it.

AB - Cyber-physical systems can be found in many areas, e.g., manufacturing, health care or smart cities. They consist of many distributed components cooperating to provide increasingly complex functionality. The design and development of such a system is difficult and error-prone. To help engineers overcome these challenges we created a formal, scenario-based specification language. Short scenarios, i.e., event sequences, specify requirements and the desired behaviors by describing how components may, must, or must not behave. Scenarios provide an intuitive way for creating formal assume-guarantee (GR(1)) specifications, giving engineers easy access to simulation, for validating the specified behavior, and controller synthesis, for creating controller software which is correct by construction. In this paper we present an approach for generating Programmable Logic Controller (PLC) code from a scenario-based specification. Previous code generation efforts, including our own, created large, verbose source files causing some tools, e.g., compilers or editors, to perform slowly or even become unresponsive. Our new approach creates compact files, shifting significant amounts of code from executable instructions to data, to reduce the burden on the compiler and other tools. The generated code is efficient and introduces minimal to no latency between the occurrence of an event and the system's reaction to it.

KW - assume-guarantee specification

KW - code generation

KW - controller synthesis

KW - programmable logic controller

KW - scenarios

UR - http://www.scopus.com/inward/record.url?scp=85050378697&partnerID=8YFLogxK

U2 - 10.1016/j.promfg.2018.06.046

DO - 10.1016/j.promfg.2018.06.046

M3 - Conference article

AN - SCOPUS:85050378697

VL - 24

SP - 153

EP - 158

JO - Procedia Manufacturing

JF - Procedia Manufacturing

SN - 2351-9789

T2 - 4th International Conference on System-Integrated Intelligence: Intelligent, Flexible and Connected Systems in Products and Production, 2018

Y2 - 19 June 2018 through 20 June 2018

ER -