The industrial robot's principal advantage over traditional automation is programmability. Robots can perform arbitrary sequences of pre-stored motions or of motions computed as functions of sensory input. This paper reviews requirements for and developments in robot programming systems. The key requirements for robot programming systems examined in the paper are in the areas of sensing, world modeling, motion specification, flow of control, and programming support. Existing and proposed robot programming systems fall into three broad categories: guiding systems in which the user leads a robot through the motions to be performed, robot-level programming systems in which the user writes a computer program specifying motion and sensing, and task-level programming systems in which the user specifies operations by their desired effect on objects. A representative sample of systems in each of these categories is surveyed in the paper.

Current fashion in "user-friendly'' software design tends to place an overreliance on direct manipulation interfaces. To be truly expressive (and thus truly user-friendly), applications need both learnable interfaces and domain-enriched languages that are accessible to the user. This paper discusses some of the design issues that arise in the creation of such programmable applications. As an example, we present "SchemePaint", a graphics application that combines a MacPaint-like interface with an interpreter for (a "graphics-enriched'') Scheme.

In this paper, I describe the application of genetic programming to evolve a controller for a robotic tank in a simulated environment. The purpose is to explore how genetic techniques can best be applied to produce controllers based on subsumption and behavior oriented languages such as REX. As part of my implementation, I developed TableRex, a modification of REX that can be expressed on a fixed-length genome. Using a fixed subsumption architecture of TableRex modules, I evolved robots that beat some of the most competitive hand-coded adversaries.

This thesis presents SodaBot, a general-purpose software agent user-environment and construction system. Its primary component is the basic software agent --- a computational framework for building agents which is essentially an agent operating system. We also present a new language for programming the basic software agent whose primitives are designed around human-level descriptions of agent activity. Via this programming language, users can easily implement a wide-range of typical software agent applications, e.g. personal on-line assistants and meeting scheduling agents. The SodaBot system has been implemented and tested, and its description comprises the bulk of this thesis.

This thesis investigates the use of Genetic Programming (GP) to evolve controllers for an autonomous robot. GP is a type of Genetic Algorithm (GA) using the Darwinian idea of natural selection and genetic recombination, where the individuals most often is represented as a tree-structure. The GP is used to evolve a population of possible solutions over many generations to solve problems. The most common approach used today, to develop controllers for autonomous robots, is to employ a GA to evolve an Artificial Neural Network (ANN). This approach is most often used in simulation only or in conjunction with online evolution; where simulation still covers the largest part of the process. The GP has been largely neglected in Behaviour Based Robotics (BBR). The is primarily due to the problem of speed, which is the biggest curse of any standard GP. The main contribution of this thesis is the approach of using a linear representation of the GP in online evolution, and to establish whether or not the GP is feasible in this situation. Since this is not a comparison with other methods, only a demonstration of the possibilities with GP, there is no need for testing the particular test cases with other methods. The work in this thesis builds upon the work by Wolfgang Banzhaf and Peter Nordin, and therefore a comparison with their work will be done.

No description available.

The biggest field in the recent decade in software development has been a subject known as Agile Development. In Agile development the construction of the software is an iterative process and is done with close contact with the costumer. One of the most well-known agile methods is Extreme Programming, which suggests a number of practices to develop software. One of those practices is test-Driven Development, which is the writing of the test code before you write the actual code. This means that one can test the code after it is finished. This creates an opportunity to change the design of the code and then test it again with your test code and discover if any functionality has been lost. The purpose of refactoring is the improvement of the design of existing code. How refactoring affects the performance is not widely discussed and therefore this thesis is going to examine that field. Code examples with and without refactoring principles have been tested. The investigation has been divided into two parts, part one tests individual refactoring principles and part two tests a test application. There are many opinions how to interpret the results of a performance test. After an extensive investigation the arithmetic mean was chosen, mainly because it reflects the total runtime for a series of executions. To test the hypothesis that total execution time will change with refactoring the Students t-test was used. It was chosen because it can be applied even when the variance is unknown. The results were clear, the arithmetic mean increased in five out of six refactoring principles. The test application also increased, but with only 4 %. The reason for the small increase was that it is not possible to go from a non refactored application to a fully refactored application. Another reason is that is was developed with Swedish Rail Administration’s framework which of course was not refactored. The conclusion of this thesis was that one should be careful with refactoring the parts of the code that is executed the most. One should have the “90-10 rule” in mind, it states that 90 % of the execution time is done in 10 % of the code. Another important aspect is that very often is an existing framework used, if you only refactor the new code and not the framework it leads to that only a subset of the code is being refactored. This means that the application does not get fully refactored and therefore the consequences of the refactoring mitigates.

This report describes the development of weight measurement application and transducer positioning for the A Sort prototype that has been developed for automatic grading and sorting of timber. The prototype consists of a transportation system with hydraulic and electrical motors, a measurement system with laser scanners and acoustic measurement equipment and a control program for the automated process with CoDeSys. The objective was to integrate these parts in an automatic system process, controlling a prototype designed for acoustic measurement of logs. The devices were installed and configured to communicate via an existing fieldbus line using CANopen as communication protocol. A control program was made for each task and implemented in the control process for the automatic measurement of logs. Two load cells were installed beneath a moving tilt and the measurement equipment was tested and calibrated using three different logs with known weight. The testing showed that in order to get higher accuracy the construction needs to be modified. Photo cells were installed on the measurement frames and a program was made in order to make the acoustic measurement of the logs work properly.

The objective of this study was to develop a tool for engineers and researchers to understand the underlying logic of the Highway Capacity Manual (HCM) procedures. The HCM offers a collection of methodologies and techniques for estimating the capacity and evaluation of the level of service for highway, street and transit facilities (HCM 2000). Mathcad worksheets were developed to replicate the computational procedures of five chapters of the HCM. The principal topics addressed are advantages of the Mathcad worksheets over existing implementations of the HCM, challenges associated with the implementation, and changes and additions made to the format of the HCM worksheets reflecting capabilities and limitations of Mathcad. These dynamic documents allow the user to easily explore the sensitivity of the procedures to varying equations, relationships and input parameters. Because the Mathcad worksheets display information in a manner similar to the HCM, most users will find the worksheets straightforward to use and interpret. As such the Mathcad worksheets offer better transparency than other implementations of the HCM procedures.

In this thesis, health care policy issues for prevention and cure of cervical cancer have been considered. The cancer is typically caused by Human Papilloma Virus (HPV) for which individuals can be tested and also given vaccinations. Policymakers are faced with the decision of how many cancer treatments to subsidize, how many vaccinations to give and how many tests to be performed in each period of a given time horizon. To aid this decision-making exercise, a stochastic dynamic optimal control problem with feedback was formulated, which can be modeled as a Markov decision process (MDP). Solving the MDP is, however, computationally intractable because of the large state space as the embedded stochastic network cannot be decomposed. Hence, an algorithm was proposed that initially ignores the feedback and later incorporates it heuristically. As part of the algorithm, alternate methodologies, based on deterministic analysis, were developed, Markov chains and simulations to approximately evaluate the objective function. Upon implementing the algorithm using a meta-heuristic for a case study of the population in the United States, several measures were calculated to observe the behavior of the system through the course of time, based on the different proposed policies. The policies compared were static, dynamic without feedback and dynamic with feedback. It was found that the dynamic policy without feedback performs almost as well as the dynamic policy with feedback, both of them outperforming the static policy. All these policies are applicable and fast for easy what-if analysis for the policymakers.