def load(self, songPath):
# Load projectiles
self._laser = Laser(self._windowWidth * 1.5)
# Load player
self._playerSpawnPos = (self._windowWidth / 2, self._windowHeight / 2)
self._player = Player(ContentManager.load_image('media/actors/player.png'), self._laser, self._playerSpawnPos)
self._playerGroup.add(self._player)
# Load HUD
fontPath = 'media/fonts/freesansbold.ttf'
self._font = ContentManager.load_font(fontPath, 36)
self._scoreSprite = TextSprite(self._font, pygame.Color('white'), (30, 30))
self._livesSprite = TextSprite(self._font, pygame.Color('white'), (30, 70))
self._livesSprite.updateText('Lives: ' + str(self._lives))
self._hudGroup.add(self._scoreSprite, self._livesSprite)
# Load music configuration
#songPath = 'media/music/battlefield1942'
#songPath = 'media/music/test'
# Load game director
self._gameDirector = GameDirector(self)
self._gameDirector.load(self._player, songPath)
# Load music
self._musicPlayer = MusicPlayer()
self._musicPlayer.load(songPath + '.mid')
self._musicPlayer.play()
def shoot(event): #fire a laser at each space bar click
global lasers, shots, player
if event.char == ' ': #if the space bar button is clicked, fire
lasers[shots] = Laser(canvas, player.getRightSide(),
player.getTopSide() + player.getHeight() //
2) #create the laser at the front of the ship
#######################################laser sound#############################
lasers[shots].shoot() #animate the laser forward
shots += 1
if shots == 10: #reset the laser object list index
shots = 0
def updatePlayerData(self, gdInfo): # Extract the information about the players p1data = gdInfo.p1data p2data = gdInfo.p2data # Update Player 1 xpos = p1data.x_pos ypos = p1data.y_pos angle = p1data.angle GS.Player1.curAngle = angle GS.Player1.rect.top = ypos GS.Player1.rect.left = xpos GS.Player1.image = pygame.transform.rotate(GS.Player1.orig_image, angle) GS.Player1.rect = GS.Player1.image.get_rect(center = GS.Player1.rect.center) if p1data.newLaser != 0: Laser1 = Laser() Laser1.go(GS.Player1.rect.centerx, GS.Player1.rect.centery, angle, "laser1.png") GS.laserList.append(Laser1) #Update health of other player GS.Player1.health = gdInfo.p1data.health # Update Player 2 xpos = p2data.x_pos ypos = p2data.y_pos angle = p2data.angle GS.Player2.curAngle = angle GS.Player2.rect.top = ypos GS.Player2.rect.left = xpos GS.Player2.image = pygame.transform.rotate(GS.Player2.orig_image, angle) GS.Player2.rect = GS.Player2.image.get_rect(center = GS.Player2.rect.center) if p2data.newLaser != 0: Laser2 = Laser() Laser2.go(GS.Player2.rect.centerx, GS.Player2.rect.centery, angle, "laser2.png") GS.laserList.append(Laser2)
def __init__(self, director, player):
Level.__init__(self, director, player)
self.player.rect.x = 224
self.player.rect.y = 1273
self.laser0 = Laser(80, 340, 'laser_45.png')
self.laser1 = Laser(400, 75, 'laser_45.png')
self.laser2 = Laser(405, 332, 'laser_180.png')
self.laser3 = Laser(80, 330, 'laser_180.png')
self.laser4 = Laser(406, 341, 'laser_125.png')
self.laser5 = Laser(80, 80, 'laser_125.png')
self.laser6 = Laser(400, 350, 'laser_90.png')
self.laserArray = [
self.laser0, self.laser1, self.laser2, self.laser3, self.laser4,
self.laser5, self.laser6
]
self.laserGroup = EntityGroup([])
self.laserGroup.add(self.laser0, self.laser1, self.laser2, self.laser3,
self.laser4, self.laser5, self.laser6)
self.groups.append(self.laserGroup)
self.laser0.active = False
self.laser1.active = False
self.activeLG = 1 # Pair of lasers active at a given time
self.time = 0
self.page = Page(408, 135, self.player, director)
self.enemyGroup.add([
FutureSoldier(141, 1084, self.player, director),
# FutureSoldier(316, 1084, self.player, director),
# FutureSoldier(141, 926, self.player, director),
FutureSoldier(316, 926, self.player, director),
FutureSoldier(686, 1260, self.player, director),
FutureSoldier(508, 988, self.player, director),
FutureSoldier(537, 1450, self.player, director),
self.page
])
self.bg = load_image("map_page_img.png", Constants.MAP_DIR)
self.collisionBg = load_image("map_page_bg.png", Constants.BG_MAP_DIR)
self.invisibleFloor = InvisibleFloor(
384, 202, 59, 78) # Invisible sprite, it functions as a trigger
self.invisibleFloorG = EntityGroup([])
self.invisibleFloorG.add(self.invisibleFloor)
self.groups.append(self.invisibleFloorG)
load_music("level_four.s3m")
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
player.setWeapons([WpnBlade("lightsaber.png", -1, pygame.Rect(128, 77, 42, 42), "sthswng1.wav", 0.2), \
WpnLaser()])
def initCaster(wrappedMap,mapInfo):
offset_x =mapInfo.origin.position.x
offset_y =mapInfo.origin.position.y
resolution = mapInfo.resolution
#Parameters of the laser
max_range = 50.0
no_of_beams = 181
min_angle = -math.pi/2.0
resolution_angle = math.pi/(no_of_beams-1)
noise_variance = 0.0#perfect
map_obj = Map(mapInfo.height, mapInfo.width, offset_x, offset_y, resolution, wrappedMap)
laser = Laser(max_range, min_angle, resolution_angle, no_of_beams, noise_variance, map_obj)
return laser
def initPeriph(self):
"""
Initialise tout les périphériques servant à l'application (Laser, Servos, Manette nunchuk...) et instancie les objets globals.
"""
try:
# GPIOs
Methods.writeFile("/sys/class/gpio/export", "66", "a")
Methods.writeFile("/sys/class/gpio/export", "69", "a")
Methods.writeFile("/sys/class/gpio/export", "45", "a")
# PWMs
Methods.writeFile("/sys/devices/bone_capemgr.8/slots", "am33xx_pwm", "a")
# UART
Methods.writeFile("/sys/devices/bone_capemgr.8/slots", "BB-UART1", "a")
sleep(2)
except IOError:
print "La configuration des périphériques a déjà été faites"
# Création du laser
self.laser = Laser(45)
# Création de la gestion d'indication des modes
self.modeObj = Mode(66, 69)
# Création des servos
self.verticalServo = Servo("P9_14", "10", False)
self.horizontalServo = Servo("P9_22", "11", True)
# Création de l'UART
self.uart = UART()
# Création du Nunchuk
try:
self.nunchuk = Nunchuk()
self.nunchukIsConnected = True
except IOError:
print "Erreur de connexion avec la manette \"Nunchuk\""
self.nunchukIsConnected = False
class GameRound:
START_LIVES = 3
def __init__(self, noteWars, windowWidth, windowHeight):
self._noteWars = noteWars
self._windowWidth = windowWidth
self._windowHeight = windowHeight
self._enemiesGroup = pygame.sprite.Group()
self._enemyDelaySec = 3.0
self._enemyElapsedDelaySec = 0.0
self._playerGroup = pygame.sprite.GroupSingle()
self._hudGroup = pygame.sprite.Group()
self._score = 0
self._lives = self.START_LIVES
def load(self, songPath):
# Load projectiles
self._laser = Laser(self._windowWidth * 1.5)
# Load player
self._playerSpawnPos = (self._windowWidth / 2, self._windowHeight / 2)
self._player = Player(ContentManager.load_image('media/actors/player.png'), self._laser, self._playerSpawnPos)
self._playerGroup.add(self._player)
# Load HUD
fontPath = 'media/fonts/freesansbold.ttf'
self._font = ContentManager.load_font(fontPath, 36)
self._scoreSprite = TextSprite(self._font, pygame.Color('white'), (30, 30))
self._livesSprite = TextSprite(self._font, pygame.Color('white'), (30, 70))
self._livesSprite.updateText('Lives: ' + str(self._lives))
self._hudGroup.add(self._scoreSprite, self._livesSprite)
# Load music configuration
#songPath = 'media/music/battlefield1942'
#songPath = 'media/music/test'
# Load game director
self._gameDirector = GameDirector(self)
self._gameDirector.load(self._player, songPath)
# Load music
self._musicPlayer = MusicPlayer()
self._musicPlayer.load(songPath + '.mid')
self._musicPlayer.play()
def spawnEnemy(self, enemy):
spawnSide = int(random.uniform(0, 4))
spawnDistance = random.random()
spawnX = 0
spawnY = 0
if spawnSide == 0: # Left side
spawnX = 0
spawnY = self._windowHeight * spawnDistance
elif spawnSide == 1: # Top side
spawnX = self._windowWidth * spawnDistance
spawnY = 0
elif spawnSide == 2: # Right side
spawnX = self._windowWidth
spawnY = self._windowHeight * spawnDistance
else: # Bottom side
spawnX = self._windowWidth * spawnDistance
spawnY = self._windowHeight
enemy.setPosition((spawnX, spawnY))
self._enemiesGroup.add(enemy)
def update(self, elapsedTimeSec):
self._enemyElapsedDelaySec += elapsedTimeSec
# Check for collisions
self._checkCollisions()
# Update game entities
self._playerGroup.update(elapsedTimeSec)
self._enemiesGroup.update(elapsedTimeSec)
self._hudGroup.update(elapsedTimeSec)
# Invoke game director
self._gameDirector.update(elapsedTimeSec)
# Check whether the user wants to exit the game
pressedKeys = pygame.key.get_pressed()
if pressedKeys[K_BACKSPACE]:
self._exitRound()
def stop(self):
self._musicPlayer.stop()
self._gameDirector.stop()
def _handlePlayerDeath(self):
self._lives -= 1
if self._lives < 0:
self.stop()
self._noteWars.goToMainMenuWithLose(self._score)
else:
self._livesSprite.updateText('Lives: ' + str(self._lives))
self._enemiesGroup.empty()
self._player.setPosition(self._playerSpawnPos)
def roundComplete(self):
self.stop()
self._noteWars.goToMainMenuWithWin(self._score)
def _exitRound(self):
self.stop()
self._noteWars.goToMainMenu()
def _checkCollisions(self):
# Check collisions between laser and enemies
collidedEnemies = []
if self._laser.isFiring():
for enemy in self._enemiesGroup.sprites():
if CollisionMethods.collideLineToRect(self._laser.getFiredFromPos(),
self._laser.getFiredToPos(),
enemy.rect):
collidedEnemies.append(enemy)
self._score += len(collidedEnemies) * 100
self._scoreSprite.updateText('Score: ' + str(self._score))
for enemy in collidedEnemies:
enemy.kill()
# Check collisions between player and enemies
collidedEnemies = pygame.sprite.spritecollide(self._player, self._enemiesGroup, True, CollisionMethods.collideRectThenMask)
if collidedEnemies:
self._handlePlayerDeath()
def draw(self, screen):
self._laser.draw(screen)
self._playerGroup.draw(screen)
self._enemiesGroup.draw(screen)
[text.render() for text in self._hudGroup.sprites()]
self._hudGroup.draw(screen)
# coding:utf-8 from Laser import Laser laser = Laser(com="COM3") laser.start() laser.main_loop()
asteroid_image2 = pygame.transform.scale(asteroid_image2, (40, 64))
asteroid_image2 = asteroid_image2.convert()
asteroid_image3 = pygame.image.load('asteroidimage3.png').convert()
asteroid_image2.set_colorkey((255, 0, 255))
asteroid_image2 = pygame.transform.scale(asteroid_image2, (40, 64))
asteroid_image2 = asteroid_image2.convert()
laser_image = pygame.image.load('laserimage.png').convert()
# ship_image.set_colorkey((255,255,255))
# screen.blit(ship_image,(0,0))
ship = Ship()
asteroids = Group()
asteroids.add(Asteroid())
comets = Group()
comets.add(Comet())
lasers = Group()
lasers.add(Laser(ship))
start_button = Start_Button(pygame_screen)
while running:
tick += 1
if tick % 30 == 0:
asteroids.add(Asteroid())
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
# print (event.key)
if event.key == 275:
ship.should_move("right")
elif event.key == 276:
ship.should_move("left")
def spawn(self, x, y, direction, obj):
self.lasers.append(Laser(x, y, direction, self.image, obj))
def shoot(self):
if self.cool_down_counter == 0:
laser = Laser(self.x+25, self.y, self.laser_img)
self.lasers.append(laser)
self.cool_down_counter = 1
class PRESURE(BMP085):
relative_altitude = 0
def Get_Origin_Altitude(self): #获取原始高度
Origin_Altitude = BMP085(0x77, 3).readAltitude()
return Origin_Altitude
def Get_relative_altitude(self): #计算相对高度
self.relative_altitude = BMP085(0x77, 3).readAltitude() - self.Get_Origin_Altitude() #相对高度 = 实时高度 - 原始高度
if(self.relative_altitude<1): #相对高度小于1时不计算
self.relative_altitude = 0
try: #初始化两个激光测距模块
i = 0
j = 0
laser = Laser(debug = False)
while (i<20): #循环测试20次
laser.fastMeasure_1()
i = i+1
value_laser_1 = laser.fastMeasure_1()
while (j<20): #循环测试20次
laser.fastMeasure_2()
j = j+1
value_laser_2 = laser.fastMeasure_2()
print "DBG: The init laser1 data is %.2f m" % value_laser_1
print "DBG: The init laser2 data is %.2f m" % value_laser_2
except:
print("Laser init error")
#sys.exit(0)
try: #初始化大气压传感器
bmp = PRESURE(0x77, 3, debug = False) # ULTRAHIRES Mode
def Fire(self):
shot = Laser((self.rect[0] + self.ship_midwidth, self.rect[1]),
self.firecolor, self.shotlength, self.firespeed,
self.rect[1], 15)
return shot
".png")
showLives = canvas.create_image(canvas.winfo_reqwidth() - imgLives[0].width() +
5,
50,
image=imgLives[lives - 1])
#text showing points
showPoints = canvas.create_text(30,
10,
text='Spacebar',
font="neuropol.ttf 30",
fill="orange",
anchor="nw")
background_timer() #background animation timer
player = Spaceship(canvas) #create a player spaceship object
lasers = [Laser(canvas)] * 10 #list of laser objects
asteroids = [Asteroid(canvas)] * 20 #list of asteroid objects
spawnasteroid()
root.bind("<Motion>",
onmousemove) #event handling for cursor movement and keyboard clicks
root.bind("<KeyRelease>", shoot)
hit_asteroid() #collision detection and health loss detection
hit_ship()
lose_health()
root.mainloop() #loop the game window to keep it on
def move(self): #wasd 이동키
pressed = pygame.key.get_pressed()
if self.left <= 400 and self.Start == False:
self.Num = 1
elif self.left < self.topBU:
self.topBU = self.left
self.Num = 1
else:
self.topBU = self.left
self.Num = 0
if self.Start == False:
if pressed[pygame.K_UP] != 1 and pressed[pygame.K_DOWN] != 1:
if self.left <= 800:
self.left += 10
if pressed[pygame.K_UP]:
if (400 < self.left):
self.left -= 15
if pressed[pygame.K_DOWN]:
if (self.left < 800):
self.left += 15
if pressed[pygame.K_RIGHT]:
if (self.top < 600):
self.top += 15
if pressed[pygame.K_LEFT]:
if (0 < self.top):
self.top -= 15
if pressed[pygame.K_SPACE]: # 스페이스바를 눌렀을 경우
if self.shot_flag: # 먼저 shot_flag의 값 확인(초기에 True로 설정)
if self.weapon == "Sector":
self.sector_shot()
self.shot_flag = False
elif self.weapon == "Normal":
self.shot() # 화살이 생성됨
self.shot_flag = False
elif self.weapon == "Laser":
laser = Laser(self.screen, self.top - 25, self.left,
self.lasertime, self.lasernum)
if self.charge == 0:
self.laser_shot()
self.charge = 50
self.shot_flag = False
if self.lasertime != 2:
self.lasertime = 2
self.lasernum = 0
else:
if self.lasertime == 0:
self.lasernum += 1
self.lasertime = 2
else:
self.lasertime -= 1
if self.lasernum == 13:
self.lasernum = 0
laser.charge()
self.charge -= 1
else:
self.charge = 50
self.lasertime = 2
self.lasernum = 0
self.shot_flag = True
if pressed[pygame.K_x]:
if self.weapon_flag:
if self.weapon == "Normal":
self.menuX = 580
self.weapon = "Sector"
elif self.weapon == "Sector":
self.menuX = 630
self.weapon = "Laser"
elif self.weapon == "Laser":
self.menuX = 530
self.weapon = "Normal"
self.weapon_flag = False
elif pressed[pygame.K_z]:
if self.weapon_flag:
if self.weapon == "Normal":
self.menuX = 630
self.weapon = "Laser"
elif self.weapon == "Sector":
self.menuX = 530
self.weapon = "Normal"
elif self.weapon == "Laser":
self.menuX = 580
self.weapon = "Sector"
self.weapon_flag = False
else:
self.weapon_flag = True
elif self.Start == True:
self.left += 0
else:
if self.left <= 800:
self.left += 10
for sector in self.arrows:
if sector.name == "Sector":
if sector.timer >= 8:
self.arrows.remove(sector)
for arrow in self.arrows:
arrow.move() #화살이 날아감
if self.collidercheck == False:
image = pygame.Surface((100, 100))
image.blit(self.playerlist[self.Num], (0, 0))
image.set_colorkey((0, 0, 0))
image.set_alpha(self.alpha)
self.screen.blit(image, (self.top - 25, self.left))
if self.alpha == 255 and self.playertimer == 0:
self.alpha = 0
self.playertimer = 3
else:
self.playertimer -= 1
self.alpha = 255
elif self.collidercheck == True:
self.screen.blit(self.playerlist[self.Num],
(self.top - 25, self.left))
def playgame(game):
# Repainting screen
game.clear_screen()
# draw ship
game.player.render()
# Display game stats
game.display_game_stats()
# Event player dies
if game.player.health <= 0:
game.gameover = True
# sound effect gameover
game.sfx['gameover'].play()
# TODO add game over when time runs out in game, Limit Time is 30
# game.playtime --> variable tracks time in game
# Events with user input
# if pressed keys is left
if game.pressedkeys[pygame.K_LEFT]:
game.player.move_left(game.seconds)
# if pressed keys is right
if game.pressedkeys[pygame.K_RIGHT]:
game.player.move_right(game.seconds)
# if pressed keys is down
if game.pressedkeys[pygame.K_DOWN]:
game.player.move_down(game.seconds)
# if pressed keys is up
if game.pressedkeys[pygame.K_UP]:
game.player.move_up(game.seconds)
# if pressed keys is space
if game.pressedkeys[pygame.K_SPACE]:
# when delay is done, player can shoot
if game.player.can_shoot() == True:
# laser is spawned
laser = Laser(game.player.pos_x, game.player.pos_y, game.screen)
game.lasers.append(laser)
# sound effect laser
game.sfx['laser'].play()
# TODO player can shoot with a different key, Key = 1
# Look at example above, we can shoot with the space key
# You can copy down code too!
# TODO create laser_damage variable with the value of 25
# updates laser
for laser in game.lasers:
bounds = laser.update(game.seconds)
if bounds is False:
# deletes laser from game once it is out of the screen
game.lasers.remove(laser)
else:
# laser hits one of the enemies
hit = laser.hit(game.enemies)
if hit:
# laser is deleted
game.lasers.remove(laser)
# health enemy goes down
hit.health = hit.health - 25
# sound effect hit
game.sfx['hit'].play()
# updates enemy laser
for laserEnemy in game.lasersEnemy:
bounds = laserEnemy.update(game.seconds)
if bounds is False:
# deletes laser from game once it is out of the screen
game.lasersEnemy.remove(laserEnemy)
else:
# laser hits the player
hit = laserEnemy.hit(game.player.pos_x, game.player.pos_y)
if hit:
# laser is deleted
game.lasersEnemy.remove(laserEnemy)
# health player goes down
game.player.health = game.player.health - 25
# sound effect hit
game.sfx['hit'].play()
# updates enemy
for enemy in game.enemies:
enemy.update(game.seconds)
# enemy dies at zero HP
if enemy.health <= 0:
# enemy is deleted
game.enemies.remove(enemy)
game.score = game.score + 50
# sound effect explosion
game.sfx['explosion'].play()
# if enemy can shoot, shoot
if enemy.can_shoot():
laserEnemy = LaserEnemy(enemy, game.screen)
game.lasersEnemy.append(laserEnemy)
# when all enemies die, level up!
if len(game.enemies) == 0:
game.level_up()
# TODO add to game score when level up, value of 50
offset_x = 0.0
offset_y = 0.0
resolution = 0.1
# Create map and laser scans
occ_map = Map.readFromTXT('../map.txt', width, height, offset_x, offset_y,
resolution)
max_range = 50.0
no_of_beams = 181
min_angle = -math.pi / 2.0
resolution_angle = math.pi / (no_of_beams - 1)
noise_variance = 0.0
laser_pos_x = 1.2
laser_pos_y = 0.0
laser_angle = 0.0 * (math.pi / 180.0)
laser = Laser(max_range, min_angle, resolution_angle, no_of_beams,
noise_variance, occ_map, laser_pos_x, laser_pos_y, laser_angle)
# load positions
positions = np.loadtxt('../data_pose.txt')
# load laser
ranges = np.loadtxt('../map_scans.txt')
assert (positions.shape[0] == ranges.shape[0])
n = 5
# sample n random scans from
pidx = np.random.randint(0, positions.shape[0], n)
sum_mse = 0
clump = 11
# Generate scans with python and compare
background_image = pygame.image.load('background1.png')
ship_image = pygame.image.load('shipimage.png')
comet_image = pygame.image.load('cometimage.png')
candy_image = pygame.image.load('candyimage.png')
asteroid_image1 = pygame.image.load('asteroidimage1.png')
asteroid_image2 = pygame.image.load('asteroidimage2.png')
asteroid_image3 = pygame.image.load('asteroidimage3.png')
laser_image = pygame.image.load('laserimage.png')
ship = Ship()
asteroids = Group()
asteroids.add(Asteroid())
comets = Group()
comets.add(Comet())
lasers = Group()
lasers.add(Laser())
start_button = Start_Button(pygame_screen)
while running:
tick += 1
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
# print (event.key)
if event.key == 275:
ship.should_move("right")
elif event.key == 276:
ship.should_move("left")
if event.key == 273:
ship.should_move("up")
def fire(self):
missile = Laser(self.game_batch, self.objects, self.x, self.y,
self.rotation, self.x_speed, self.y_speed)
self.objects.append(missile)
class App():
"""
Démarre une application qui permet de gérer la position sur deux axes d'un laser via des servomoteurs.
"""
def __init__(self):
"""
Méthode "main" de l'application.
"""
print "Initialisation des péripheriques..."
self.initPeriph()
print "Initialisation des servos..."
self.initServos()
print "Initialisation terminée !"
print "Programme prêt !"
print ""
#################################################
self.mode = "Manual"
self.modeObj.setMode(self.mode)
# Création des formes
self.shape = Shape(self.horizontalServo, self.verticalServo, self.laser, self.uart)
try:
while 1:
self.reading = self.uart.read()
if self.reading != "Up" and self.reading != "Left" and self.reading != "Right" and self.reading != "Down" and self.reading != "Center" and self.reading != "Laser" and self.reading != "":
self.mode = self.reading
self.modeObj.setMode(self.mode)
if self.mode == "Auto":
self.autoMode()
elif self.mode == "Semi-auto":
self.semiAutoMode()
elif self.mode == "Manual":
self.manualMode()
elif self.mode == "Wii":
if self.nunchukIsConnected:
self.wiiMode()
else:
print "La manette \"Nunchuk\" n'est pas connectée"
self.mode = "Manual"
else:
sleep(2)
self.mode = "Auto"
self.modeObj.setMode(self.mode)
except KeyboardInterrupt:
print "Arret du programme..."
self.modeObj.setMode("Stop")
self.laser.OFF()
self.initServos()
print "Programme arreté"
def initPeriph(self):
"""
Initialise tout les périphériques servant à l'application (Laser, Servos, Manette nunchuk...) et instancie les objets globals.
"""
try:
# GPIOs
Methods.writeFile("/sys/class/gpio/export", "66", "a")
Methods.writeFile("/sys/class/gpio/export", "69", "a")
Methods.writeFile("/sys/class/gpio/export", "45", "a")
# PWMs
Methods.writeFile("/sys/devices/bone_capemgr.8/slots", "am33xx_pwm", "a")
# UART
Methods.writeFile("/sys/devices/bone_capemgr.8/slots", "BB-UART1", "a")
sleep(2)
except IOError:
print "La configuration des périphériques a déjà été faites"
# Création du laser
self.laser = Laser(45)
# Création de la gestion d'indication des modes
self.modeObj = Mode(66, 69)
# Création des servos
self.verticalServo = Servo("P9_14", "10", False)
self.horizontalServo = Servo("P9_22", "11", True)
# Création de l'UART
self.uart = UART()
# Création du Nunchuk
try:
self.nunchuk = Nunchuk()
self.nunchukIsConnected = True
except IOError:
print "Erreur de connexion avec la manette \"Nunchuk\""
self.nunchukIsConnected = False
def initServos(self):
"""
Initialise les servomoteurs à la position 0,0 et éteint le laser.
"""
self.horizontalServo.setPosition(0)
self.verticalServo.setPosition(0)
Methods.sendData(self.uart, 0, 0, self.laser.getState())
def autoMode(self):
"""
Gére le mode "Auto" de l'application. Le mode "Auto" réalise une succession de toutes les formes pré-enregistré en boucle.
"""
while 1:
self.laser.ON()
print "Dessine un carré"
self.shape.startShape("Square", 2)
self.initServos()
self.reading = self.uart.read()
if self.reading == "Auto":
self.reading = self.uart.read()
if self.uart.inWaiting() != 0:
break
sleep(2)
print "Dessine un losange"
self.shape.startShape("Diamond", 3)
self.initServos()
if self.uart.inWaiting() != 0:
break
sleep(2)
print "Dessine un cercle"
self.shape.startShape("Circle", 3)
self.initServos()
if self.uart.inWaiting() != 0:
break
sleep(2)
print "Dessine un infini"
self.shape.startShape("Infinite", 3)
self.initServos()
sleep(2)
break
def semiAutoMode(self):
"""
Gére le mode "Semi-auto" de l'application. Le mode "Semi-auto" réalise les formes demandées via l'IHM.
"""
self.laser.OFF()
horizontalPositionTable = []
verticalPositionTable = []
laserStateTable = []
while 1:
pointDatas = self.uart.read()
if pointDatas == "Finish":
break
if pointDatas != "Semi-auto":
if pointDatas == "Square":
print "Dessine un carré"
self.shape.startShape(pointDatas, 1)
self.initServos()
elif pointDatas == "Diamond":
print "Dessine un losange"
self.shape.startShape(pointDatas, 1)
self.initServos()
elif pointDatas == "Circle":
print "Dessine un cercle"
self.shape.startShape(pointDatas, 1)
self.initServos()
elif pointDatas == "Infinite":
print "Dessine un infini"
self.shape.startShape(pointDatas, 1)
self.initServos()
else:
pointDatasTable = pointDatas.split(",")
horizontalPositionTable.append(int(pointDatasTable[0])*2)
verticalPositionTable.append(int(pointDatasTable[1])*2)
laserStateTable.append(pointDatasTable[2])
if len(horizontalPositionTable) != 0:
print "Dessine une forme personnalisé"
self.shape.start(horizontalPositionTable, verticalPositionTable, laserStateTable)
self.laser.OFF()
self.mode = "Manual"
def manualMode(self):
"""
Gére le mode "Manuel" de l'application. Le mode "Manuel" réalise les mouvements simples via l'IHM (Déplacement vert le Haut, la droite, allumer le laser...).
"""
for i in range(100):
self.reading = self.uart.read()
hPos = self.horizontalServo.getPosition()
vPos = self.verticalServo.getPosition()
if self.reading != "":
if self.reading == "Up":
vPos+=2
elif self.reading == "Left":
hPos-=2
elif self.reading == "Right":
hPos+=2
elif self.reading == "Down":
vPos-=2
elif self.reading == "Center":
hPos = 0
vPos = 0
elif self.reading == "Laser":
if self.laser.getState() == "0":
self.laser.ON()
else:
self.laser.OFF()
else:
break
self.horizontalServo.setPosition(hPos)
self.verticalServo.setPosition(vPos)
Methods.sendData(self.uart, self.horizontalServo.getPosition(), self.verticalServo.getPosition(), self.laser.getState())
sleep(0.01)
def wiiMode(self):
"""
Gére le mode "Wii" de l'application. Le mode "Wii" réalise les actions via la manette nunchuk.
"""
buttons = self.nunchuk.getButtons()
button_c = buttons[0]
button_z = buttons[1]
if button_z:
self.laser.ON()
else:
self.laser.OFF()
if button_c:
axis = self.nunchuk.getAccelerometerAxis()
hAngle = int(axis[0]*1.8-216.0)# Min=70 ; Max=170
vAngle = int(axis[1]*-1.8+225.0)# Min=175 ; Max=75
else:
position = self.nunchuk.getJoystickPosition()
hAngle = int(position[0]*0.93-123.58)# Min=36 ; Max=229
vAngle = int(position[1]*0.95-120.48)# Min=32 ; Max=221
self.horizontalServo.setPosition(hAngle)
self.verticalServo.setPosition(vAngle)
Methods.sendData(self.uart, self.horizontalServo.getPosition(), self.verticalServo.getPosition(), self.laser.getState())
sleep(0.01)
plt.imshow(occ_map, cmap='Greys_r') plt.show() offset_x =0.0 offset_y =0.0 resolution = 0.1 max_range = 50.0 no_of_beams = 181 min_angle = -math.pi/2.0 resolution_angle = math.pi/(no_of_beams-1) noise_variance = 0.0 map_obj = Map(height, width, offset_x, offset_y, resolution, occ_map) laser = Laser(max_range, min_angle, resolution_angle, no_of_beams, noise_variance, map_obj) robot_pos_x = 6.0 robot_pos_y = 5.0 robot_theta = 0.0 * (math.pi/180.0) laser_pos_x = 1.2 laser_pos_y = 0.0 laser_angle = 0.0 * (math.pi/180.0) sin_theta = math.sin(robot_theta) cos_theta = math.cos(robot_theta) x = robot_pos_x + laser_pos_x * cos_theta - laser_pos_y*sin_theta y = robot_pos_y + laser_pos_x * sin_theta + laser_pos_y*cos_theta theta = robot_theta + laser_angle
plt.imshow(occ_map, cmap='Greys_r')
plt.show()
offset_x = 0.0
offset_y = 0.0
resolution = 0.1
max_range = 50.0
no_of_beams = 181
min_angle = -math.pi / 2.0
resolution_angle = math.pi / (no_of_beams - 1)
noise_variance = 0.0
map_obj = Map(height, width, offset_x, offset_y, resolution, occ_map)
laser = Laser(max_range, min_angle, resolution_angle, no_of_beams,
noise_variance, map_obj)
robot_pos_x = 6.0
robot_pos_y = 5.0
robot_theta = 0.0 * (math.pi / 180.0)
laser_pos_x = 1.2
laser_pos_y = 0.0
laser_angle = 0.0 * (math.pi / 180.0)
sin_theta = math.sin(robot_theta)
cos_theta = math.cos(robot_theta)
x = robot_pos_x + laser_pos_x * cos_theta - laser_pos_y * sin_theta
y = robot_pos_y + laser_pos_x * sin_theta + laser_pos_y * cos_theta
theta = robot_theta + laser_angle
def Fire(self):
theshot = Laser((self.rect[0] + self.ship_midwidth,
self.rect[1] + self.firebaseline), self.firecolor,
self.shot_height, self.firespeed,
self.rect[1] + self.firebaseline, 0)
return theshot
def laser_shot(self):
laser = Laser(self.screen, self.top - 25, self.left, self.lasertime,
self.lasernum)
self.arrows.append(laser)
def gaming_loop():
global bullet_state, bullet_x, bullet_y
running = True
laser = Laser(random.randint(0, 1336), 0)
while running:
screen.fill((0, 0, 0))
screen.blit(background, (0, 0))
pygame.draw.line(screen, light_red, (0, 615), (1400, 620), 5)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
current_player.x_change = -30
elif event.key == pygame.K_RIGHT:
current_player.x_change = 30
elif event.key == pygame.K_SPACE:
if bullet_state == "fire":
fire_bullet(bullet_x, bullet_y)
else:
bullet_sound = mixer.Sound("laser.mp3")
bullet_sound.play()
bullet_x = current_player.x
bullet_y = 680
fire_bullet(bullet_x, bullet_y)
elif event.key == pygame.K_p:
pause()
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
current_player.x_change = 0
elif event.key == pygame.K_RIGHT:
current_player.x_change = 0
laser.y += laser.y_change
current_player.x += current_player.x_change
screen.blit(Laser.laser_img, (laser.x, laser.y))
if current_player.x <= 0:
current_player.x = 0
if current_player.x >= 1400 - 88:
current_player.x = 1400 - 88
if laser.y > 800:
laser = Laser(random.randint(0, 1336), 0)
for enemy in enemy_list:
if enemy.y > 600 or laser.x in range(
current_player.x - 8,
current_player.x + 86) and laser.y in range(
current_player.y, current_player.y + 84):
mixer.music.stop()
for individual_enemy in enemy_list:
individual_enemy.y = 900
game_over_text()
show_button("Main",
240,
450,
150,
100,
yellow,
light_yellow,
action="Main")
show_button("Quit",
950,
450,
150,
100,
red,
light_red,
action="Quit")
else:
enemy.move()
collision = collision_check(enemy.x, enemy.y, bullet_x, bullet_y)
if collision:
explosion_sound = mixer.Sound("Explosion-n.mp3")
explosion_sound.play()
bullet_y = 680
bullet_state = "ready"
global score_value
score_value += 1
enemy.x = random.randint(0, 1328)
enemy.y = random.randint(50, 150)
enemy.draw_enemy(enemy.x, enemy.y, screen)
if bullet_state == "fire":
if bullet_y < 0:
bullet_y = 680
bullet_state = "ready"
else:
fire_bullet(bullet_x, bullet_y)
bullet_y -= bullet_y_change
current_player.draw_player(current_player.x, current_player.y,
screen)
show_score(text_x, text_y)
clock.tick(120)
pygame.display.update()
else:
print "usage: RunPF.py Data.pickle numParticles (optional, default=100)"
sys.exit(2)
# Load data
Data = pickle.load(open(sys.argv[1], 'rb'))
deltat = Data['deltat'] #[0,0]
occupancy = Data['occupancy']
U = Data['U']
X0 = Data['X0']
Ranges = Data['Ranges']
XGT = Data['XGT']
Alpha = Data['Alpha']
sparsity = 5
numBearings = Ranges[0, 0].shape[0]
Ranges = np.array(Ranges.tolist())[:, :, ::sparsity]
# Gridmap class
gridmap = Gridmap(occupancy)
# Laser class
laser = Laser(numBearings, sparsity)
# Instantiate the PF class
pf = PF(numParticles, Alpha, laser, gridmap, True)
filename = os.path.basename(
sys.argv[1]).split('.')[0] + '_Pn' + str(numParticles) + '_gauss'
pf.run(U, Ranges, deltat, X0, XGT, filename, True, sys.argv[3])
# coding:utf-8 from Laser import Laser import config laser = Laser(com=config.PORT) laser.start() laser.main_loop()
'RShoulderRoll': 0,
'RElbowYaw': 1.7,
'RElbowRoll': 1.4,
'RWristYaw': -1.5
}
simulation_manager = SimulationManager()
client_id = simulation_manager.launchSimulation(gui=True)
if not DEMO_CAM_HUMAN:
pepper = simulation_manager.spawnPepper(client_id,
spawn_ground_plane=True,
translation=[-3, -1, 0])
cam = Cam(pepper, "top_cam", do_predictions=DEMO_TURN_TO_OBJ)
cam.start()
laser = Laser(pepper)
laser.start()
goToPosture(pepper, defaultPosture)
if DEMO_CAM_HUMAN:
human = simulation_manager.spawnPepper(client_id,
spawn_ground_plane=True,
translation=[0, 0, 0])
humanCam = HumanCam(human)
humanCam.start()
p.connect(p.DIRECT)
if DEMO_BRING_BACK_CHAIR and not DEMO_TURN_TO_OBJ:
chair = p.loadURDF("urdf/chair_1/chair.urdf",
basePosition=[0, -1, 0],
now_Thread = 0
flags = [False, False, False, False, False, False, False, False, False]
thread_flags = [False, False, False, False, False]
GPIO.cleanup()
sensing_Rover = Sensing_Rover()
pcf8591 = Pcf8591(0x48)
gas = Gas(pcf8591, ain=2)
thermister = Thermistor(pcf8591, ain=1)
tracking = Tracking(32)
photoresister = Photoresister(pcf8591, ain=0)
ultra = HcSr04(trigpin=38, echopin=40)
queue = queue.Queue()
rgbLed = RgbLed(16, 18, 22)
buzzer = Buzzer(35)
laser = Laser(37)
lcd = Lcd1602(0x27)
pca9685 = Pca9685()
dc_left = DC(11, 12, pca9685)
dc_right = DC(13, 15, pca9685)
channel_left = 5
channel_right = 4
set_speed = 80
sv = Sg90(pca9685, 0) # 5~90도 (default = 12도, 줄어들면 LOWER, 커지면 HIGHER)
sh = Sg90(pca9685, 1) # 12~170도 (default = 90도, 줄어들면 RIGHT, 커지면 LEFT)
sw = Sg90(pca9685, 14) # 50~130도 (default = 90도, 줄어들면 LEFT, 커지면 RIGHT)
su = Sg90(pca9685, 15) # 40~120도 (default = 80도, 줄어들면 RIGHT, 커지면 LEFT)
publiser_camera = Publisher_camera("192.168.3.177", 1883, "/camerapub")
import datetime
import json
import RPi.GPIO as GPIO
from Laser import Laser
import time
default_configuration = '{"run_time": 5, "min_movement": 12, "x_min": 0.1, "x_max": 90, "y_min": 0.1, "y_max": 22}'
GPIO_BUTTON = 26
laser = Laser()
config = json.loads(default_configuration)
run_time = config.get('run_time')
def __button_handler(channel):
print('button has been pressed...')
global engage
if engage:
print('Already firing the laser, button press ignored')
else:
print('Initiating Firing Sequence!')
# only start a new firing sequence if we're not already in the middle of one.
engage = True
__calibrate_laser()
def end():
end_time = start_time + datetime.timedelta(seconds=run_time)
return end_time
width = 617
offset_x =0.0
offset_y =0.0
resolution = 0.1
# Create map and laser scans
occ_map = Map.readFromTXT('../map.txt', width, height, offset_x, offset_y, resolution)
max_range = 50.0
no_of_beams = 181
min_angle = -math.pi/2.0
resolution_angle = math.pi/(no_of_beams-1)
noise_variance = 0.0
laser_pos_x = 1.2
laser_pos_y = 0.0
laser_angle = 0.0 * (math.pi/180.0)
laser = Laser(max_range, min_angle, resolution_angle, no_of_beams, noise_variance, occ_map, laser_pos_x, laser_pos_y, laser_angle)
# load positions
positions = np.loadtxt('../data_pose.txt')
# load laser
ranges = np.loadtxt('../map_scans.txt')
assert( positions.shape[0] == ranges.shape[0] )
n = 5
# sample n random scans from
pidx = np.random.randint(0, positions.shape[0], n)
sum_mse = 0
clump = 11