Change search
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
!secure(system) <=?=> !safe(system): On Security and Safety of Industrial Software Systems
Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.ORCID iD: 0000-0002-1791-535x
2019 (English)Doctoral thesis, comprehensive summary (Other academic)
Abstract [en]

The focus of our research work is on readily accessible, embedded, real-time development with concurrency support. To this end, we develop the Real-Time For the Masses (RTFM) programming framework with a model of computation based on tasks and resources and that stipulates a timing semantics. Typically, hard real-time requirements are a characteristic of safety-critical applications. In contrast to runtime verification, such applications primarily require static assurances concerning safety and security attributes. This thesis discusses the building blocks for a statically analyzable programming paradigm for embedded real-time applications and its implementation. Svenska kraftnät funded the research presented in this thesis and set the scope to industrial automation. Consequently, we also investigate the applicability of our RTFM framework for scheduling and resource management for the runtime environments of industrial applications. We start by reviewing relevant and well-established industry standards to build background knowledge of the state-of-the-art safety and security requirements in software development. Special attention is placed on the IEC 61131 and IEC 61499 standards for industrial software development and their programming and execution model. We show the feasibility of using IEC 61499 as a holistic, distributed, and hierarchical model with mappings from the functional layer (IEC 61499 function block networks) and safety layer (PLCopen safety function blocks) to RTFM. We also demonstrate that our Rust-based RTFM implementation enables static verification for a myriad of safety and security attributes. Moreover, our investigations reveal a mutual dependency of safety and security in the context of software systems. For this reason, we believe and argue that safety and security cannot be considered independent during the design and implementation of safety-critical applications. Upon closer examination, we even conclude that safety and security are equivalent.

 

Place, publisher, year, edition, pages
Luleå: Luleå University of Technology, 2019.
Series
Doctoral thesis / Luleå University of Technology 1 jan 1997 → …, ISSN 1402-1544
Keywords [en]
embedded systems, hard real-time, concurrency, model of computation, safety-critical, safety, security, industrial automation, RTFM, real-time for the masses
National Category
Embedded Systems
Research subject
Embedded Systems
Identifiers
URN: urn:nbn:se:ltu:diva-73059ISBN: 978-91-7790-320-8 (print)ISBN: 978-91-7790-321-5 (electronic)OAI: oai:DiVA.org:ltu-73059DiVA, id: diva2:1292333
Public defence
2019-05-08, A3024, Luleå, 13:00 (English)
Opponent
Supervisors
Available from: 2019-03-01 Created: 2019-02-27 Last updated: 2019-09-26Bibliographically approved
List of papers
1. RTFM-4-FUN
Open this publication in new window or tab >>RTFM-4-FUN
Show others...
2014 (English)In: 2014 9th IEEE International Symposium on Industrial Embedded Systems (SIES 2014): Pisa, 18-20 June 2014, Piscataway, NJ: IEEE Communications Society, 2014Conference paper, Published paper (Refereed)
Abstract [en]

Function Blocks provides a means to model andprogram industrial control systems. The recently acclaimed IEC61499 standard allows such system models to be partitioned andexecuted in a distributed fashion. At device level, such models aretraditionally implemented onto programmable logic controllersand industrial PCs. In this paper, we discuss work in progresson developing a mapping allowing to implement a subset of IEC61499 models onto light-weight embedded devices (MCUs). Wepropose and detail an event semantics, and its mapping to thenotions of tasks and resources for Stack Resource Policy basedanalysis and scheduling. Moreover, we show how the proposedmapping can be efficiently implemented under the RTFM-kernel.Finally we outline a prototype tool-chain and discuss related,ongoing and future work.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE Communications Society, 2014
National Category
Embedded Systems Computer Sciences
Research subject
Embedded System; Dependable Communication and Computation Systems
Identifiers
urn:nbn:se:ltu:diva-31695 (URN)10.1109/SIES.2014.7087453 (DOI)5f425bf0-2a15-489b-8321-1f032143a348 (Local ID)5f425bf0-2a15-489b-8321-1f032143a348 (Archive number)5f425bf0-2a15-489b-8321-1f032143a348 (OAI)
Conference
IEEE International Symposium on Industrial Embedded Systems : 18/06/2014 - 20/06/2014
Note

