Robotics Programming

August 15, 2015

Mark Anthony P. Cesar, MIT
Racquel A. Cortez, MIT
 OUTLINE

• Introduction
• Types of machine Language
• Evolution of Robotics Programming
• Other Robot language System
• The Key Requirements of Robot
• Issues on Robot Programming
• Arduino Software
• ROBOTC
• Advance Topic in Robotics

2
 INTRODUCTION

• One of the characteristics of robots is versatility. It is derive

from the robot’s physical structure and control, but it can be
utilized only if the robot can be programmed easily.
Programming is usually the final step involved in building a
robot

• The evolution reaches from early control concepts on the

hardware level via point-to-point and simple motion level
languages to motion-oriented structured robot programming
languages

3
General robot Programming Paradigm

4
 Two Enabling Technologies

• Telemanipulators

These are remotely controlled machines which usually consist of an arm

and a gripper. The movements of arm and gripper follow the instructions
the human gives through his control device. First telemanipulators have
been used to deal with radio-active material.

• Numeric control
It allows to control machines very precisely in relation to a given
coordinate system. It was first used in 1952 at the MIT and lead to the
first programming language for machines (called APT: Automatic
Programmed Tools).

The combination of both of these techniques lead to the first

programmable telemanipulator. The first industrial robot using these
principle was installed in 1961. These are the robots one knows from
industrial facilities like car construction plants.

5
 Types of Programming Languages

• Machine Language
The only language understood by computers and consists of pure
numbers; it takes the form of “1” or “0”.

• Low Level Language

It also called assembly language. It uses mnemonic codes, which is easily
to understand than machine language. Each machine instruction has two
parts: (1) the operation code which tells the computer what function to
perform and (2) the operand which tells the computer what data to use
when performing the function

• High Level Language

It is closer to human language than the machine language that the
computer understands.

6
 Generation of Robot Programming
Language
• First Generation
Combination of command statements. It Teaches
Pendent Procedures. Its features are Motion Control and
easier to use. First Generation Languages cannot specify
complex arithmetic computations, It cannot make use of
complex sensor data. It has limited capacity to
communicate and cannot be extended.

• Second Generation
Second Generation Languages can control motion, have
advanced sensor capabilities limited intelligence and can
process communication and data.

7
 Evolution of Robot Programming

MHI (1960) - Mechanical Hand Interpreter

The first robot-level programming language, MHI, was developed for one of
the earliest computercontrolled robots, the MH-1 at MIT. As opposed to its
contemporary the Unimate, which was not controlled by a general-purpose
computer and used no external sensors, MH-I was equipped with several
binary touch sensors throughout its hand, an array of pressure sensors
between the fingers, and photodiodes on the bottom of the fingers. The
availability of sensors fundamentaly affected the mode of programming
developed for the MH-1.

8
 Evolution of Robot Programming

WAVE (1970)

The WAVE system, developed at Stanford, was the earliest system designed
as a general purpose robot programming language. WAVE was a language,
whose syntax was modeled after the assembly language of the PDP-10.

In spite of WAVE’S low-level syntax, the system provided an extensive

repertoire of high-level functions. WAVE pioneered several important
mechanisms in robot programming systems:

The description of positions by the Cartesian coordinates

The coordination of joint motions to achieve continuity
The specification of compliance in Cartesian coordinates
.

9
 Evolution of Robot Programming

MINI (1972)

MINI was developed at MIT, It it was an

extension to an existing LISP system
by means of a few functions. The
functions served as an interface to a
real-time process running on a
separate machine. LISP has little
syntax; it is a large collection of
procedures with common calling
conventions, with no distinction
between user and system code. The
robot control functions of MINI simply
expanded the repertoire of functions
available to the LISP programmer.
.

10
 Evolution of Robot Programming

AL (1974)

AL robot language was developed in Artificial Intelligence Lab at

Stanford University. It is the second generation language based on
simultaneous Pascal. The programs are written and executed on
PDP – 10. If the program is developed with high level code, then it
should be written in Stanford Artificial Intelligence Language (SAIL).
The AL system includes a big mainframe computer, and it generally
runs on PDP 11/45.

