Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State

Programming complex embedded systems involves reasoning through intricate system interactions along paths between sensors, actuators and control processors. This is a time-consuming and error-prone process. Furthermore, the resulting code generally lacks modularity and robustness. Model-based progra...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Williams, Brian C., Ingham, Michel D.
Format: Buchkapitel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 524
container_issue
container_start_page 508
container_title
container_volume 2470
creator Williams, Brian C.
Ingham, Michel D.
description Programming complex embedded systems involves reasoning through intricate system interactions along paths between sensors, actuators and control processors. This is a time-consuming and error-prone process. Furthermore, the resulting code generally lacks modularity and robustness. Model-based programming addresses these limitations, allowing engineers to program by specifying high-level control strategies and by assembling common-sense models of the system hardware and software. To execute a control strategy, model-based executives reason about the models “on the fly”, to track system state, diagnose faults and perform reconfigurations. This paper describes the Reactive Model-based Programming Language (RMPL) and its executive, called Titan. RMPL provides the features of synchronous reactive languages within a constraint-based modeling framework, with the added ability of being able to read and write to state variables that are hidden within the physical plant.
doi_str_mv 10.1007/3-540-46135-3_34
format Book Chapter
fullrecord <record><control><sourceid>proquest_pasca</sourceid><recordid>TN_cdi_pascalfrancis_primary_14614444</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>EBC6413329_452_529</sourcerecordid><originalsourceid>FETCH-LOGICAL-p1844-ffd659f3612ad9db5756ae614d3eed23b2f9f35ad600b20ff8678e394294884a3</originalsourceid><addsrcrecordid>eNpFkDtPAzEQhM1TRCE95TWUDrbXjzNdiMJDAoEI1JYv9oXA3TnYlyL_HgciMc1qd2a2-BC6oGRMCVFXgAUnmEsKAoMBfoBGWpWQj783dYgGVFKKAbg--vc4ZUQcowEBwrBWHE7RgEkmSwVanaFRSp8kC6gWTA3Q-1NwvsE3NnlXvMSwjLZtV93yupiGro-hafJSzNrKO5cT823qfZuKalu8eptCt3MnVdj0xf0qJ7pi3tven6OT2jbJj_ZziN5vZ2_Te_z4fPcwnTziNS05x3XtpNA1SMqs064SSkjrJeUOvHcMKlZnV1gnCakYqetSqtKD5kzzsuQWhujy7-_apoVt6mi7xSqZdVy1Nm4NzaR4Vs6N_3IpW93SR1OF8JUMJWbH2oDJ6MwvV7NjnQt8_ziG741PvfG7xsJnJrZZfNh172MyklMApg0XzAim4Qc7PXtH</addsrcrecordid><sourcetype>Index Database</sourcetype><iscdi>true</iscdi><recordtype>book_chapter</recordtype><pqid>EBC6413329_452_529</pqid></control><display><type>book_chapter</type><title>Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State</title><source>Springer Books</source><creator>Williams, Brian C. ; Ingham, Michel D.</creator><contributor>Hentenryck, Pascal Van ; Van Hentenryck, Pascal</contributor><creatorcontrib>Williams, Brian C. ; Ingham, Michel D. ; Hentenryck, Pascal Van ; Van Hentenryck, Pascal</creatorcontrib><description>Programming complex embedded systems involves reasoning through intricate system interactions along paths between sensors, actuators and control processors. This is a time-consuming and error-prone process. Furthermore, the resulting code generally lacks modularity and robustness. Model-based programming addresses these limitations, allowing engineers to program by specifying high-level control strategies and by assembling common-sense models of the system hardware and software. To execute a control strategy, model-based executives reason about the models “on the fly”, to track system state, diagnose faults and perform reconfigurations. This paper describes the Reactive Model-based Programming Language (RMPL) and its executive, called Titan. RMPL provides the features of synchronous reactive languages within a constraint-based modeling framework, with the added ability of being able to read and write to state variables that are hidden within the physical plant.</description><identifier>ISSN: 0302-9743</identifier><identifier>ISBN: 9783540441205</identifier><identifier>ISBN: 3540441204</identifier><identifier>EISSN: 1611-3349</identifier><identifier>EISBN: 9783540461357</identifier><identifier>EISBN: 3540461353</identifier><identifier>DOI: 10.1007/3-540-46135-3_34</identifier><identifier>OCLC: 262687397</identifier><identifier>LCCallNum: QA76.758</identifier><language>eng</language><publisher>Germany: Springer Berlin / Heidelberg</publisher><subject>Applied sciences ; Computer science; control theory; systems ; Exact sciences and technology ; Hide State ; Mode Estimation ; Physical Plant ; Plant State ; Programming theory ; Start Location ; Theoretical computing</subject><ispartof>Lecture notes in computer science, 2002, Vol.2470, p.508-524</ispartof><rights>Springer-Verlag Berlin Heidelberg 2002</rights><rights>2003 INIST-CNRS</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><relation>Lecture Notes in Computer Science</relation></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Uhttps://ebookcentral.proquest.com/covers/6413329-l.jpg</thumbnail><linktopdf>$$Uhttps://link.springer.com/content/pdf/10.1007/3-540-46135-3_34$$EPDF$$P50$$Gspringer$$H</linktopdf><linktohtml>$$Uhttps://link.springer.com/10.1007/3-540-46135-3_34$$EHTML$$P50$$Gspringer$$H</linktohtml><link.rule.ids>309,310,779,780,784,789,790,793,4050,4051,27925,38255,41442,42511</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&amp;idt=14614444$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><contributor>Hentenryck, Pascal Van</contributor><contributor>Van Hentenryck, Pascal</contributor><creatorcontrib>Williams, Brian C.</creatorcontrib><creatorcontrib>Ingham, Michel D.</creatorcontrib><title>Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State</title><title>Lecture notes in computer science</title><description>Programming complex embedded systems involves reasoning through intricate system interactions along paths between sensors, actuators and control processors. This is a time-consuming and error-prone process. Furthermore, the resulting code generally lacks modularity and robustness. Model-based programming addresses these limitations, allowing engineers to program by specifying high-level control strategies and by assembling common-sense models of the system hardware and software. To execute a control strategy, model-based executives reason about the models “on the fly”, to track system state, diagnose faults and perform reconfigurations. This paper describes the Reactive Model-based Programming Language (RMPL) and its executive, called Titan. RMPL provides the features of synchronous reactive languages within a constraint-based modeling framework, with the added ability of being able to read and write to state variables that are hidden within the physical plant.</description><subject>Applied sciences</subject><subject>Computer science; control theory; systems</subject><subject>Exact sciences and technology</subject><subject>Hide State</subject><subject>Mode Estimation</subject><subject>Physical Plant</subject><subject>Plant State</subject><subject>Programming theory</subject><subject>Start Location</subject><subject>Theoretical computing</subject><issn>0302-9743</issn><issn>1611-3349</issn><isbn>9783540441205</isbn><isbn>3540441204</isbn><isbn>9783540461357</isbn><isbn>3540461353</isbn><fulltext>true</fulltext><rsrctype>book_chapter</rsrctype><creationdate>2002</creationdate><recordtype>book_chapter</recordtype><recordid>eNpFkDtPAzEQhM1TRCE95TWUDrbXjzNdiMJDAoEI1JYv9oXA3TnYlyL_HgciMc1qd2a2-BC6oGRMCVFXgAUnmEsKAoMBfoBGWpWQj783dYgGVFKKAbg--vc4ZUQcowEBwrBWHE7RgEkmSwVanaFRSp8kC6gWTA3Q-1NwvsE3NnlXvMSwjLZtV93yupiGro-hafJSzNrKO5cT823qfZuKalu8eptCt3MnVdj0xf0qJ7pi3tven6OT2jbJj_ZziN5vZ2_Te_z4fPcwnTziNS05x3XtpNA1SMqs064SSkjrJeUOvHcMKlZnV1gnCakYqetSqtKD5kzzsuQWhujy7-_apoVt6mi7xSqZdVy1Nm4NzaR4Vs6N_3IpW93SR1OF8JUMJWbH2oDJ6MwvV7NjnQt8_ziG741PvfG7xsJnJrZZfNh172MyklMApg0XzAim4Qc7PXtH</recordid><startdate>2002</startdate><enddate>2002</enddate><creator>Williams, Brian C.</creator><creator>Ingham, Michel D.</creator><general>Springer Berlin / Heidelberg</general><general>Springer Berlin Heidelberg</general><general>Springer</general><scope>FFUUA</scope><scope>IQODW</scope></search><sort><creationdate>2002</creationdate><title>Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State</title><author>Williams, Brian C. ; Ingham, Michel D.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-p1844-ffd659f3612ad9db5756ae614d3eed23b2f9f35ad600b20ff8678e394294884a3</frbrgroupid><rsrctype>book_chapters</rsrctype><prefilter>book_chapters</prefilter><language>eng</language><creationdate>2002</creationdate><topic>Applied sciences</topic><topic>Computer science; control theory; systems</topic><topic>Exact sciences and technology</topic><topic>Hide State</topic><topic>Mode Estimation</topic><topic>Physical Plant</topic><topic>Plant State</topic><topic>Programming theory</topic><topic>Start Location</topic><topic>Theoretical computing</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Williams, Brian C.</creatorcontrib><creatorcontrib>Ingham, Michel D.</creatorcontrib><collection>ProQuest Ebook Central - Book Chapters - Demo use only</collection><collection>Pascal-Francis</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Williams, Brian C.</au><au>Ingham, Michel D.</au><au>Hentenryck, Pascal Van</au><au>Van Hentenryck, Pascal</au><format>book</format><genre>bookitem</genre><ristype>CHAP</ristype><atitle>Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State</atitle><btitle>Lecture notes in computer science</btitle><seriestitle>Lecture Notes in Computer Science</seriestitle><date>2002</date><risdate>2002</risdate><volume>2470</volume><spage>508</spage><epage>524</epage><pages>508-524</pages><issn>0302-9743</issn><eissn>1611-3349</eissn><isbn>9783540441205</isbn><isbn>3540441204</isbn><eisbn>9783540461357</eisbn><eisbn>3540461353</eisbn><abstract>Programming complex embedded systems involves reasoning through intricate system interactions along paths between sensors, actuators and control processors. This is a time-consuming and error-prone process. Furthermore, the resulting code generally lacks modularity and robustness. Model-based programming addresses these limitations, allowing engineers to program by specifying high-level control strategies and by assembling common-sense models of the system hardware and software. To execute a control strategy, model-based executives reason about the models “on the fly”, to track system state, diagnose faults and perform reconfigurations. This paper describes the Reactive Model-based Programming Language (RMPL) and its executive, called Titan. RMPL provides the features of synchronous reactive languages within a constraint-based modeling framework, with the added ability of being able to read and write to state variables that are hidden within the physical plant.</abstract><cop>Germany</cop><pub>Springer Berlin / Heidelberg</pub><doi>10.1007/3-540-46135-3_34</doi><oclcid>262687397</oclcid><tpages>17</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0302-9743
ispartof Lecture notes in computer science, 2002, Vol.2470, p.508-524
issn 0302-9743
1611-3349
language eng
recordid cdi_pascalfrancis_primary_14614444
source Springer Books
subjects Applied sciences
Computer science
control theory
systems
Exact sciences and technology
Hide State
Mode Estimation
Physical Plant
Plant State
Programming theory
Start Location
Theoretical computing
title Model-Based Programming: Controlling Embedded Systems by Reasoning About Hidden State
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-06T08%3A24%3A40IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_pasca&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=bookitem&rft.atitle=Model-Based%20Programming:%20Controlling%20Embedded%20Systems%20by%20Reasoning%20About%20Hidden%20State&rft.btitle=Lecture%20notes%20in%20computer%20science&rft.au=Williams,%20Brian%20C.&rft.date=2002&rft.volume=2470&rft.spage=508&rft.epage=524&rft.pages=508-524&rft.issn=0302-9743&rft.eissn=1611-3349&rft.isbn=9783540441205&rft.isbn_list=3540441204&rft_id=info:doi/10.1007/3-540-46135-3_34&rft_dat=%3Cproquest_pasca%3EEBC6413329_452_529%3C/proquest_pasca%3E%3Curl%3E%3C/url%3E&rft.eisbn=9783540461357&rft.eisbn_list=3540461353&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=EBC6413329_452_529&rft_id=info:pmid/&rfr_iscdi=true