Guide.txt

-------------------------------------------------------------------------------------------------------
Page-1 : Robot Simulator
-------------------------------------------------------------------------------------------------------
This guide is for creating own robot simulator . 


DISCLAIMER
This is a small initive for steping towards AI  , use of most widly popular computer language PYTHON for everybody who are involve in robotics in our country and are just wandering with embedded system and mechanics .

I hope to colaborate with you
Santosh Dahal



What is robot simulator ? 

The digital version of your robot iniside computer , where you can operate , test your algorithm before using on real robot . 

What are benefits of own robot simulator ? 

There are other simulator around like ROS , V-REP. They consist of high level of abstraction and own hardware which are expensive . By using this simulator you can make your robot intelligence with help of your own computer.

This course is designed as a guide for all the robotics enthugist outside there who are interested for making their robot intelligence and get yourself updated with robotics trends and technology. 

-------------------------------------------------------------------------------------------------------------
Page-2 : GUI application
-------------------------------------------------------------------------------------------------------------

Simulator is same as other GUI application with  algorithms used in robotics and contain diffrerent robotic model in which you can play around.

So ,first we will follow the procedure for creating simple GUI application.

1) Opening a window

    import 	pygame

    pygame.init()

    screen = pygame.display.set_mode((640,480))

First of all, to use pygame we have to import it. Then we create a Surface that is 640 pixels wide and 400 pixels high. There are a lot more things you can do with set_mode, but we will keep it simple at this point.

This code give you the window open for limited period of time.We have to add inifinite loop so the program never gets close without user wish.


2) Break to exit


   running = True
   while running:
      for event in pygame.event.get():
            if event.type == pygame.QUIT:
               running = false
            if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
               running = flase


The loop is controlled by a flag called running. As long as the flag is set the loop keeps running. Inside the loop we use the get() method to grab the  event that occur since next execution. 

There are several different event types that pygame knows about and can respond to. One of these is QUIT and KEYDOWN 
QUIT : Gets triggered when the user clicks on the window’s close button.

KEYDOWN : Gets triggered when the user any keyboard button.When we recieve a KEYDOWN event, the event object will hold the code of the key that was pressed in an attribute called ‘key’. So by comparing event.key to whichever key we are interested in, we can find out if that was the actual key that was pressed.

All we do if we get an event of this type is clear the running flag, which will exit the loop and cause the program to terminate. Still simple, isn’t it.




3) Structuring Program

import pygame

class Simulator(object):
	def main(self , screen):
		while 1:
          for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 return
             if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                 return

              

if __name__ == '__main__':
	pygame.init()
	screen = pygame.display.set_mode((640,480))
    Simulator().main(screen)

We have clean our code and apply OOP concept . If you are not familiar with OOP , please prepare yourself about class , object .How to initilize  and create them. 

--------------
EXECRISE:
--------------
1. Create a window that is 320 pixels wide and 200 pixels high.
2. Create a program where the user can specify the width and the height as command line arguments.
3. Create a program that asks the users for the width and the height and then displays the window.
4. Write a program that calls pygame.display.set_mode twice with different sizes. What do you expect should  happen? Run the program. What actually happens? Can you explain why?

------------------------------------------------------------------------------------------------------------
page-3 : Drawing into Screen
-------------------------------------------------------------------------------------------------------------
4) Drawing into Screen

import pygame

class Simulator(object):
	def main(self , screen):
		robot = pygame.image.load("car60_40.png")
		
		while 1:
			for event in pygame.event.get():
				if event.type == pygame.QUIT:
					return
				if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
					return
			screen.blit(robot,(320,240))
			pygame.display.flip()


if __name__ == '__main__':
	pygame.init()
	screen = pygame.display.set_mode((640,480))
	Simulator().main(screen)

The next thing that is new is that we call pygame.display.flip. Drawing directly to the screen is usually a very bad idea. Instead, we have a invisible buffer that we draw onto. When we have finished drawing we make the buffer visible. That way we get flicker-free animations 


5) Set Background Color

red = (200, 0, 0)
blue = (0, 0, 255)
green = (0, 155, 0)
yellow = (155, 155, 0)
white = (255, 255, 255)
black = (0, 0, 0) 

screen.fill(white)

We have passed in a sequence of three values: red, green and blue. Each one can be a value between 0 and 255. Since we set all to zero, we get a black screen. You should experiment with different values for red, green and blue.


6) Using Less CPU

clock = pygame.time.Clock()
clock.tick(30)