11
 Evolution of Robot Programming

AL was designed to provide four major kinds of capabilities:

The manipulation capabilities provided by the WAVE
system: Cartesian specification of motions, trajectory
planning, and compliance.
The capabilities of a real-time language: concurrent
execution of processes, synchronization, and on-
conditions.
The datand control structures of an ALGOL-like
language, including data types for geometricalculations,
e.g., vectors, rotations, and coordinate frames.
Support for world modeling, especially the AFFIXMENT
mechanism for modeling attachments between frames
including temporary ones such as formed by grasping.
.

12
 Evolution of Robot Programming

TEACH (1975)

The TEACH language was developed as part of the PACS system at

Bendix Corporation

In addressing these issues TEACH introduced several key innovations;

among these are the following:

1. Programs are composed of partially ordered sequences of statements

that can be executed sequentially or in parallel.
2. The system supports very flexible mapping between the logical
devices
3. All motions are specified relative to local coordinate frames, so as to
enable simple relocation of the motion sequence.
4. Programs are composed of partially ordered sequences of statements
that can be executed sequentially or in parallel.
5, The system supports very flexible mapping between the logical
devices
6. All motions are specified relative to local coordinate frames, so as to 13
enable simple relocation of the motion sequence.
 Evolution of Robot Programming

VAL (1975) - Variable Assembly Language

VAL is the robot language used in the industrial robots of
Unimation Inc., especially the PUMA series

. The basic capabilities of the VAL language are as follows:

1. point-to-point, joint-interpolated, and Cartesian motions
(including approach and deproach motions);
2. specification and manipulation of Cartesian coordinate
frames, including the specification of locations relative to
arbitrary frames;
3. integer variables and arithmetic, conditional branching, and
procedures;
4. setting and testing binary signal lines and the ability to
monitor these lines and execute a procedure when an event is
detected.

14
 Generation of Robot Programming
Language
AML (1977 ) A Manufacturing Language

AML is a high level language based on sub routine, which is mainly

implemented to manage RS / 1 Assembly Robot, End Effectors Active
Force Feedback, and Cartesian Arm with hydraulic motors. The RS / 1
assembly robot incorporates a mini – computer (IBM Series/1), 192 KB
memory, matrix printer, disk drive, display terminals, and keyboard. AML
was developed by IBM Corporation for robot programming. An important
reason for creating this language is to offer simple subsets and as well
as powerful base language

15
 Evolution of Robot Programming

PAL (1978)

PAL programs consist primarily of a sequence of

homogeneous coordinate equations involving the locations of objects
and of the robot’s endeffector. Some of the transforms in these
equations, e.g., those specifying the relative location of a feature
to an object’s frame, are defined explicitely in the program.

Other coordinate frames are defined implicitly by the equations;

leading the robot through an execution of the task establishes
relations among these frames. Solving for the implicitly defined
frames completes the program

16
 Evolution of Robot Programming

MCL (1979)

MCL is an extension of the APT language for Numerically Controlled

machining to encompass robot control, including the following capabilities:

data types, e.g., strings, booleans, reals, and frames;

control structures for conditional execution,
iterative real-time input and output;
vision interface, including the ability to define a shape to execution,
and multiprocessing; be located in the visual field.

17
 Additional Robot Language System

ML

It is a low-level robot language developed at IBM, with operations

comparable to those of a computer assembly language. The
motion commands specified joint motions for an (almost)
Cartesian robot. The language provided support for guarded
moves by means of SENSOR commands that enabled sensor
monitors; when a monitor was activated by a sensor value outside
of the specified range, all active motions were terminated. ML
supported two parallel robot tasks and provided for simple
synchronization between the tasks.

18
 Additional Robot Language System

EMILY
It was an off-line assembler for the ML language. It raised the
syntax of ML to a level comparable to Fortran.

MAPLE
It was an interpreted AL-like language, also developed at IBM.
The actual manipulation operations were carried out by using
the capabilities of the ML system described earlier

