Robot Control

Robots are definitely advanced designs, but usually (Let's not consider AI scenarios for now) they are only as advanced as they are told to be. Robot Control is an interface for programming robot behaviour.

Used technologies

  1. Java
  2. JavaFX
  3. Scheme

Github repository

The project was created as a part of the Programming Language Paradigms course at Aarhus University. Its main goal was to design and implement robot control system made for a factory application.

The project was implemented with use of two different programming paradigms:

  1. Imperative

    2. The imperative part is written in Java, and is built as a JavaFX application. This part contains all the GUI logic and uses a Kawa framework for communicating with the functional part. The application is split into several packages in order to separate logic:

    • GUI - containing all user interface components and functionality such as animations.
    • Robot - holding a model of the robot state which is mapped when communicating with Scheme.
    • Utils - different utilities such as file reader for loading scheme files and mapping used when displaying the floor.
    • Scheme - containing Scheme communication logic.

    To communicate with Scheme the Kawa framework is used. This framework allows Scheme to run in a Java environment.

  2. Functional

    3. The Scheme code contains all the functionality of the program regarding robot behaviour, and is based on the functional programming paradigm. The implementation was split into separate files.

    • The FloorPlan - which holds the state of the floor.
    • FloorUtil - which is used as an accessor to the floor and tiles.
    • Robot - holds information about the robot ”object”, and defines the rules imposed on its behaviour
    • Simulation - which runs the simulation and calls procedures of the robot.

As mentioned, Scheme is a functional programming language, and is very good at handling computations. It gave a good separation of concerns, as all logic of the robot is contained in Scheme, and view logic in Java. The robot behaviour has been encapsulated in the class representation being a function containing other functions. The robot class function is immutable meaning that every call changing the robot state resulted in creation of a new robot instance. However, not all of the inside functions are pure functions because some of them depend on the Floor Plan representation, which is in contradiction to functional programming paradigm.

The system consists of two independent components: Java and Scheme, communicating with each other. The project was designed with focus on proper separation of concerns between this two components.

The Scheme component can be viewed as robot's internal memory, and as a result it contains all robot state, and defines its behaviour based on programmed movement restrictions and floor state.

The imperative part is written in Java, and is build as a JavaFX application \cite{javafx}. This component contains all the GUI logic and uses a Kawa framework for communicating with the functional part. This framework allows Scheme to run in a Java environment.

Running the application

In order to run an application simply import it into your IDE with JavaFX configuration, and run it as Java Application.