Defeasible Logic on an Embedded Microcontroller

Defeasible logic is a system of reasoning in which rules have exceptions, and when rules conflict, the one that applies most specifically to the situation wins out. This paper reports a successful application of defeasible logic to the implementation of an embedded control system. The system was programmed in d-Prolog (a defeasible extension of Prolog), and the inferences were compiled into a truth table that was encoded on a low-end PIC microcontroller.Advantages of defeasible logic include conciseness and correct handling of the passage of time. It is distinct from fuzzy logic and probabilistic logic, addressing a different set of problems.     

Implementation of Hard Real-Time Embedded Control Systems

Although the domain of hard real-time systems has been thoroughly elaborated in the academic sphere, embedded computer control systems –- being an important component in mechatronic designs –- are seldom dealt with consistently. Often, off-the-shelf computer systems are used, with no guarantee that they will be able to meet the requirements specified. In this paper, a design for embedded control systems is presented. Particularly, the paper deals with the hardware architecture and design details, the operating system, and high-level real-time language support. It is shown how estimates of process run-times necessary for schedulability analysis can be acquired on the basis of deterministic behavior of the hardware platform.     

An Embedded Microprocessor for Intelligent Control

The conventional approach for the implementation of the knowledge base of a planning agent, on an intelligent embedded system, is solely of software nature. It requires the existence of a compiler that transforms the initial declarative logic program, specifying the knowledge base, to its equivalent procedural one, to be programmed to the embedded systems microprocessor. This practice increases the complexity of the final implementation (the declarative to sequential transformation adds a great amount of software code for simulating the declarative execution) and reduces the overall systems performance (logic derivations require the use of a stack and a great number of jump instructions for their evaluation). The design of specialized hardware implementations, which are only capable of supporting logic programs, in an effort to resolve the aforementioned problems, introduces limitations in their use in applications where logic programs need to be intertwined with traditional procedural ones in a desired application. In this paper, we exploit HW/SW codesign methods to present a microprocessor, capable of supporting hybrid applications using both programming approaches. We take advantage of the close relationship between attribute grammar (AG) evaluation and knowledge engineering methods to present a programmable hardware parser that performs logic derivations and combine it with an extension of a conventional RISC microprocessor that performs the unification process to report the success or failure of logic derivations. The extended RISC microprocessor is still capable of executing conventional procedural programs, thus hybrid applications can be implemented. The presented implementation increases the performance of logic derivations for the control inference process (experimental analysis yields an approximate 1000% – 10 times increase in performance) and reduces the complexity of the final implemented code through the introduction of an extended C language called C-AG that simplifies the programming of hybrid procedural-declarative applications.     

Towards the uniform implementation of declarative languages

Current implementation techniques for functional languages differ considerably from those for logic languages. This complicates the development of flexible and efficient abstract machines that can be used for the compilation of declarative languages combining concepts of functional and logic programming. We propose an abstract machine, called the JUMP-machine, which systematically integrates the operational concepts needed to implement the functional and logic programming paradigm. The use of a tagless representation for heap objects, which originates from the Spineless Tagless G-machine, supports the integration of different concepts. In this paper, we provide a functional logic kernel language and show how to translate it into the abstract machine language of the JUMP-machine. Furthermore, we define the operational semantics of the machine language formally and discuss the mapping of the abstract machine to concrete machine architectures. We tested the approach by writing a compiler for the functional logic language GTML. The obtained performance results indicate that the proposed method allows to implement functional logic languages efficiently.     

Effective incorporation of function into logic

During the last decade, the integration of functional and logic languages has received widespread attraction for the purpose of offering two different programming styles in one system simultaneously. The main goal is to incorporate the characteristics of the two paradigms coherently, without degrading the performance of the whole system. However, few languages have achieved this goal. Some of them, even though they have a rich set of functions, perform poorly. Others are efficient, but lose some important facilities. The paper proposes a functional logic language Lazy Aflog and its abstract machine FWAM-II as an expressive and efficient mechanism for this incorporation. Lazy Aflog is an extension of logic language in which functions are reduced in the extended unification, called E-unification with lazy evaluation. This extended unification allows Lazy Aflog to process infinite data structures and higher-order functions naturally. FWAM-II is an extension of the Warren Abstract Machine (WAM) in which the instructions and run-time structures to provide the suspension/reactivation of functional closure are added. These facilities enable FWAM-II to support not only resolution but also infinite data structures and higher-order functions efficiently. In addition, the experimental results show that Lazy Aflog and FWAM-II could be a good compromise between expressiveness and efficiency of the integration.     

用Keil C51开发大型嵌入式程序

结合在8051系列单片机平台上的实际开发应用的经验，介绍用Keil C在8051单片机上进行大型嵌入式程序开发的技术。主要阐述了大型嵌入式开发中在存储器的管理、动态内存的使用、C语言调用汇编语言和程序调试方面的知识，并就所遇到的问题提出相应的解决方法。     

高职高专嵌入式C程序设计课程教学探讨

随着计算机技术和微电子技术的迅速发展,嵌入式系统应用领域越来越广泛,人才供不应求。如何合理、高效地培养嵌入式人才已迫在眉睫。作者经过多年的嵌入式C程序设计课程教学探索与实践,就高职高专学生特点,对该课程教学内容的选取、教学方法及教学实践等方面提出了一些见解。     

A Rewriting Logic Approach to Operational Semantics (Extended Abstract)