LAMA-S
It was developed at IRIA, France, is a VAL-like language with
support for on-line computations, for arrays, and for
pseudoparallel execution of tasks.
.

19
 Additional Robot Language System

LM
It was developed at IMAG, Grenoble, France. LM is a
language that provides most of the manipulation facilities of
AL in a minicomputer implementation. It also supports
affixment, but not multiprocessing.

SIGLA
It was developed at Olivetti for the SIGMA robots, supports a
basic set of joint motion instructions, testing of binary signals,
and conditional tests. It is comparable to the ML language in
syntactic level. SIGLA supports pseudoparallel execution of
multiple tasks and some simple force control.

MAL
It was developed at Milan Polytechnic, Italy, is a Basic-like
language for controlling multiple Cartesian robots. The
language supports multiple tasks and task synchronization by
means of semaphores.
20
 Additional Robot Language System

RAIL
It was developed at AUTOMATIX Inc, contains a large subset
of PASCAL, including computations on a variety of data types,
as well as high-level program control mechanisms. RAIL
supports interfaces to binary vision and robot welding
systems.

This language was designed by Automatix for arc welding and

inspection purposes. RAIL comes with three different kinds of
systems, namely:

Hitachi Process Robot – Arc Welding

Cartesian Arm – Assembly functions
Vision system without arm

21
 Additional Robot Language System

HELP
It was developed at General Electric for their robot products,
including the Allegro robot. The language is Pascal-like and
supports concurrent processes to control the
two arms in the Allegro system. It is comparable in level to
RAIL and AML.

RPL
RPL robot language makes the improvement, checking, and
correction of control algorithms very easy. It can be done
even by an unskilled programmer like line foreman,
production engineers, etc. The RPL programs are translated
to interpretable code with the help of a compiler in SRI Robot
Programming System. The programs are typically written in
BLISS – 11 and run in RT – 11. The DECPDP – 10 is cross
compiled into the LSI – 11 or PDP – 11. This robot language
was designed in SRI International.

22
 The Key Requirements of Robot
Programming
Sensing

Sensing enables robots to perform tasks in significant

environmental uncertainties without special-purpose tooling.
Sensors can be used to identify the position of parts, to
inspect parts, to detect errors during manufacturing
operations, and to accomodate to unknown surfaces. Sensing
places two key requirements on robot programming systems.
The first requirement is to provide general input and output
mechanisms for acquiring sensory data.
The second requirement is to provide versatile control
mechanisms, such as force control, for using sensory data to
determine robot motions.

23
 The Key Requirements of Robot
Programming
The principal uses of sensing in robot Programming are as
follows:

1. Initiating and terminating motions

2. Choosing among alternative actions
3. Obtaining the identity and position of objects and features
4. Complying to external constraints

24
 The Key Requirements of Robot
Programming
World Modeling

Tasks that do not involve sensing can be specified as a

sequence of desired robot configurations; there is no need to
represent the geometrical structure of the environment in
terms of objects

A robot programming system should facilitate this type of

computation on object positions and robot configurations.
Coordinate frames are likely to continue being the primary
representation of positions in robot programs. Therefore, a
robot programming system should support the representation
of coordinate frames and computations on frames via
transforms.

25
 The Key Requirements of Robot
Programming
World Modeling

Many of the required frames can be obtained from drawings

of the part. This process is extremely tedious and error prone,
however. Several methods for obtaining these data have been
proposed:
using the robot to define coordinate frames;
using geometric models from Computer-Aided Design
(CAD) databases;
using vision systems.
.

26
 The Key Requirements of Robot
Programming
Motion Specification

The most obvious part of robot programming is motion

specification which is needed for guiding the robot
The view of motion specification as simply specifying a
sequence of positions or robot configurations is too limiting.
Mechanisms for geometric specification of curves and
functionally defined motion should also be provided.
.

27
 The Key Requirements of Robot
Programming
Flow of Control
In the absence of any form of sensing, a fixed sequence of
operations is the only possible type of robot program.