Godkänd; 2014; 20141204 (maalin)

Available from: 2016-09-30 Created: 2016-09-30 Last updated: 2019-02-27Bibliographically approved
2. RTFM-core: course in compiler construction
Open this publication in new window or tab >>RTFM-core: course in compiler construction
2016 (English)In: The SIGBED Review, ISSN 1551-3688, Vol. 14, no 1, p. 29-36Article in journal (Refereed) Published
Abstract [en]

The course in Compiler Construction is part of the Computer Science masters program at Luleå University of Technology (LTU). Since the fall of 2014, the course is given by the Embedded Systems group. This paper outlines the course syllabus and its relation to CPS/IoT and embedded systems in general. In particular, the course introduces domain specific language design with the outset from the imperative RTFM-core language. Students are exposed to design choices for the language, spanning from programming model, compiler design issues, back-end tools, and even runtime environments. The intention is to give a holistic perspective and motivate the use of compilation techniques towards robust, efficient, and verifiable (embedded) software. Of course, developing basic skills is not overlooked and as part of the laboratory assignments, students extend the min-imalistic Object Oriented language RTFM-cOOre and develop the compiler accordingly targeting the RTFM-core language as an intermediate representation. As the RTFM-core/-cOOre compilers are implemented using OCaml/Men-hir, the students are also exposed to functional languages and to their advantages in the context of compiler construction. However, for their own development they may choose alternative design tools and languages. This gives us the opportunity to review and correlate achievements and efficiency to the choice of tools and languages and it is an outset for future course development.

National Category
Embedded Systems
Research subject
Embedded System
Identifiers
urn:nbn:se:ltu:diva-61641 (URN)10.1145/3036686.3036690 (DOI)
Available from: 2017-01-26 Created: 2017-01-26 Last updated: 2019-02-27Bibliographically approved
3. RTFM-core: Language and Implementation
Open this publication in new window or tab >>RTFM-core: Language and Implementation
Show others...
2015 (English)In: 2015 IEEE 10th Conference on Industrial Electronics and Applications (ICIEA): Auckland, 15-17 June 2015, Piscataway, NJ: IEEE Communications Society, 2015, p. 990-995, article id 7334252Conference paper, Published paper (Refereed)
Abstract [en]

Robustness, real-time properties and resource efficiency are key properties to embedded devices of the CPS/IoT era. In this paper we propose a language approach RTFMcore, and show its potential to facilitate the development process and provide highly efficient and statically verifiable implementations. Our programming model is reactive, based on the familiar notions of concurrent tasks and (single-unit) resources. The language is kept minimalistic, capturing the static task, communication and resource structure of the system. Whereas C-source can be arbitrarily embedded in the model, and/or externally referenced, the instep to mainstream development is minimal, and a smooth transition of legacy code is possible. A prototype compiler implementation for RTFM-core is presented. The compiler generates C-code output that compiled together withtheRTFM-kernelprimitivesrunsonbaremetal.TheRTFMkernel guarantees deadlock-lock free execution and efficiently exploits the underlying interrupt hardware for static priority scheduling and resource management under the Stack Resource Policy. This allows a plethora of well-known methods to static verification (response time analysis, stack memory analysis, etc.) to be readily applied. The proposed language and supporting tool-chain is demonstrated by showing the complete process from RTFM-core source code into bare metal executables for a lightweight ARM-Cortex M3 target.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE Communications Society, 2015
National Category
Embedded Systems
Research subject
Embedded System
Identifiers
urn:nbn:se:ltu:diva-39731 (URN)10.1109/ICIEA.2015.7334252 (DOI)2-s2.0-84960919182 (Scopus ID)e965493c-10db-44b6-9031-ca7acaf56f68 (Local ID)978-1-4799-8389-6 (ISBN)e965493c-10db-44b6-9031-ca7acaf56f68 (Archive number)e965493c-10db-44b6-9031-ca7acaf56f68 (OAI)
Conference
IEEE Conference on Industrial Electronics and Applications : 15/06/2015 - 17/06/2015
Note
Validerad; 2016; Nivå 1; 20150916 (maalin)Available from: 2016-10-03 Created: 2016-10-03 Last updated: 2019-02-27Bibliographically approved
4. End-to-End Response Time of 61499 Distributed Applications over Switched Ethernet
Open this publication in new window or tab >>End-to-End Response Time of 61499 Distributed Applications over Switched Ethernet
Show others...
2017 (English)In: IEEE Transactions on Industrial Informatics, ISSN 1551-3203, E-ISSN 1941-0050, Vol. 13, no 1, p. 287-297Article in journal (Refereed) Published
Abstract [en]

