基于无线传感器网络的土壤水分监测基站系统设计

根据土壤水分监测传感器网络应用的需求,提出一种基于无线传感器网络的土壤水分监测基站系统的设计方案,包括监测网络体系结构、硬件结构及软件功能模块分割的总体方案设计。此外,还对基站无线通信模块、数据转换模块、存储模块、人机界面和数据上传模块进行详细设计。在实验测试中,本系统运行状况良好、工作稳定,基本能满足实际应用的需要。     

Program partition and logic program analysis

A program partition scheme for stratified programs introduced by Apt et al. (1988) is used to study efficient computation of logic programs. We consider three types of program partitions and their corresponding graph representations: 1) the natural partition, 2) stratified partitions, and 3) the reduced partition. The natural (program) partition consists of definitions of relations, each definition being a subprogram. Subprograms of a program partition may consist of several relations. A partition graph is introduced for a program partition, each node of which corresponds to a subprogram. The partition graph for a stratified partition is a directed acyclic graph (DAG). A stratified partition decomposes a program into modules. The stratified partition with the maximum number of modules is the reduced partition. The cost to achieve a reduced partition is linear in the program size, using well known graph algorithms. We introduce the modular interpretations, which are equivalent in semantics to the standard interpretation. The modular interpretations offer encapsulation and may reduce the computation cost for some modules significantly. The modular approach can play an important role in query optimization, efficient termination, programming design, and software engineering. We classify query types and answer types then discuss query optimization for some query types. Many efficient query processing strategies are applicable to restricted subclasses of programs. The program partition method allows us to select the most efficient strategy for each module. For example, if a module is a uniformly bounded recursion, then the module can be terminated efficiently. If a module defines the transitive closure, then efficient program transformations may be applied to this module     

Theory of Modules

Because large-scale software development is a struggle against internal program complexity, the modules into which programs are divided play a central role in software engineering. A module encapsulating a data type allows the programmer to ignore both the details of its operations, and of its value representations. It is a primary strength of program proving that as modules divide a program, making it easier to understand, so do they divide its proof. Each module can be verified in isolation, then its internal details ignored in a proof of its use. This paper describes proofs of module abstractions based on functional semantics, and contrasts this with the Alphard formalism based on Hoare logic.     

Modular Pluggable Analyses for Data Structure Consistency

Hob is a program analysis system that enables the focused application of multiple analyses to different modules in the same program. In our approach, each module encapsulates one or more data structures and uses membership in abstract sets to characterize how objects participate in data structures. Each analysis verifies that the implementation of the module 1) preserves important internal data structure consistency properties and 2) correctly implements a set algebra interface that characterizes the effects of operations on the data structure. Collectively, the analyses use the set algebra to 1) characterize how objects participate in multiple data structures and to 2) enable the interanalysis communication required to verify properties that depend on multiple modules analyzed by different analyses. We implemented our system and deployed several pluggable analyses, including a flag analysis plug-in for modules in which abstract set membership is determined by a flag field in each object, a PALE shape analysis plug-in, and a theorem proving plug-in for analyzing arbitrarily complicated data structures. Our experience shows that our system can effectively 1) verify the consistency of data structures encapsulated within a single module and 2) combine analysis results from different analysis plug-ins to verify properties involving objects shared by multiple modules analyzed by different analyses     

Support for software engineering using MODULA-2

Continuing a series on modern high-level languages the paper describes the features of MODULA-2 which are important in industrial systems programming. These features include the creation of libraries of reusable software, the ability to perform low-level programming and support for concurrency. MODULA-2 supports good software engineering practice by providing facilities for program decomposition, separate compilation and data abstraction. The role of the module concept and the export/import mechanism in providing these features is examined. Program modules, the definition and implementation parts of library modules and local modules are described.     

Modeling of Software Partition for Distributed Real-Time Applications