Programming Support
Robot programs often must access external manufacturing
data, ask users for data or corrective action, and produce
statistical reports.
.

28
 Issues on Robot Programming

Compiler vs Interpreter
Language systems that compile high-level languages into a lower level
language can achieve great efficiency of execution as well as early
detection of some classes of programming errors. Interpreters, on the
other hand, provide enhanced interactive environments, including
debugging, and are more readily extensible.

New vs Old
Is it better to design a new language or extend an old one? A new one
can be tailored to the need of the new domain. An old one is likely to
be more complete, to have an established user group, and to have
supporting software packages. In practice, few designers can avoid the
temptation of starting de novo; therefore, most robot languages are
“new” languages. .

29
 What Language to Choose

Assembly
It is just one step away from machine code and as such it is very
tedious to use. Assembly should only be used when you need absolute
instruction-level control of your code.

Basic
One of the first widely used programming languages, it is still used by
some microcontrollers (Basic Micro, BasicX, Parallax) for educational
robots.

C/C++
One of the most popular languages, C provides high-
level functionality while keeping a good low-level control.

30
 What Language to Choose

Java
It is more modern than C and provides lots of safety features to the
detriment of low-level control. Some manufacturers likeParallax make
microcontrollers specifically for use with Java.

.NET/C#
Microsoft’s proprietary language used to develop applications in Visual
Studio. Examples include Netduino, FEZ Rhino and others).

Processing (Arduino)
A variant of C++ that includes some simplifications in order to
make the programming for easier.

Python
One of the most popular scripting languages. It is very simple to learn and
can be used to put programs together very fast and efficiently.

31
 What Language to Choose

Often times, a microcontroller is intended to be programmed

in a specific language. For example:

• Arduino microcontrollers use Arduino software and are re-

programmed in Processing.
• Basic Stamp microcontrollers use PBasic
• Basic Atom microcontrollers use Basic Micro
• Javelin Stamp from Parallax is programmed in Java
• ROBOTC is a cross-robotics-platform programming
language for popular educational robotics systems
• CAD Based Program Specification

32
 Arduino Software

Step 1: Ensure you have all components needed to program

the microcontroller.
Step 2: Connect the microcontroller to the computer and
verify which COM port it is connected to
Step 3: Check product’s user guide for sample code and
communication method / protocol.

Step 4: Encode the Program

Step 5: Test and Debug

33
 Arduino Software

Distance sensor

File -> Examples -> Analog -> AnalogInOutSerial

Pan/Tilt

File -> Examples -> Servo -> Sweep

Motor Controller

34
 Arduino Software

Motor Controller

The controller is connected to the Tx (serial) pin of the

Arduino and waits for a specific “start byte” before taking any
action. The manual does indicate the communication protocol
required; a string with specific structure:
0x80 (start byte)
0x00 (specific to this motor controller; if it receives anything
else it will not take action)
motor # and direction (motor one or two and direction
explained in the manual)
motor speed (hexadecimal from 0 to 127)

35
 Arduino Software

Motor Controller

In order to do this, we create a character with each of these

as bytes within the character:
unsigned char buff[6];
buff[0]=0x80; //start byte specific to Pololu motor controller
buff[1]=0; //Device type byte specific to this Pololu controller
buff[2]=1; //Motor number and direction byte; motor one
=00,01
buff[3]=127; //Motor speed “0 to 128″ (ex 100 is 64 in hex)
Serial.write(buff);

36
 ROBOTC

• A complete ‘C’ programming language for

robotics.
– Developed for Teaching, Powerful enough for
Hobbyists/Professionals
– Developed in Microsoft Visual C++ 2008 and IAR
Embedded Workbench
• Extremely easy to use for both beginners and
advanced users
– Most “robot functions” are a single line
commands.

37
 ROBOTC

• Single Programming Language / Multiple Platforms