The IEC 61499 standard provides means to specify distributed control systems in terms of function blocks. For the deployment, each device may hold one or many logical resources, each consisting of a function block network with service interface blocks at the edges. The execution model is event driven (asynchronous), where triggering events may be associated with data (and seen as messages). In this paper, we propose a low complexity implementation technique allowing to assess end-to-end response times of event chains spanning over a set of networked devices. Based on a translation of IEC 61499 to RTFM1-tasks and resources, the response time for each task in the system at device-level can be derived using established scheduling techniques. In this paper, we develop a holistic method to provide safe end-to-end response times taking both intra- and inter-device delivery delays into account. The novelty of our approach is the accuracy of the system scheduling overhead characterization. While the device-level (RTFM) scheduling overhead was discussed in previous works, the network-level scheduling overhead for switched Ethernets is discussed in this paper. The approach is generally applicable to a wide range of COTS Ethernet switches without a need for expensive custom solutions to provide hard real-time performance. A behavior characterization of the utilized switch determines the guaranteed response times. As a use case, we study the implementation onto (single-core) ARMcortex based devices communicating over a switched Ethernet network. For the analysis, we define a generic switch model and an experimental setup allowing us to study the impact of network topology as well as 802.1Q quality of service in a mixed critical setting. Our results indicate that safe sub millisecond end-to-end response times can be obtained using the proposed approach.

Place, publisher, year, edition, pages
IEEE, 2017
National Category
Embedded Systems
Research subject
Embedded Systems
Identifiers
urn:nbn:se:ltu:diva-60286 (URN)10.1109/TII.2016.2626463 (DOI)000395874400029 ()2-s2.0-85013444377 (Scopus ID)
Note

Validerad; 2017; Nivå 2; 2017-02-21 (rokbeg)

Available from: 2016-11-10 Created: 2016-11-10 Last updated: 2019-02-27Bibliographically approved
5. A Real-Time Semantics for the IEC 61499 standard
Open this publication in new window or tab >>A Real-Time Semantics for the IEC 61499 standard
Show others...
2015 (English)In: Proceedings of 2015 IEEE 20th International Conference on Emerging Technologies & Factory Automation (ETFA 2015): Luxembourg, 8-11 Sept. 2015, Piscataway, NJ: IEEE Communications Society, 2015, article id 7301558Conference paper, Published paper (Refereed)
Abstract [en]

The IEC 61499 standard provides an executable model for distributed control systems in terms of interacting function blocks. However, the current IEC 61499 standard lacks appropriate timing semantics for the specification of timing requirements, reasoning on timing properties at the model level, and for the timing verification of a specific deployment. In this paper we address this fundamental shortcoming by proposing Real-Time-4-FUN, a real-time semantics for IEC 61499. The key property is the preservation of non-determinism, allowing us to reason on (and verify) timing properties at the model level without assuming any specific scheduling policy or stipulating specific order of execution for the deployment. This provides for a clear separation of concerns, where the designer can focus on properties of the application prior to, and separately from, deployment verification. The proposed timing semantics is backwards compatible to the current standard, thus allow for reuse of existing designs. The transitional property allows timing requirements to propagate to downstream sub-systems, and can be utilized for scheduling both at device and network level. Based on a translation to RTFM-tasks and resources, IEC 61499 the models can be analyzed, compiled and executed. As a proof of concept the timing semantics has been experimentally implemented in the RTFM-core language and the accompanying (thread based) RTFM-RT run-time system.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE Communications Society, 2015
Series
I E E E International Conference on Emerging Technologies and Factory Automation. Proceedings, ISSN 1946-0740
National Category
Embedded Systems Computer Sciences
Research subject
Embedded System; Dependable Communication and Computation Systems
Identifiers
urn:nbn:se:ltu:diva-36915 (URN)10.1109/ETFA.2015.7301558 (DOI)2-s2.0-84952918103 (Scopus ID)abd06064-cd7b-4d30-8ca2-a6eed13cec5b (Local ID)978-1-4673-7929-8 (ISBN)abd06064-cd7b-4d30-8ca2-a6eed13cec5b (Archive number)abd06064-cd7b-4d30-8ca2-a6eed13cec5b (OAI)
Conference
IEEE International Conference on Emerging Technologies and Factory Automation : 08/09/2015 - 11/09/2015
Note
Validerad; 2016; Nivå 1; 20150917 (maalin)Available from: 2016-10-03 Created: 2016-10-03 Last updated: 2019-02-27Bibliographically approved
6. RTFM-RT: a threaded runtime for RTFM-core towards execution of IEC 61499
Open this publication in new window or tab >>RTFM-RT: a threaded runtime for RTFM-core towards execution of IEC 61499
2015 (English)In: Proceedings of 2015 IEEE 20th International Conference on Emerging Technologies & Factory Automation (ETFA 2015): Luxembourg, 8-11 Sept. 2015, Piscataway, NJ: IEEE Communications Society, 2015, article id 7301501Conference paper, Published paper (Refereed)
Abstract [en]