--------------
EXECRISE:
--------------
1. Create a window with a white background color.
2. Create a window with a red background color.
3. Experiment with setting different background colors. If you are not familiar with RGB values then spend a little extra time to figure out how to get colors like yellow, brown, cyan etc.
4. Create a program that asks the user to specify the values for red, green and blue. Check that the values are in the valid range (0-255) and then use these for the background color.
5.Create a program that upon start-up checks the time of the day and sets the brightness of the background color accordingly. Use a blue scale. If it is midnight, the screen should be black. If it is midday, the screen should be bright blue. Any other time the background should be something in between corresponding to the brightness outside.


--------------------------------------------------------------------------------------------------------------
page-4 : Moving things
--------------------------------------------------------------------------------------------------------------

7) Moving along x

import pygame

"""Define color"""
red = (200, 0, 0)
blue = (0, 0, 255)
green = (0, 155, 0)
yellow = (155, 155, 0)
white = (255, 255, 255)
black = (0, 0, 0)

class Simulator(object):
	def main(self , screen):
		clock = pygame.time.Clock()
		robot = pygame.image.load("car60_40.png")
		robot_x = 320
		robot_y = 240
		while 1:
			clock.tick(30)
			for event in pygame.event.get():
				if event.type == pygame.QUIT:
					return
				if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
					return
			screen.fill(white)
			robot_x += 1
			screen.blit(robot,(robot_x,robot_y))
			pygame.display.flip()


if __name__ == '__main__':
	pygame.init()
	pygame.display.set_caption("Move")
	screen = pygame.display.set_mode((640,480))
	Simulator().main(screen)

We have separate variable for robot x & y position , so we can manipulate in runtime.


8) Organizing Robot into class

We will build class for mobile robot . Think what property of car is essential for imagining it in plane coordinate.

We need x and y co-ordinate for it's position and angle for it's orientation

class robot:
	def __init__(self):
		self.x = 0
		self.y = 0
		self.orientation = 0

	def set(self, x, y,orientation):
		self.x = x
		self.y = y
		self.orientation = orientation

	def move(self, turn, x,y):
		self.orientation = self.orientation + turn
		self.x = self.x + x
		self.y = self.y - y

	def draw(self):
		car_img = pygame.image.load("car60_40.png")
		img = pygame.transform.rotate(car_img, self.orientation)
		screen.blit(img, (self.x, self.y))

class Simulator(object):
	def main(self , screen , robot):
		clock = pygame.time.Clock()
		robot.draw()
		x = 0
		y = 0
		orientation = 0
		while 1:
			clock.tick(30)
			screen.fill(white)
			for event in pygame.event.get():
				if event.type == pygame.QUIT:
					return
				if event.type == pygame.KEYDOWN:
					if event.key == pygame.K_LEFT:
						x = -1
					elif event.key == pygame.K_RIGHT:
						x = 1
					elif event.key == pygame.K_UP:
						y = 1
					elif event.key == pygame.K_DOWN:
						y = -1
					elif event.key == pygame.K_a:
						orientation = -1
					elif event.key == pygame.K_d:
						orientation = 1
				elif event.type == pygame.KEYUP:
					if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT or event.key == pygame.K_UP or event.key == pygame.K_a or event.key == pygame.K_d or event.key == pygame.K_DOWN:
						x = 0
						y = 0
						orientation = 0 
			robot.move(orientation , x , y)
			robot.draw()
			pygame.display.flip()


robot = robot()
Simulator().main(screen , robot)

-------------------------------------------------------------------------------------------------------------
page-5 : Building Real Model
-------------------------------------------------------------------------------------------------------------

9) Building Real Model 

In real car does not move in such manner . We must apply some of the math we read in school to have work it like real life.

We only apply orientation and accelaration as forward to the car . But how can we move our car in real manner see the code below, if you didn't get it contact me. 

	def move(self, turn, forward):
		self.orientation = self.orientation + turn
		#cos value 0degree->1 , 90degree->0, 180degree->-1
		#we must pass degree in radian
		self.x = self.x + forward*cos(self.orientation*pi/180)
		#sin value 0degree->0 , 90degree->1, 180degree->0
		#we must pass degree in radian
		self.y = self.y - forward*sin(self.orientation*pi/180)


10) Move within the boundary

		self.orientation %= 360
		self.x %= world_size
		self.y %= world_size

The above code simply bound robot inside window i.e robot will come out of opposite side if it crossover one of the side .