– Mindstorms – NXT and EV3
– Innovation FIRST – VEX Cortex, and VEX IQ
– Arduino - Arduino Uno, Mega, Mega 2560 controllers
• Developed for Education (High School/College)
– Students learn in a friendly environment about C-Based
programming
– Friendlier Compiler, GUI Device Configuration, Code
Templates
• Focus is for new programmers to C, but powerful to
make experienced programmers feel comfortable.

38
 ROBOTC Language

• Language extensions for robotics

– Built-in variables for robotics devices – motors,
sensors, joysticks
– Example: One line command to drive motors
• NXT - motor[motorA] = 100; //Turn Motor A @ 100%
• User “friendly” compiler
– Auto-correct from popular programming errors
– Letter case errors in variable names: “playSound”
for “PlaySound”.
• Compiler is NOT CASE Sensitive – This is by design!
39
 ROBOTC
Development Environment
• Language extensions for robotics
– Built-in variables for robotics devices – motors,
sensors, joysticks
– Example: One line command to drive motors
• NXT - motor[motorA] = 100; //Turn Motor A @ 100%
• User “friendly” compiler
– Auto-correct from popular programming errors
– Letter case errors in variable names: “playSound”
for “PlaySound”.
• Compiler is NOT CASE Sensitive – This is by design!
40
 ROBOTC
Development Environment
• Normal-style source code editor
– Syntax highlighting and formatting
– Code completion
– Integrated help/support
• Compiler, linker and program downloader – integrated and
combined
– No command line tools required (or available…)
• Interactive Run-Time Debugger
– Allows monitoring of tasks (threads), variables, devices such as
motors and sensors.
• User friendly
– “Basic”, “Expert” and “Super User” mode to adjust features and
menus
– 100+ programming examples in the “Sample Code” Library

41
 ROBOTC
Interactive Real-time Run-Time Debugger
• Run/Stop, Suspend/Resume programs from PC
• Single step through program execution, one line at a time.
• Unlimited user defined breakpoints
• Read / write / display the contents of any user variable.
• Consciously view the status of all devices in at run-time
from your PC.
• Zero additional coding required, enabled by default!

42
 ROBOTC Language
ROBOTC vs. “Other” Languages
• #1 Reminder: You are creating code to be run of a 256kb
ARM Processor – not a desktop!
• Variables and Memory
– The NXT Supports…
• Integers, Longs, Floats, Bytes, Bool, Chars and Strings (String are
limited to 20 characters – use Char[] for longer strings)
– The NXT has room for 15,000 bytes of variables
– Adding “const” in front of a variable will make that variable a
constant.
• This will prevent the variable from being changed by the program
– Constants do not take up any memory on the NXT
– Support for Pointers/Recursion (standard ANSI C-style)
– ROBOTC is a procedural language – there are no classes. You
can use a “struct” as an alternative to group variables.

43
 ROBOTC Language
ROBOTC vs. “Other” Languages
• Libraries and Workspaces
– ROBOTC is built around a 1-program model – no
workspace files.
– ROBOTC automatically includes all of the headers behind
the scenes
• Stuff like math libraries, string support, standard language libraries
are already included.
– You can create your own external libraries and do a
“#include” to bring them into your program.
• Advanced C Data Structures
– Pointer Support (* and &)
• void testFunct(int &tempVar)
– Structs and Typedefs are supported
• Standard ANSI-C support in most cases.

44
 ROBOTC Language
ROBOTC vs. “Other” Languages
• LCD Capabilities
– You have full control of the LCD – Take a look at the help
documentation / samples. You can turn individual pixels on
or off, or use some of the drawing libraries already built
into ROBOTC.
• Advanced Ideas with NXT
– I2C Support – Big 3rd party sensor library or roll your own
• http://botbench.com/blog/robotc-driver-suite/
– File I/O
• See Sample Programs – You can write to text files and use the NXT
File Management utility to download the file to your PC
– Bit Shifting and Comparators operators are available
– Arrays – ROBOTC supports up to 2-dimention arrays.

45
 ROBOTC Language
ROBOTC vs. “Other” Languages
• LCD Capabilities
– You have full control of the LCD – Take a look at the help
documentation / samples. You can turn individual pixels on
or off, or use some of the drawing libraries already built
into ROBOTC.
• Advanced Ideas with NXT
– I2C Support – Big 3rd party sensor library or roll your own
• http://botbench.com/blog/robotc-driver-suite/
– File I/O
• See Sample Programs – You can write to text files and use the NXT
File Management utility to download the file to your PC
– Bit Shifting and Comparators operators are available
– Arrays – ROBOTC supports up to 2-dimention arrays.

46
 ROBOTC Language
Support and Curriculum
• ROBOTC.net Community Forums
– www.robotc.net/forums
– Over 5000+ active users
– Most questions can be answered here
• ROBOTC Technical Support
– support@robotc.net – Ticketing System
– Or e-mail Tim (tfriez@cmu.edu) or John (jwatson@robotc.net) directly
• Help Documentation / Function Reference
– Built-In and Online at www.robotc.net
• Video based curriculum
– Answers questions about how to use hardware and gives beginning
programming tutorials
– http://tinyurl.com/RCNXTTraining

47
 ROBOTC Language
Licensing
• You’re entitled to a free copy of ROBOTC thanks to this class
– Download from http://www.robotc.net/download/nxt/
• Use the following licensing information:
– ROBOTC for MINDSTORMS 4.X
– License ID: 61588936
– Password: Howie2015
• You may need the LEGO USB Driver as well
– This is typically included in the installer package and
automatically installed.
– 32Bit:
• http://downloads.robotc.net/drivers/NXTUSBDriver_32bit.zip
– 64Bit:
• http://downloads.robotc.net/drivers/NXTUSBDriver_64bit.zip

48
 Thinking about Programming
Creating a successful robot takes a team effort between
humans and machines.

Role of the Robot

The robot follows the instructions
it is given, thereby carrying out the
plan.
 Human/Machine
Communication

Because humans and robots don’t normally speak the same language, a
special language must be used to translate the necessary instructions
from human to robot. These human-to-robot languages are called
programming languages. Instructions written in them are called
programs. ROBOTC is just one of many such programming languages
that humans use to talk to machines.
 Think about “Behaviors”
Behaviors are a convenient way to talk about what a robot is doing and
what it must do. Moving forward, stopping, turning, looking for an
obstacle… these are all behaviors.

Basic or Simple Behavior

Complex Behavior Some behaviors are small, like “go
Some behaviors are big, like forward for 3 seconds.” Big
“solve the maze.” behaviors are actually made up of
these smaller ones.
Planning the Behaviors
 PSUEDOCODE
As the programmer becomes more
experienced, the organization of the
behaviors in English will start to
include important techniques from
the programming language itself,
like if-else statements and loops.
This hybrid language, halfway
between English and the
programming language, is called
pseudocode.It is an important tool
in helping to keep larger programs
understandable.
 ROBOTC is text based!
Commands to the robot are first written as text on the
screen. They are then processed by the ROBOTC compiler
into a machine language file that the robot can
understand. Finally, they are loaded onto the robot,
where they can be run.
 Code
Text written as part of a program is called code. You type
code just like you type normal text. Keep in mind that
capitalization is important to the computer. Replacing a
lowercase letter with a capital letter (or a capital letter
with a lowercase letter) will cause the robot to become
confused.
 Code COLOR
As you type, ROBOTC will try to help you out by coloring the
words it recognizes. If a word appears in a different color,
it means ROBOTC recognizes it as an important word in
the programming language.
 Statements
Statements are instructions for the robot. The most basic
kind of statement in ROBOTC simply gives a command to
the robot. The motor[port3] = 127; statement in the
sample program you downloaded is a simple statement
that gives a command. It instructs the motor plugged
into Motor Port 3 to turn on at full power.
 Order the Statements
Statements are run in order as quickly as the robot is able
to reach them. Running this program on the robot turns
the motor on, then waits for 3000 milliseconds (3
seconds) with the motor still running, and then ends.
 RobotC Rules
How did ROBOTC know that motor[port3]= 127 and
wait1msec[3000] were two separate commands. Was it
because they appeared on two different lines?

No. Spaces and line breaks in ROBOTC are only used to separate words
from each other in multi-word commands. Spaces, tabs, and lines don’t affect
the way a program is interpreted by the machine.
 ROBOTC Rules
So why ARE they on separate lines? For the programmer.
Programming languages are designed for humans and
machines to communicate. Using spaces, tabs, and lines
helps human programmers read the code more easily.
Making good use of spacing in your program is a very
good habit for your own sake.
 Punctuation!
But what about ROBOTC? How DID it know where one
statement ended and the other began? It knew because
of the semicolon (;) at the end of each line. Every
statement ends with a semicolon. It’s like the period at
the end of a sentence.
 Punctuation Pairs
Punctuation pairs, like the parentheses and square brackets
in these two statements, are used to mark off special
areas of code. Every punctuation pair consists of an
opening punctuation mark and a closing punctuation
mark. The punctuation pair designates the area between
them as having special meaning to the command that
they are part of.
 Punctuation Pairs

Different commands make use of different kinds of paired

punctuation. The motor command uses square brackets and the
wait1Msec command uses parentheses. This is just the way the
commands are set up. You will have to remember to use the right
punctuation with the right commands or plan.
 Control Structures
Simple statements do the work in ROBOTC, but control
structures do the thinking. Control structures (or control
statements) are pieces of code that control the flow of
the program’s commands, rather than issue direct orders
to the robot.
 Control Structures
One important control structure is task main. Every ROBOTC
program includes a special section called task main. This control
structure determines which code the robot will run as part of the main
program.
 Comments
Comments are text that the program ignores. A comment
can contain notes, messages, and symbols that may help
a human, but would be meaningless to the robot.
ROBOTC simply skips over them. Comments appear in
green in ROBOTC.
 Advance Topics in Robotics

Design of 22-DOF pneumatically actuated upper body

for child android ‘Affetto’

69
 Advance Topics in Robotics

• Design and evaluation of robot patient for nursing

skill training in patient transfer

70
 Advance Topics in Robotics

• Accurate error compensation for a MR-compatible

surgical robot based on a novel kinematic
calibration method

71
 Advance Topics in Robotics

• Conformational Modeling of Continuum Structures

in Robotics and Structural Biology: A Review

72
 Advance Topics in Robotics

• A stiffness adjustment mechanism maximally utilizing elastic

energy of a linear spring for a robot joint

73
 CONCLUSION

• The KEY characteristic of robots is versatility; they can be

applied to a large variety of tasks without significant redesign.
This versatility derives from the generality of the robot’s
physical structure and control, but it can be exploited only if
the robot can be programmed easily. In some cases, the lack
of adequate programming tools can make some tasks
impossible to perform. In other cases, the cost of
programming may be a significant fraction of the total cost of
an application. For these reasons, robot programming systems
play a crucial role in robot development.

74
 References
Advanced Robotics Latest Article
http://www.tandfonline.com/toc/tadr20/0/0#.Vc2ySbKqqko

http://www.slideshare.net/correll/nlp-for-robotics?from_action=save

http://www.robotc.net/

http://www.robotshop.com

http://www.roboticsbible.com/robot-programming-languages.html
TimotFriez, Carnegie Mellon/Robomatter, January 27th, 2015
 References
Albert W. Schueller, Programming with Robots, 2011

F. M. Wahl and U. Thomas, Robot Programming - From Simple Moves to

Complex Robot Tasks, Institute for Robotics and Process Control
Technical University of Braunschweig, 2002
http://www.rob.cs.tu-bs.de/content/03-research/03-publications/download/
uth_2002_05_workshop_sfb_b4.pdf

Tim Niemueller and Sumedha Widyadharma, (2003) Artificial Intelligence –

An Introduction to Robotics,

Tomas Lazano-Perez, Robot Programming (1983)

nmarc2001@yahoo.com
racortez035@yahoo.com