The IEC 61449 standard provides an outset for designing and deploying distributed control systems. Recently, a mapping from IEC 61499 to the RTFM-kernel API has been presented. This allows predictable real-time execution of IEC 61499 applications on light-weight single-core platforms. However, integrating the RTFM-kernel (bare-metal runtime) into potential deployments requires developing device drivers, protocol stacks, and the like. For this presentation, we apply the mapping from IEC 61499 to the RTFM-MoC task and resource modelimplementedbytheRTFM-corelanguage.Thecompilation from RTFM-core can be targeted to both, RTFM-kernel and the introduced runtime system RTFM-RT. In this paper, we detail thegenericRTFM-RTruntimearchitecture,whichallowsRTFMcore programs to be executed on top of thread based environments. Furthermore, we discuss our implementation regarding scheduling specifics of Win32 threads (Windows) and Pthreads (Linux and Mac OS X). Using our RTFM-RT implementation for deployment,predictableIEC61499executiontogetherwithaccess to abovementioned operating system functions are achieved. For further developments, we discuss the needed scheduling options to achieve hard real-time and analysis required to eliminate deadlocks.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE Communications Society, 2015
Series
I E E E International Conference on Emerging Technologies and Factory Automation. Proceedings, ISSN 1946-0740
National Category
Embedded Systems
Research subject
Embedded System
Identifiers
urn:nbn:se:ltu:diva-28357 (URN)10.1109/ETFA.2015.7301501 (DOI)84952886083 (Scopus ID)221993dc-626e-4af8-a3b6-f401521965a9 (Local ID)978-1-4673-7929-8 (ISBN)221993dc-626e-4af8-a3b6-f401521965a9 (Archive number)221993dc-626e-4af8-a3b6-f401521965a9 (OAI)
Conference
IEEE International Conference on Emerging Technologies and Factory Automation : 08/09/2015 - 11/09/2015
Note
Validerad; 2016; Nivå 1; 20150917 (maalin)Available from: 2016-09-30 Created: 2016-09-30 Last updated: 2019-02-27Bibliographically approved
7. Safe tasks: run time verification of the RTFM-lang model of computation
Open this publication in new window or tab >>Safe tasks: run time verification of the RTFM-lang model of computation
2016 (English)In: 2016 IEEE 21st International Conference on Emerging Technologies and Factory Automation (ETFA): Berlin, 6-9 Sept. 2016, Piscataway, NJ: IEEE conference proceedings, 2016, article id 7733550Conference paper, Published paper (Refereed)
Abstract [en]

