|
|
|
|
An Open-source Recipe for Teaching/Learning Robotics with a Simulator
|
Renaud Detry |
This tutorial presents a cross-platform robot development and simulation environment that can be installed in five minutes and that allows students to write control, navigation, vision or manipulation algorithms in a hundred lines of Matlab or Python code. The tutorial relies on the V-REP robot simulator, and on the Matlab Robotics Toolbox (RTB). The key feature of this combination is its ease of use – both tools are trivial to install. The tutorial is intended for teachers and students. Students will install the simulation environment on their laptop and learn everything they need to know to start implementing and testing robot algorithms. Teachers will return home with a ready-to-use recipe for organizing a master-level robotics project. This event follows our successful tutorial at IROS 2014. In this instance, we will focus on providing hands-on experience to the audience with an hour-long practice session.
Because working with hardware is time-consuming, many Master-level and PhD-level robotics courses leave hardware issues aside, to give the students time to study theoretical concepts and information-processing algorithms. Unfortunately, hardware-free courses often come with no hands-on exercises, which impedes learning. This tutorial discusses one solution to this problem: allowing students to gain practical experience in a simulated environment. Open-source simulators have existed for a long time, but their limited ease-of-use made them impractical for teaching. Ease of use is crucial in teaching: The software must be robust, multi-platform, and its installation has to be trivial. V-REP, the simulator on which this tutorial is based, can be installed on Linux, OSX and Windows simply by uncompressing zip archive.
Software development is another major challenge in robot development. This tutorial is based on the Robotics Toolbox for MATLAB (RTB), a library of robot-oriented software building blocks. Its Matlab implementation makes it accessible to branches of engineering where fluency in C++ is not expected.
The aims of this tutorial are twofold. First, we provide Master/Ph.D. students with an environment that allows them to easily test robot control algorithms. Second, we provide teachers with all the material needed for organizing a Master-level robotics project.
The TRS environment consists of a set of Matlab scripts, and a V-REP file modeling a mobile robot and a building floor. Running a single Matlab command establishes a connection between Matlab and V-REP. The user is then able to recover sensor data (images, scans, odometry), process those data, and send commands to the robot's actuators. The robot's sensors and actuators are accessed via Matlab functions:
vrep.simxSetJointTargetVelocity(id, wheel1, 10);
An understanding of the simulator itself is not required, as all the programming is done through the Matlab interface.
http://renaud-detry.net/teaching/info0948/private/raster/youbot.mp4
The tutorial covers the V-REP Matlab API and RTB. As stated above, we also provide a recipe for organizing a Master-level robotics project. The project consists in using a mobile robot to pickup groceries from a table and move them to different baskets distributed across a house. The project involves control, navigation, mapping, vision and manipulation. The recipe is composed of a website that presents the project, a Matlab script that illustrates access the robot's sensors and actuators, and a Git repository containing the V-REP model and Matlab scripts discussed above. The website covers multiple aspects of the project, including its descriptions, install instructions, milestones paving the way for the students, and a description of the robot and its capabilities. The project recipe is publicly available on GitHub.
SimJulia- A process-driven combined continuous-time / discrete-event simulation framework
|
Ben Lauwens |
SimJulia is a simulation framework written in the Julia programming language. Julia (http://julialang.org) is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments.
SimJulia is inspired by a lot of other simulation frameworks: SIMULA, SimPy, DISCO, ... but has the unique feature that continuous time processes, i.e. systems of differential equations, can be mixed with discrete event processes, eg. queuing systems. This allows to build simulations for which the scheduling of a discrete event can depend on a numerical threshold coming from the ODEs (system of ordinary differential equations) and vice versa. In classical simulation tools this is a very runtime expensive operation due to the continuous polling. SimJulia solved this problem elegantly by using a quantized state system (QSS) solver for the solution of the ODEs. This technique allows to reuse the discrete event kernel for the continuous time integration.
The basic building blocks of a discrete event simulation ("Event", "Process", "Environment") are expanded with often used operational models, i.e. congestion points where processes queue up in order to use them:
- a "Resource" can be used by a limited number of processes at a time (e.g., a gas station with a limited number of fuel pumps).
- a "Container" models the production and consumption of a homogeneous, undifferentiated bulk. It may either be continuous (like water) or discrete (like apples).
- a "Store" allows the production and consumption of generic Julia types.
Another way to program the interaction of processes is the use of interrupts. It is also possible to use a process as an event, i.e. an event will be scheduled when the process stops running. An advanced feature is the possibility of logical operations with events. This allows to schedule an event when n events have happened or when only one out of n events has happened.
The continuous time models are build around the notion of "Continuous", a system of differential equations and "Variable", the state of one variable of the system. It is possible to schedule events based on a threshold upon a variable. And vice versa the system of differential equations can be dynamically adapted according to the scheduling of an event. Both non-stiff and stiff QSS solvers of order up to 4 are available.
To make the modelling process as easy as possible for the end users the discrete event handling is abstracted by a process driven approach. An end user has not to worry about events but can concentrate on the logical implementation of the processes. SimJulia uses the coroutine functionality included in Julia to implement this feature which has no overhead (green threads) compared to using the events directly.
After the tutorial, participants will be familiar with SimJulia and will be able to implement and run their own models.
SimJulia is released under the MIT License. The source code is freely available at the GitHub page of SimJulia (https://github.com/BenLauwens/SimJulia.jl) and complete documentation is provided (http://simjuliajl.readthedocs.org).
title to be announced
Info to be added in
|
|
Info to be added in