The issue of software partition deals with the process of mapping the given set of logical modules, which reflect the user's point of view, into a set of software tasks, which reflect the software implementor's point of view. It is shown in this paper that the software partitioning problem can be modeled as one that maximizes the efficiency in resource utilization while observing the constraints on CPU throughput, memory space available, maximally allowed task execution time, and the order of module execution. The CPU and memory constraints are implementation dependent. The maximum task execution time constraint is due to considerations on the response time performance. The constraint on module execution order is a logical one, and it is shown to have significant performance impact. It is proven that by employing the module precedence relation, which reflects the sequence of module execution, the order of module execution can be properly maintained during the software partitioning process. And thus the defined tasks can be guaranteed to be completely executable, once properly activated With completely executable tasks, the operating overhead cost and the response time delay can be minimized. The following four module precedence relations are explored: precede, succeed, parallel, and precede as well as succeed. The validity of the selected partitioning criterion of maximizing the resource utilization efficiency is also assessed through simulation experiments. The results of simulation show that performance of the selected criterion is insensitive to the application environment, as well as to the application requirements.     

基于OSGi 的移动广告平台订单系统

基于组件化构建应用已经成为一种趋势。针对模块划分缺少理论依据和指导,提出了依靠软件数据模型进行细粒度划分基本单元,再根据组件之间的服务交互频度和权值对基本单元的相关性进行分析,最终,利用模糊图的聚类方法,将基本单元聚类成模块的模块划分方法。最后,通过基于OSGi（Open Services Gateway Initiative＇s framework）的移动广告平台订单系统的应用实例表明了该方法的合理性和有效性。该模块划分方法适用于简单的面向数据模型的应用系统。     

医院无线呼救系统

基于无线传输方式,本文提出一种无线呼救系统,旨在解决一些不方便搭建有线呼叫系统的医院急救问题。该系统由病床模块、护士模块和护士站模块组成。三部分之间的数据传输均采用无线通信的方式。由于比一般的系统增设了护士模块部分,因此可以将病人的呼叫信息及时传递给护士,以避免因巡房等因素造成的"时间空白"。本文中着重对该系统的呼叫功能及其软件设计进行了介绍。     

Experience with Modular Concurrent Programming

This paper summarizes the initial experience with the programming language Concurrent Pascal in the design of three model operating systems. A Concurrent Pascal program consists of modules called processes, monitors, and classes. The compiler checks that the data structures of each module are accessed only by the operations defined in the module. The author emphasizes that the creative aspect of program construction is the initial selection of modules and the connection of them into hierarchical structures. By comparison the detailed implementation of each module is straightforward. The most important result is that it is possible to build a concurrent program of one thousand lines out of one-page modules that can be comprehended at a glance.     

Data access routines