Embedded systems for critical applications are typicallyspecified with requirements on predictable timing andsafety. While ensuring predictable timing, the RTFM-lang (Real-Time For the Masses) model of computation (MoC) currentlylacks memory access protection among real-time tasks. In thispaper, we discuss how to safely verify task execution given aspecification using the RTFM-MoC. Furthermore, an extensionto the RTFM-core infrastructure is outlined and tested with usecases of embedded development. We propose a method for runtime verification exploiting memory protection hardware. Forthis purpose, we introduce memory resources to the declarativelanguage RTFM-core allowing compliance checks. As a proofof concept, compiler support for model analysis and automaticgeneration of run time verification code is implemented togetherwith an isolation layer for the RTFM-kernel. With this verificationfoundation, functional run time checks as well as furtheroverhead assessments are future research questions.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE conference proceedings, 2016
Series
I E E E International Conference on Emerging Technologies and Factory Automation. Proceedings, ISSN 1946-0740
National Category
Embedded Systems
Research subject
Embedded System
Identifiers
urn:nbn:se:ltu:diva-59755 (URN)10.1109/ETFA.2016.7733550 (DOI)000389524200057 ()2-s2.0-84996551916 (Scopus ID)978-1-5090-1314-2 (ISBN)978-1-5090-1313-5 (ISBN)
Conference
21st International Conference on Emerging Technologies and Factory Automation (ETFA), Berlin, 6-9 Sept 2016
Available from: 2016-10-14 Created: 2016-10-14 Last updated: 2019-02-27Bibliographically approved
8. No Panic! Verification of Rust Programs by Symbolic Execution
Open this publication in new window or tab >>No Panic! Verification of Rust Programs by Symbolic Execution
2018 (English)Conference paper, Published paper (Refereed)
Abstract [en]

The Rust language stands out with a type system and underlying memory model targeting memory safety. The accompanying rustc compiler is typically able to statically prove the safety conditions and accept or reject input programs accordingly. However, e.g., cases of raw array indexing are in general out of reach for static analysis and promoted to runtime verification rendering executables with partial correctness guarantees (aborting with a panic on safety violations). For safety-critical applications, this requires proper panic handling, which is by itself a hard problem. Moreover, runtime verification may be undesirable for performance reasons and hence calling for stronger methods to static program analysis. In this paper, we take the approach of symbolic execution and propose a generic contract based verification process for programs written in Rust. For the verified properties (assertions), the program is both safe and panic free. Besides correctness, this implies further performance improvements as code for runtime verification can be safely dropped. We demonstrate the feasibility of the approach by adopting the KLEE symbolic execution engine to analyze LLVM bitcode extracted from Rust programs and libraries under verification and discuss its implications and limitations.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE, 2018
Series
IEEE International Conference on Industrial Informatics INDIN, ISSN 1935-4576, E-ISSN 2378-363X
National Category
Computer Sciences
Research subject
Dependable Communication and Computation Systems
Identifiers
urn:nbn:se:ltu:diva-71249 (URN)10.1109/INDIN.2018.8471992 (DOI)000450180200015 ()2-s2.0-85055511267 (Scopus ID)978-1-5386-4829-2 (ISBN)978-1-5386-4830-8 (ISBN)
Conference
16th International Conference on Industrial Informatics (INDIN), Porto, Portugal, 18-20 July 2018
Available from: 2018-10-17 Created: 2018-10-17 Last updated: 2019-02-27Bibliographically approved
9. Hardware-in-the-loop based WCET analysis with KLEE
Open this publication in new window or tab >>Hardware-in-the-loop based WCET analysis with KLEE
Show others...
2018 (English)In: 2018 IEEE 23RD INTERNATIONAL CONFERENCE ON EMERGING TECHNOLOGIES AND FACTORY AUTOMATION (ETFA), Piscataway, NJ: IEEE, 2018, p. 345-352Conference paper, Published paper (Refereed)
Abstract [en]

C programming dominates the mainstream of embedded development as of today. To aid the development, hardware abstractions, libraries, kernels, and light-weight operating systems are commonplace. However, these typically offer little or no help to automatic worst-case execution time (WCET) estimation, and thus manual test and measurement based approaches remain the de facto standard. For this paper, we take the outset from the Real-Time For the Masses (RTFM) framework, which is developed to facilitate embedded software development for IoT devices and provides highly efficient implementations, suitable to the mainstream of embedded system design. Although the Rust language plays currently a minor part in embedded development, we believe its properties add significant improvements and thus implement our RTFM framework in Rust. We present an approach to worst-case execution time estimation in the context of RTFM tasks and critical sections, which renders sufficient information for further response time and schedulability analysis. We introduce our test bench, which utilizes the KLEE tool for automatic test vector generation and subsequently performs cycle accurate hardware-in-the-loop measurements of the generated tests. The approach is straightforward and fully automatic. Our solution bridges the gap in between measurement based and static analysis methods for WCET estimation. We demonstrate the feasibility of the approach on a running example throughout the paper and conclude with a discussion on its implications and limitations.