This paper shows how rewriting logic semantics (RLS) can be used as a computational logic framework for operational semantic definitions of programming languages. Several operational semantics styles are addressed: big-step and small-step structural operational semantics (SOS), modular SOS, reduction semantics with evaluation contexts, and continuation-based semantics. Each of these language definitional styles can be faithfully captured as an RLS theory, in the sense that there is a one-to-one correspondence between computational steps in the original language definition and computational steps in the corresponding RLS theory. A major goal of this paper is to show that RLS does not force or pre-impose any given language definitional style, and that its flexibility and ease of use makes RLS an appealing framework for exploring new definitional styles.     

C51在单片机嵌入式系统中的应用

介绍了用 C语言开发单片机时所遇到的问题 ,以 Franklin为例 ,介绍了 C5 1在 80 5 1系列单片机嵌入式系统中的使用技巧。提出了用 ASM5 1与 C5 1结合起来混合编程的新方法 ,在 C5 1语言不便处理或效率较低时调用汇编函数 ,另一种是用汇编识别 C5 1函数 ,开发出的系统更易维护 ,可靠性高 ,移植性强。     

使用UML和C语言实现基于对象的嵌入式软件开发

针对C 语言难以在低端嵌入式系统项目中应用的情况，对嵌入式系统软件开发中基于对象的方法进行了研究，提出了一种使用UML和C语言设计和开发嵌入式软件的实用方法。实践证明，该方法很好地融合了UML和C语言的优点，能够大大提高嵌入式软件的开发效率和可维护性。     

A System for Translating Executable VDM Specifications into Lazy ML

This article describes the process of developing a system for translating VDM executable specifications into Lazy ML prototypes. The system was specified in VDM and a Lazy ML prototype implementation was derived from its specification. This article concentrates on discussing the lessons learned in each stage of the development process, evaluating the adequacy of the used methodology. © 1997 by John Wiley & Sons, Ltd.     

Iconic languages: Towards end-user programming of mobile applications

After tracing the steps that led to the current generation of iconic languages starting from the original idea of S.K. Chang, we describe an iconic language, named MicroApp, for modeling pervasive mobile applications directly on the mobile device. MicroApp exploits generalized icons for composing mobile applications: services are represented by icons and are composed of adopting colors for representing data-flow. We also qualitatively evaluate the visual environment that implements this iconic language.     

基于嵌入式系统的浏览器的研究与实现

该文简单概要了嵌入式系统和嵌入式浏览器,介绍了嵌入式浏览器的相关技术,并详细地描述了实现的细节和主要模型。     

Open Embedded Control

Embedded control devices today usually allow parameter changes, and possibly activation of different pre-implemented algorithms. Full reprogramming using the complete source code is not allowed for safety, efficiency, and proprietary reasons. For these reasons, embedded regulators are quite rigid and closed concerning the control structure. In several applications, like industrial robots, there is a need to tailor the low level control to meet specific application demands. In order to meet the efficiency and safety demands, a way of building more generic and open regulators has been developed. The key idea is to use pieces of compiled executable code as functional operators, which in the simplest case may appear as ordinary control parameters. In an object oriented framework, this means that new methods can be added to controller objects after implementation of the basic control, even at run-time. The implementation was carried out in industrially well accepted languages such as C and C++. The dynamic binding at run-time differs from ordinary dynamic linking in that only a subset of the symbols can be used. This subset is defined by the fixed part of the system. The safety demands can therefore still be fulfilled. Encouraged by results from fully implemented test cases, we believe that extensive use of this concept will admit more open, still efficient, embedded systems.     

如何构造嵌入式实时应用系统

文中对组织和设计嵌入式实时应用系统应着重考虑的一些问题做了探讨,主要包括系统实时目标分析、硬件平台的规划、实时操作系统的选择、编程语言的选择和其它方面的一些关键问题。     

透视C程序设计语言

从三个不同侧面透视了C高级程序设计语言:"结构化"的程序设计语言;"函数式"的程序设计语言;"面向过程"的程序设计语言。论述了C程序设计语言面向过程的模块化编程思想、用其编程解决实际问题的一般思路和具体程序中的实现形式,同时,总结了上述三个方面的内在联系和它们的统一性。得出了C高级程序设计语言的优点和其强大的生命力,具有较高的概括性和理论意义,对于学习和研究C程序设计语言提供了一个很好的典型案例。     

EC + +与C + +嵌入式系统编程比较研究

文中主要阐述了在国外广泛应用的嵌入式系统面向对象编程语言EC ,比较了它与C 的区别,论述了EC 对嵌入式系统编程的优点。     

Tice: A real-time language compilable using C++ compilers

Model-based development (MBD) holds the promise to capture potential timing problems in embedded software during the early phases of the development, securing the production of bug-free embedded software. For most MBD approaches, the source code is just an intermediate artifact that can be generated automatically from the models. This assumption clashes with an undeniable fact: a large share of the commercial embedded software exploits existing libraries or is developed using C/C++ natively. A way to reconcile the ambitions of MBD with the use of a programming language is by offering new language constructs and an innovative compilation tool-chain that prevents model error and timing problems “by construction.” However, the persistent popularity of C/C++ among embedded programmers and the limited availability of tools have severely limited the uptake of alternative programming languages for embedded software. Therefore, we propose an original route. Our language proposal, named Tice, has been shaped as a C++ active library. Tice retains full compatibility with existing C++ code, which can be integrated easily into new Tice-based projects. The enforcement of Tice syntax and semantics can be made by a standard C++ compiler, forgoing the need for new tools. In this article, we describe Tice's syntax, semantics, and model of computation and communication. We demonstrate Tice's practical applicability on an industrial scale use-case and give ample evidence for Tice's efficient compilation using off-the-shelf C++ compilers. Finally, we show Tice's code generation process.