One of the most important things about good design is modularity: dividing a system into separate pieces so that you can modify one module without the changes rippling all over the system. Early on, it was observed that modules should be arranged around system secrets, each module hiding its secret from the other modules. Then if the secret thing changes, you avoid a ripple effect. One of the most common secrets to hide these days is data structures. An axiom of object-oriented design is that data should always be private, but the idea of hiding data goes far beyond objects. The author discusses guidelines for basic data hiding. His examples all use objects but the arguments apply just as well to non-OO modules. When thinking about data access routines, the author uses two major cases: encapsulating either a single value (such as a person's name) or a collection (such as the line items on an order).     

一种基于对象信息的MIS自适应生成器

为解决MIS在开发和运行过程中因需求频繁变更所带来的开发和维护的工作量上升问题,提出一种新的MIS软件基础模块自适应生成管理器。通过信息化管理MIS的版本、用户与权限、系统结构、系统模块、对象信息、通用视图元素、通用业务逻辑元素和通用数据访问方式,并基于通用的界面层基础元素、业务逻辑层基础元素、数据访问层基础元素和对象信息自适应生成或重构MIS软件基础模块的数据库、交互界面、业务逻辑、数据交互部分和软件内部结构,以达到动态构建和管理MIS软件基础模块,实现基础模块信息化和系统对自身信息化、自动化管理的目的。通过将该生成器技术实现并实际应用于MIS开发,验证其能够较好地应对MIS基础模块的快捷构建与变更,有效降低MIS开发与维护的工作量。该生成器较好地解决了MIS软件基础模块快速构建与重构问题,能较好地应对MIS在开发和运行过程中的频繁变更。     

基于射频识别的室内定位系统设计

在分析室内定位应用背景的基础上,提出一种基于射频识别的室内定位系统设计方案,重点设计了室内定位系统的硬件模块和软件模块;硬件模块设计主要包括读取器模块、标签模块和接口电路模块;设计实现了对室内物体的定位信息的获取以及进行穿过障碍物获取数据的功能;软件模块主要包括主程序流程设计;实验结果表明可以在30m*30m的范围内获取到室内物体位置信息的信号强度指示,由传输模型定位出位置,计算出误差值。     

基于FPGA的图像融合处理系统方案设计

一种基于FPGA技术的图像处理系统,实现了图像数据的A/D采集、在SRAM以及SDRAM中的存取、在FPGA内部的DSP运算以及图像数据的D/A输出,具备图像融合处理功能。文章在阐述系统结构、总体方案和设计思想基础上,重点论述了系统各模块划分、芯片选型依据以及系统有关模块的接口设计。     

僵尸网络关键技术及其防御研究

为了更好地防御僵尸网络,研究了僵尸网络的程序设计与网络组建方法.分析了僵尸网络的功能结构和工作机制,设计了一个僵尸程序,该僵尸程序主要由扫描、漏洞攻击、上传工具和通信模块组成.利用Windows编程技术实现了各个模块,并搭建实验环境对其整体性能进行了测试.测试结果表明,僵尸网络的整体性能达到预期效果.最后讨论了僵尸网路的防范措施.     

基于可信密码模块的SoC可信启动框架模型

为满足嵌入式终端对信息安全的要求,设计了基于可信密码模块的SoC可信启动框架。该框架的特点在于对引导程序U-boot做功能上的分割,且存储在不同的非易失性存储器中,并增设了通信模块,使之在操作系统启动之前就具有发送和接收文件的功能。将引导程序的各部分与操作系统核心文件均作为可信实体,发送至可信密码模块进行完整性度量,若度量成功则可信密码模块返回下一阶段的启动信号并在其本地存储器中保存可信实体;若度量失败则禁止启动。实验结果表明,该框架是可行、有效的,可以满足现今嵌入式终端在信息安全方面的需要。     

OOMMS:A Module Management System Based on an Object-Oriented Model

This paper describes the design rationale of OOMMS, a module management system based on an object-oriented model.The concepts of object and module are defined.Modules refer to the software products in general which have interface parts and body pars.Related concepts of a cluster of modules,versions of a module,and revisions of a version are also defined.The tools for checking in Cprogram modules into OOMMS are discussed.     

A unix tool for managing reusable software components

Sloth is a simple Unix-based tool for creating and maintaining large C programs built from reusable ‘modules’. Sloth is a collection of UNIX shell commands for creating and editing modules, and for producing executables by linking compiled code from the modules comprising a program. Sloth in a sense extends C by providing module facilities similar to those built in to newer languages such as Modula-II. The Sloth ‘extensions’, however, are at the shell level only. No changes are required in C itself; in fact, the Sloth commands invoke the standard Unix C compiler. A Sloth module contains a set of C procedures and local declarations, a set of global definitions and variable declarations, an initialization routine and an ‘import’ list of other modules containing declarations referred to, but not defined by, the module in question. The Sloth link command has one argument, the name of a ‘root’ directory. The link command automatically identifies all those modules imported directly or indirectly by the root module, checks that the object code for each module is up-to-date and recompiles where necessary. It then creates a main program in which the various initialization routines are executed in the correct order (most primitive first), compiles it and links it with all the object files and produces an executable program. Individual modules can be compiled without any knowledge of the application that uses, directly or indirectly, the module in question. Two applications that both use a collection of modules can therefore share the object code for these modules. The use and implementation of Sloth are presented, as are the experience in using it, programming techniques developed to take full advantage of its facilities, as well as several extensions, either completed or planned.