Place, publisher, year, edition, pages
Piscataway, NJ: IEEE, 2018
Series
IEEE International Conference on Emerging Technologies and Factory Automation-ETFA, ISSN 1946-0740
National Category
Computer Sciences
Research subject
Dependable Communication and Computation Systems
Identifiers
urn:nbn:se:ltu:diva-71247 (URN)10.1109/ETFA.2018.8502510 (DOI)000449334500042 ()2-s2.0-85057245110 (Scopus ID)978-1-5386-7108-5 (ISBN)
Conference
23rd IEEE International Conference on Emerging Technologies and Factory Automation (ETFA 2018) Politecnico Torino,Italy , Sep 04-07, 2018
Available from: 2018-10-17 Created: 2018-10-17 Last updated: 2019-02-27Bibliographically approved
10. Concurrent Reactive Objects in Rust Secure by Construction
Open this publication in new window or tab >>Concurrent Reactive Objects in Rust Secure by Construction
2019 (English)In: Ada User Journal, ISSN 1381-6551, Vol. 40, no 1Article in journal (Refereed) Published
Abstract [en]

Embedded systems of the IoT era face the software developer with requirements on a mix of resource efficiency, real-time, safety, and security properties. As of today, C/C++ programming dominates the mainstream of embedded development, which leaves ensuring system wide properties mainly at the hands of the programmer. We adopt a programming model and accompanying framework implementation that leverages on the memory model, type system, and zero-cost abstractions of the Rust language. Based on the outset of reactivity, a software developer models a system in terms of Concurrent Reactive Objects (CROs) hierarchically grouped into Concurrent Reactive Components (CRCs) with communication captured in terms of time constrained synchronous and asynchronous messages. The developer declaratively defines the system, from which a static system instance can be derived and analyzed. A system designed in the proposed CRC framework has the outstanding properties of efficient, memory safe, race-, and deadlock-free preemptive (single-core) execution with predictable real-time properties. In this paper, we further explore the Rust memory model and the CRC framework towards systems being secure by construction. In particular, we show that permissions granted can be freely delegated without any risk of leakage outside the intended set of components. Moreover, the model guarantees permissions to be authentic, i.e., neither manipulated nor faked. Finally, the model guarantees permissions to be temporal, i.e., never to outlive the granted authority. We believe and argue that these properties offer the fundamental primitives for building secure by construction applications and demonstrate its feasibility on a small case study, a wireless autonomous system based on an ARM Cortex M3 target.

Place, publisher, year, edition, pages
Ada Language UK Ltd., 2019
National Category
Computer Sciences
Research subject
Dependable Communication and Computation Systems
Identifiers
urn:nbn:se:ltu:diva-71246 (URN)2-s2.0-85067078450 (Scopus ID)
Note

Validerad;2019;Nivå 1;2019-04-09 (inah)

Available from: 2018-10-17 Created: 2018-10-17 Last updated: 2019-06-28Bibliographically approved

Open Access in DiVA

fulltext(14769 kB)140 downloads
File information
File name FULLTEXT01.pdfFile size 14769 kBChecksum SHA-512
c2c4f0154c9599d8e1a4085e60d9a921642d60049e8346c76569a75859235a2f6682852110da4b2646d65e1962dbb9a3fe0134f430b00dbb1a8f49e6ee935f40
Type fulltextMimetype application/pdf

Authority records BETA

Lindner, Marcus

Search in DiVA

By author/editor
Lindner, Marcus
By organisation
Computer Science
Embedded Systems

Search outside of DiVA

GoogleGoogle Scholar
Total: 140 downloads
The number of downloads is the sum of all downloads of full texts. It may include eg previous versions that are now no longer available

isbn
urn-nbn

Altmetric score

isbn
urn-nbn
Total: 1249 hits
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf