Lab 1: Concept of Virtualization Technology; Installation of Virtual

Machines

Goal

Understand virtualization and install a virtual machine.

Introduction

Virtualization technology allows multiple operating systems to run on a single

physical machine. This is achieved by creating a virtual environment, known
as a virtual machine (VM), which runs on top of the host machine’s operating
system.

Steps

Step 1: introduction to virtualization technology

1. Research and explain the concept of virtualization.

2. Understand the different types of virtualization:

1. Hardware Virtualization: Creates a complete, self-contained

environment for each VM.

2. Software Virtualization: Uses software to emulate hardware

components.

3. Learn about hypervisors:

1. Type 1 Hypervisor: Runs directly on the host machine’s hardware

(e.g., Vmware ESXi).

2. Type 2 Hypervisor: Runs on top of the host machine’s operating

system (e.g., VirtualBox).

Step 2: Installing Virtual Machine

1. Download and install VirtualBox or Vmware Player.

2. Create a new virtual machine:

 1. Choose the operating system to install (e.g., Ubuntu or Windows).

2. Allocate resources (CPU, RAM, disk space) to the VM.

3. Configure network settings (e.g., NAT or Bridged).

3. Install an operating system inside the VM:

1. Insert the installation media (ISO file or physical disk).

2. Follow the installation prompts to complete the installation.

Deliverables

1. A working virtual machine with a installed operating system.

2. A brief report explaining the concept of virtualization and the steps taken
to install the virtual machine.

Assessment

1. Understanding of virtualization technology (20%).

2. Successful installation of a virtual machine (40%).

3. Quality of the report and documentation (30%).

4. Adherence to lab guidelines and submission requirements (10%).

Lab 2: Significance of Open-Source Platforms; Installation of Linux OS
Goal

Learn about open-source platforms and install a Linux operating system.

Introduction

Open-source platforms have revolutionized the software industry by

providing free and customizable solutions. Linux is a popular open-source
operating system that offers flexibility, security, and community support.

Significance of Open-Source Platforms

*Advantages*

1. *Free and Cost-Effective*: Open-source software is free to download and

use, reducing costs for individuals and organizations.

2. *Customizable*: Open-source software allows users to modify the code to

suit their specific needs.

3. *Community Support*: Open-source software has a large community of

developers and users who contribute to its development and provide
support.

4. *Security*: Open-source software is often more secure than proprietary

software, as the code is openly available for review and auditing.

*Examples of Open-Source Software*

1. *Linux*: An operating system.

2. *Apache*: A web server software.

3. *Mozilla Firefox*: A web browser.

4. *LibreOffice*: An office suite.

Installation of Linux OS

*Choosing a Linux Distribution*

1. *Ubuntu*: A popular and user-friendly distribution.

2. *Fedora*: A community-driven distribution with the latest software

packages.

3. *Debian*: A stable and secure distribution with a large community.

*Installation Steps*

1. *Download the ISO file*: Download the ISO file for the chosen Linux
distribution.

2. *Create a bootable USB drive*: Use a tool like Rufus to create a bootable
USB drive.

3. *Boot from the USB drive*: Restart the computer and boot from the USB
drive.

4. *Follow the installation prompts*: Follow the installation prompts to

complete the installation.

Deliverables

1. A working Linux installation on a virtual machine or physical machine.

2. A brief report explaining the significance of open-source platforms and the

steps taken to install the Linux OS.

Assessment

1. Understanding of open-source platforms (30%).

2. Successful installation of a Linux OS (40%).

3. Quality of the report and documentation (30%).

Lab 3: Tools of Study, Analyze, and Design Robotics; Installation of V-REP
CoppeliaSim

Goal

Explore tools used in robotics and install CoppeliaSim (formerly V-REP).

Introduction

Robotics simulation software enables researchers and engineers to design,

test, and analyze robotic systems in a virtual environment. CoppeliaSim is a
popular robotics simulation platform used for education, research, and
industry applications.

Tools of Study, Analyze, and Design Robotics

_Robotics Simulation Software_

1. _CoppeliaSim (V-REP)_: A widely used robotics simulation platform.

2. _Gazebo_: An open-source robotics simulation software.

3. _Webots_: A commercial robotics simulation software.

Installation of CoppeliaSim

_System Requirements_

1. _Operating System_: Windows, macOS, or Linux.

2. _Processor_: 64-bit processor.

3. _RAM_: 8 GB or more.

_Installation Steps_

4. _Download CoppeliaSim_: Download the latest version of CoppeliaSim from

the official website.

5. _Install CoppeliaSim_: Run the installer and follow the installation prompts.
6. _Verify Installation_: Launch CoppeliaSim and verify that it is working
correctly.

Getting Started with CoppeliaSim

_Tutorials and Resources_

1. _CoppeliaSim Tutorials_: Official tutorials provided by CoppeliaSim.

2. _User Manual_: Comprehensive user manual for CoppeliaSim.

3. _Community Forum_: Active community forum for CoppeliaSim users.

Deliverables

1. A working installation of CoppeliaSim.

2. A brief report explaining the tools used in robotics and the steps taken to
install CoppeliaSim.

Assessment

1. Understanding of robotics simulation software (30%).

2. Successful installation of CoppeliaSim (40%).

3. Quality of the report and documentation (30%).

f7

Basic Concepts

1. *Scene*: A scene in CoppeliaSim represents a 3D environment where

objects and robots can be simulated.

2. *Objects*: Objects in CoppeliaSim can be robots, shapes, or other 3D

models.

3. *Robots*: Robots in CoppeliaSim are special types of objects that can be

programmed to perform tasks.

4. *Joints*: Joints in CoppeliaSim connect objects and allow them to move

relative to each other.

Basic Commands
1. *Creating a New Scene*: To create a new scene, go to `File` > `New
Scene`.

2. *Adding Objects*: To add an object, go to `Insert` > `Object` and select

the desired object type.

3. *Selecting Objects*: To select an object, click on it in the scene hierarchy

or in the 3D view.

4. *Moving Objects*: To move an object, select it and use the `Move` tool or
press `Ctrl + M`.

5. *Rotating Objects*: To rotate an object, select it and use the `Rotate` tool
or press `Ctrl + R`.

6. *Scaling Objects*: To scale an object, select it and use the `Scale` tool or
press `Ctrl + S`.

7. *Running the Simulation*: To run the simulation, press the `Play` button or
press `F5`.

8. *Stopping the Simulation*: To stop the simulation, press the `Stop` button
or press `F6`.

Basic Scripting

1. *Creating a New Script*: To create a new script, go to `File` > `New

Script`.

2. *Writing Script Code*: CoppeliaSim uses Lua as its scripting language. You
can write Lua code in the script editor.

3. *Running the Script*: To run the script, press the `Run` button or press
`F5`.

Basic Sensors and Actuators

1. *Sensors*: Sensors in CoppeliaSim can detect changes in the environment,

such as collisions or proximity.

2. *Actuators*: Actuators in CoppeliaSim can control the movement of

objects, such as joints or wheels.
Basic Collision Detection

1. *Collision Detection*: CoppeliaSim can detect collisions between objects.

2. *Collision Response*: CoppeliaSim can respond to collisions by applying

forces or changing the object’s movement.

Basic Lighting and Rendering

1. *Lighting*: CoppeliaSim can simulate various lighting conditions, such as

daylight or artificial lighting.

2. *Rendering*: CoppeliaSim can render scenes in various modes, such as

wireframe or shaded.

Basic Physics Engines

1. *Physics Engines*: CoppeliaSim can simulate physics using various

engines, such as Bullet or ODE.

2. *Physics Properties*: CoppeliaSim can adjust physics properties, such as

friction or gravity.

These are the basic concepts and commands in CoppeliaSim. By mastering

these basics, you can create complex simulations and scenarios in
CoppeliaSim.
Scene Hierarchy

1. _Scene Hierarchy_: The scene hierarchy is a tree-like structure that

displays all objects in the scene.

2. _Object Selection_: Select an object in the scene hierarchy to view its

properties.

3. _Object Manipulation_: Use the scene hierarchy to rename, delete, or

reorder objects.

Object Properties
1. _Object Properties_: Each object in CoppeliaSim has properties that define
its behavior and appearance.

2. _Position and Orientation_: Set an object’s position and orientation using

the properties panel.

3. _Size and Scale_: Adjust an object’s size and scale using the properties
panel.

4. _Color and Texture_: Change an object’s color and texture using the
properties panel.

Joint Properties

1. _Joint Properties_: Joints connect objects and enable movement.

2. _Joint Types_: CoppeliaSim supports various joint types, such as revolute,

prismatic, and spherical.

3. _Joint Limits_: Set joint limits to restrict movement.

4. _Joint Motors_: Add motors to joints to control movement.

Sensor and Actuator Properties

1. _Sensor Properties_: Sensors detect changes in the environment.

2. _Sensor Types_: CoppeliaSim supports various sensor types, such as

proximity, collision, and vision.

3. _Actuator Properties_: Actuators control object movement.

4. _Actuator Types_: CoppeliaSim supports various actuator types, such as

joint motors and wheel motors.

Scripting

1. _Scripting Languages_: CoppeliaSim supports Lua, Python, and other

scripting languages.

2. _Scripting API_: Use the CoppeliaSim API to interact with objects, joints,
sensors, and actuators.
3. _Script Execution_: Execute scripts using the script editor or by attaching
them to objects.

Simulation Settings

1. _Simulation Settings_: Configure simulation settings, such as time step,

simulation speed, and physics engine.

2. _Simulation Modes_: Choose from various simulation modes, such as real-

time, accelerated, or stepped.

3. _Simulation Recording_: Record simulations for later playback or analysis.

Visualization

1. _Visualization_: Customize visualization settings, such as lighting, shading,

and rendering.

2. _Camera Settings_: Adjust camera settings, such as position, orientation,

and field of view.

3. _Object Visualization_: Customize object visualization, such as color,

texture, and transparency.

Collaboration

1. _Collaboration_: CoppeliaSim supports collaboration features, such as

multi-user editing and simulation.

2. _Remote Simulation_: Run simulations remotely using CoppeliaSim’s

remote simulation feature.

3. _Simulation Sharing_: Share simulations with others using CoppeliaSim’s

simulation sharing feature.

By mastering these concepts and commands, you’ll be able to create

complex simulations and scenarios in CoppeliaSim.
Creating the First Simulation

1. *Launch CoppeliaSim*: Open CoppeliaSim on your computer.

2. *Create a New Scene*: Go to `File` > `New Scene` to create a new scene.

3. *Add Objects*: Add objects to the scene by going to `Insert` > `Object`
and selecting the desired object type (e.g., cube, sphere, robot).
4. *Configure Object Properties*: Configure the properties of each object,
such as position, orientation, size, and color.

5. *Add Joints and Sensors*: Add joints and sensors to the objects as needed.

Running the Simulation

1. *Start the Simulation*: Press the `Play` button or press `F5` to start the
simulation.

2. *Adjust Simulation Settings*: Adjust simulation settings, such as time step,

simulation speed, and physics engine, as needed.

3. *Interact with the Simulation*: Interact with the simulation by clicking on

objects, adjusting joint values, or triggering sensors.

Saving the Simulation

1. *Save the Scene*: Go to `File` > `Save Scene` to save the scene.

2. *Choose a File Format*: Choose a file format, such as `.ttt` or `.scn`.

3. *Specify a File Name and Location*: Specify a file name and location for
the saved scene.

Recording the Simulation

1. *Start Recording*: Press the `Record` button or press `F9` to start

recording the simulation.

2. *Choose a Video Format*: Choose a video format, such as `.mp4` or `.avi`.

3. *Specify a File Name and Location*: Specify a file name and location for
the recorded video.

4. *Stop Recording*: Press the `Stop` button or press `F9` again to stop
recording.

Tips and Variations

- *Use the Scene Hierarchy*: Use the scene hierarchy to manage objects,
joints, and sensors.
- *Adjust Simulation Settings*: Adjust simulation settings to optimize
performance or achieve specific simulation goals.

- *Use Scripting*: Use scripting to automate simulation tasks, interact with

objects, or analyze simulation data.

- *Record Simulation Data*: Record simulation data, such as object positions,

joint values, or sensor readings, for later analysis.

Two-Link Planar Manipulator Modeling

*Introduction*
A two-link planar manipulator is a robotic arm with two joints that can move
in a two-dimensional plane. This type of manipulator is commonly used in
industrial robotics and is a fundamental concept in robotics.

*Modeling Requirements*

To model a two-link planar manipulator in CoppeliaSim, you will need to

create the following components:

1. *Base*: A fixed base that serves as the attachment point for the
manipulator.

2. *Link 1*: A revolute joint that connects the base to the first link.

3. *Link 2*: A revolute joint that connects the first link to the second link.

4. *End Effector*: A tool or gripper attached to the end of the second link.

*Modeling Steps*

1. *Create a New Scene*: Launch CoppeliaSim and create a new scene.

2. *Add a Base*: Insert a new object (e.g., a cube) to serve as the base.

3. *Add Link 1*: Insert a new object (e.g., a cylinder) to serve as the first link.
Attach a revolute joint to the base and link 1.

4. *Add Link 2*: Insert a new object (e.g., a cylinder) to serve as the second
link. Attach a revolute joint to link 1 and link 2.

5. *Add End Effector*: Insert a new object (e.g., a sphere) to serve as the end
effector. Attach it to the end of link 2.

*Joint Configuration*

1. *Revolute Joint 1*: Configure the revolute joint between the base and link
1 to have a range of motion (e.g., -180° to 180°).

2. *Revolute Joint 2*: Configure the revolute joint between link 1 and link 2 to
have a range of motion (e.g., -180° to 180°).
*Simulation Settings*

1. *Simulation Time Step*: Set the simulation time step to a suitable value
(e.g., 0.01 s).

2. *Physics Engine*: Select a suitable physics engine (e.g., Bullet Physics

Engine).

*Verification*

1. *Verify Joint Movement*: Verify that the joints move correctly when the
simulation is run.

2. *Verify End Effector Movement*: Verify that the end effector moves
correctly when the simulation is run.

By following these steps, you should now have a basic two-link planar
manipulator model in CoppeliaSim.
Modeling the Two-Link Planar Manipulator (Continued)

Adding Actuators to the Joints

1. _Select Joint 1_: Select the revolute joint between the base and link 1.

2. _Add an Actuator_: Go to `Insert` > `Actuator` > `Rotary Motor` to add a

rotary motor actuator to joint 1.

3. _Configure Actuator Properties_: Configure the actuator properties, such as

the maximum torque and velocity.

4. _Repeat for Joint 2_: Repeat the process for joint 2, adding a rotary motor
actuator to control the movement of link 2.

Adding Sensors to the Joints

1. _Select Joint 1_: Select the revolute joint between the base and link 1.

2. _Add a Sensor_: Go to `Insert` > `Sensor` > `Joint Position Sensor` to add
a joint position sensor to joint 1.
3. _Configure Sensor Properties_: Configure the sensor properties, such as
the measurement range and accuracy.

4. _Repeat for Joint 2_: Repeat the process for joint 2, adding a joint position
sensor to measure the position of link 2.

Creating a Control Script

1. _Create a New Script_: Go to `File` > `New Script` to create a new script.

2. _Write Control Code_: Write a control script that reads the sensor data and
controls the actuators to move the links to desired positions.

3. _Save and Attach Script_: Save the script and attach it to the manipulator
model.

Simulating the Manipulator

1. _Run the Simulation_: Press the `Play` button or press `F5` to run the
simulation.

2. _Verify Manipulator Movement_: Verify that the manipulator moves

correctly in response to the control script.

3. _Adjust Control Parameters_: Adjust the control parameters, such as the

gains and setpoints, to improve the performance of the manipulator.

Tips and Variations

- _Use Inverse Kinematics_: Use inverse kinematics to calculate the joint

angles required to move the end effector to a desired position.

- _Add Obstacles_: Add obstacles to the simulation environment to test the

manipulator’s ability to avoid collisions.

- _Use Different Control Strategies_: Use different control strategies, such as

PID control or model predictive control, to control the manipulator.

By following these steps, you should now have a complete two-link planar
manipulator model in CoppeliaSim, with actuators, sensors, and a control
script.
Differential Drive Car Modeling

Introduction

A differential drive car is a mobile robot that uses two wheels to move
around. The wheels are powered by separate motors, allowing the car to turn
and move in different directions.

Modeling Requirements

To model a differential drive car in CoppeliaSim, you will need to create the
following components:
1. _Chassis_: A rectangular body that represents the car’s main structure.

2. _Wheels_: Two circular objects that represent the car’s wheels.

3. _Motors_: Two motor objects that power the wheels.

4. _Joints_: Two revolute joints that connect the wheels to the chassis.

Modeling Steps

*Step 1: Create the Chassis*

1. _Insert a new object_: Go to `Insert` > `Object` > `Rectangular` to create

a new rectangular object.

2. _Configure the chassis properties_: Set the chassis’s dimensions, color,

and other properties as desired.

*Step 2: Create the Wheels*

1. _Insert two new objects_: Go to `Insert` > `Object` > `Circular` to create
two new circular objects.

2. _Configure the wheel properties_: Set the wheels’ dimensions, color, and
other properties as desired.

*Step 3: Create the Motors*

1. _Insert two new motor objects_: Go to `Insert` > `Actuator` > `Rotary
Motor` to create two new rotary motor objects.

2. _Configure the motor properties_: Set the motors’ properties, such as their
maximum torque and velocity.

*Step 4: Create the Joints*

1. _Insert two new revolute joints_: Go to `Insert` > `Joint` > `Revolute` to
create two new revolute joints.
2. _Configure the joint properties_: Set the joints’ properties, such as their
axis of rotation and limits.

*Step 5: Assemble the Car*

1. _Attach the wheels to the chassis_: Use the revolute joints to attach the
wheels to the chassis.

2. _Attach the motors to the wheels_: Use the motor objects to power the
wheels.

Simulation Settings

1. _Simulation time step_: Set the simulation time step to a suitable value
(e.g., 0.01 s).

2. _Physics engine_: Select a suitable physics engine (e.g., Bullet Physics

Engine).

Verification

1. _Verify the car’s movement_: Run the simulation and verify that the car
moves correctly.

2. _Verify the wheels’ rotation_: Verify that the wheels rotate correctly when
the motors are powered.
Differential Drive Car Modeling (Continued)

Adding Sensors and Control Systems

1. _Add sensors_: Add sensors to the car to measure its position, orientation,
and velocity.

- Go to `Insert` > `Sensor` > `Position Sensor` to add a position sensor.

- Go to `Insert` > `Sensor` > `Orientation Sensor` to add an orientation

sensor.

- Go to `Insert` > `Sensor` > `Velocity Sensor` to add a velocity sensor.

2. _Add control systems_: Add control systems to the car to control its
movement.

- Go to `Insert` > `Actuator` > `PID Controller` to add a PID controller.

- Configure the PID controller’s properties, such as its gains and setpoints.

Modeling the Car’s Kinematics

1. _Define the car’s kinematic parameters_: Define the car’s kinematic

parameters, such as its wheelbase and track width.

2. _Create a kinematic model_: Create a kinematic model of the car using the
defined parameters.

- Go to `Insert` > `Model` > `Kinematic Model` to create a new kinematic

model.

- Configure the kinematic model’s properties, such as its joint types and
limits.

Adding a Control Script

1. _Create a new script_: Go to `File` > `New Script` to create a new script.

2. _Write control code_: Write control code to control the car’s movement
using the sensors and control systems.
 - Use the CoppeliaSim API to read sensor data and control the car’s
movement.

3. _Save and attach script_: Save the script and attach it to the car model.

Simulating the Car’s Movement

1. _Run the simulation_: Press the `Play` button or press `F5` to run the
simulation.

2. _Verify the car’s movement_: Verify that the car moves correctly in
response to the control script.

3. _Adjust control parameters_: Adjust the control parameters, such as the

PID gains and setpoints, to improve the car’s movement.

Tips and Variations

- _Use different sensor types_: Use different sensor types, such as lidar or
camera sensors, to improve the car’s perception and control.

- _Add obstacles and challenges_: Add obstacles and challenges to the

simulation environment to test the car’s control and navigation abilities.

- _Use machine learning algorithms_: Use machine learning algorithms, such

as reinforcement learning or deep learning, to improve the car’s control and
navigation abilities.
Designing and simulating a robotic arm in CoppeliaSim involves several
steps. First, you need to create a new scene and add objects to represent the
robotic arm’s links and joints ¹. You can use the “Insert” menu to add objects,
such as cylinders or rectangular shapes, to represent the arm’s links.

*Kinematic Modeling*

Next, you need to define the kinematic properties of the robotic arm,
including the joint types, limits, and dependencies ¹. CoppeliaSim supports
various joint types, including revolute, prismatic, and spherical joints. You
can also define the arm’s kinematic parameters, such as the link lengths and
joint angles.

*Control Systems*

To control the robotic arm, you need to add control systems, such as PID
controllers or fuzzy logic controllers ² ³. CoppeliaSim supports various control
systems and allows you to customize them to suit your needs.

*Simulation and Testing*

Once you have designed and configured the robotic arm, you can simulate
its movement and test its performance ¹. CoppeliaSim allows you to simulate
various scenarios, including obstacle avoidance and trajectory planning.

*Customization and Extensions*

CoppeliaSim also allows you to customize and extend the robotic arm’s
functionality using plugins and scripts ¹. You can write custom scripts in
languages like Python or Lua to control the arm’s movement and interact
with its environment.

Overall, designing and simulating a robotic arm in CoppeliaSim requires a

combination of kinematic modeling, control systems design, and simulation
testing. By following these steps and leveraging CoppeliaSim’s features and
customization options, you can create a realistic and functional robotic arm
simulation.