def on_location(self, **kwargs):
speed = Speed(float(kwargs['speed']))
if speed > self.highest_speed_float:
self.highest_speed_float = speed
self.gps_speed = getattr(speed, unit_mapping[self.unit])
self.highest_speed = getattr(Speed(self.highest_speed_float),
unit_mapping[self.unit])
def _segmentSpeed(self, segment):
start, end = segment
distance = start.location.distanceTo(end.location)
timespan = start.daytime.intervalTo(end.daytime)
if distance.asMeters == 0:
# avoid 0/0 singularity, distance=0 always means speed=0
return Speed.fromDistanceInTime(Distance.meters(0), Interval.fromMinutes(1))
else:
return Speed.fromDistanceInTime(distance, timespan)
def move25():
speed4 = Speed(25)
speed4.start()
# time.sleep(2)
fc.forward(35)
fc.stop()
time.sleep(0.5)
fc.turn_right(50)
print('distance:', fc.us.get_distance())
def stopped(self):
speed, distance, duration = self.speed_meter.sm_data
self.display.set_data((Speed(speed,speed), distance, duration))
self.show()
self.led.green()
self.buzzer.tbeep(1000)
self.buzzer.silent()
def __init__(self, middle_row, start_column, grid, num):
self.__coordinates = {
middle_row - 2: [
start_column, start_column + 1, start_column + 4,
start_column + 5
],
middle_row - 1: [
start_column + 1, start_column + 2, start_column + 5,
start_column + 6
],
middle_row: [
start_column + 2, start_column + 3, start_column + 6,
start_column + 7
],
middle_row + 1: [
start_column + 1, start_column + 2, start_column + 5,
start_column + 6
],
middle_row + 2: [
start_column, start_column + 1, start_column + 4,
start_column + 5
],
}
for i in self.__coordinates:
for j in self.__coordinates[i]:
grid[i][j] = Speed(num)
def test_speed(self):
# fast_response = requests.get('https://www.fast.com')
# if fast_response.status_code != 200:
# return self.response('Sorry, I could not connect to python speed test. Please try again'), False
# soup = BeautifulSoup(fast_response)
# speed_value = soup.find("div",attrs={"class":"speed-results-container","id":"speed-value"}).text
# print(speed_value)
# speed_unit = soup.find("div",attrs={"class":"speed-units-container","id":"speed-units"}).text
# print(speed_unit)
st = pyspeedtest.SpeedTest()
ping = 'Your ping is: ' + str(st.ping()) + ' milliseconds'
down = st.download() / 1000000
if down < 1:
down = 'Your download speed is: ' + str(
down * 1000) + ' kilobytes per second'
else:
down = str(down) + ' megabytes per second'
up = st.upload() / 1000000
if up < 1:
up = 'Your upload speed is: ' + str(
up * 1000) + ' kilobytes per second'
else:
up = str(up) + ' megabytes per second'
speed = Speed(ping, up, down)
return self.response(speed), True
def __init__(self, rows=20, cols=20):
self.board = Board(rows=rows, cols=cols)
self.game_over = False
self.score = 0
self.high_score = HighScore()
self.wonsz = Wonsz(self.board)
self.apple = self.give_me_apple()
self.speed = Speed()
self.time = time()
self.eat = False
self.pause = True
self.modes = ('Classic', 'Modern')
self.mode = self.modes[0]
self.steps = 0
self.tiles = self.board.rows*self.board.cols
self.points = self.tiles - self.steps
self.debug = []
def run_game():
'''Run Game of Life.'''
pygame.init()
game_settings = Settings()
screen = pygame.display.set_mode((game_settings.screen_width,
game_settings.screen_height))
pygame.display.set_caption("Game of Life")
# There is only one cell.
cell = Cell(screen, game_settings)
# Set main menu.
main = MainMenu()
# Set available options.
options = Options(screen, game_settings)
# Set speed and speed bar.
speed = Speed(screen, game_settings)
to_drop = [speed.actual_drop]
# Set pause menu.
state = Status(screen)
# Build the matrix for live cells coordinates.
mat_rows = game_settings.screen_height // game_settings.cell_height + 2
mat_cols = game_settings.screen_width // game_settings.cell_width + 2
cells_matrix = np.zeros(shape = (mat_rows, mat_cols)).astype(bool)
xmouse, ymouse = None, None
# Set to False the single step option.
move_to_next_step = [False]
while 1:
gf.check_events(state, speed, main, options, xmouse, ymouse,
move_to_next_step)
if main.menu:
xmouse, ymouse = pygame.mouse.get_pos()
gf.main_menu(xmouse, ymouse, game_settings, state, speed,
main, options, cells_matrix)
elif not state.pause or move_to_next_step[0]:
gf.game(move_to_next_step, cells_matrix,
game_settings, state, speed, to_drop)
gf.update_screen(game_settings, screen, cells_matrix,
state, speed, main, options, cell)
def turnRight():
speed4 = Speed(25)
speed4.start()
# time.sleep(2)
fc.turn_right(80)
x = 0
for i in range(15):
time.sleep(0.1)
speed = speed4()
x += speed * 0.1
print("%smm/s" % speed)
print("%smm" % x)
speed4.deinit()
fc.stop()
def drive(self, speed=__INITIAL_SPEED):
""" Main entry point of the car, and put it in drive mode
Keyword arguments:
speed -- speed of back wheel, range is 0 (stop) - 100 (fastest)
"""
logging.info('Starting to drive at speed %s...' % speed)
i = 0
while self.camera.isOpened() and i < 30:
_, image_lane = self.camera.read()
image_objs = image_lane.copy()
i += 1
self.video_orig.write(image_lane)
# image_objs = self.process_objects_on_road(image_objs)
# self.video_objs.write(image_objs)
# show_image('Detected Objects', image_objs)
image_lane = self.follow_lane(image_lane)
self.video_lane.write(image_lane)
# show_image('Lane Lines', image_lane)
cv2.imshow('Lane Lines', image_lane)
if cv2.waitKey(1) & 0xFF == ord('q'):
self.cleanup()
break
speed4 = Speed(25)
speed4.start()
# time.sleep(2)
fc.forward(20)
x = 0
for i in range(25):
time.sleep(0.1)
speed = speed4()
x += speed * 0.1
# time.sleep(0.5)
#print("%smm/s"%speed)
print("%smm" % x)
speed4.deinit()
fc.stop()
from speed import Speed
def get_diff(pool):
coin = btcnet_info.get_pool(pool)
if coin:
coin = coin.coin
else:
coin = 'btc'
return float(btcnet_info.get_difficulty(coin))
getworks = None
accepted = None
rejected = None
hashrate = Speed()
def build_dict():
"""
Returns a dict with tuples of getworks, accepted, reject, priority, percentage
"""
__patch()
res = {}
for key in getworks:
server, username, password, diff = key
if key not in accepted:
accepted[key] = 0
if key not in rejected:
rejected[key] = 0
if server not in res:
def on_config_change(self, config, section, key, value):
self.unit = config.get('preferences', 'unit')
sp = getattr(Speed(self.highest_speed_float), unit_mapping[self.unit])
self.highest_speed = sp
def run_game():
#Initialisiert das Spiel und erstellt ein screen-Objekt
pygame.init()
# Lädt die Hintergrundmusik
mixer.music.load("rsc/music.wav")
mixer.music.set_volume(0.2)
mixer.music.play(-1)
# Erstellt eine Instanz von Settings
ai_settings = Settings()
ai_settings2 = Settings()
ai_settings3 = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("GlamJam")
# Erstellt eine Instanz von Player
player = Player(ai_settings, screen)
# Erstellt die Blöcke
block1 = Block(ai_settings, screen, player)
block2 = Block(ai_settings, screen, player)
block3 = Block(ai_settings, screen, player)
# Erstellt eine Instanz von Point
point = Point(ai_settings, screen)
# Erstellt das Scoreboard
scoreboard = Scoreboard(ai_settings, screen)
# Erstellt die Geschwindigkeitsanzeige
speed = Speed(ai_settings, screen)
# Erstellt die Levelanzeige
level = Level(ai_settings, screen)
gameover = Gameover(ai_settings, screen)
# Erstellt eine Instanz von Field
field = Field(ai_settings, screen)
# Erstellt Instanzen der Gegner
enemy = Enemy(ai_settings, screen)
enemy2 = Enemy(ai_settings2, screen)
enemy3 = Enemy(ai_settings3, screen)
# Erstellt die Gruppe für Lebenspunkte
lifes = Group()
gf.create_life(ai_settings, screen, lifes)
# Legt die Startbedigungen der einzelnen Gegner fest
gf.create_enemy(ai_settings, ai_settings2, ai_settings3, enemy, enemy2, enemy3)
# Legt die Startbedingungen der Blöcke fest
gf.create_block(ai_settings, block1, block2, block3)
# Startet die Hauptschleife des Spiels
while True:
# Setzt die Variable clock immer auf die aktuelle Prozesszeit
clock = time.process_time()
# Reagiert auf Tastatureingaben
gf.check_events(ai_settings, player)
# Checkt ob der Spieler getroffen wurde
if (clock - ai_settings.starttime) >= 1: # Nach einem Treffer wird 1s gewartet bis erneut getroffen werden kann
gf.check_player_hit(ai_settings, screen, player, lifes, enemy, enemy2, enemy3)
# Checkt ob der Spieler den Punkt eingesammelt hat
gf.check_point_collect(ai_settings, ai_settings2, ai_settings3, player, point, scoreboard, speed, level, block1, block2, block3)
# Checkt ob der Spieler noch Leben hat
gf.check_life(ai_settings)
if ai_settings.game_aktive:
# Update der Spielerposition und der Gegnerpositionen
if pygame.sprite.collide_rect(player, block1):
block1.update_collide_left()
block1.update_collide_right()
block1.update_collide_top()
block1.update_collide_bottom()
if pygame.sprite.collide_rect(player, block2):
block2.update_collide_left()
block2.update_collide_right()
block2.update_collide_top()
block2.update_collide_bottom()
if pygame.sprite.collide_rect(player, block3):
block3.update_collide_left()
block3.update_collide_right()
block3.update_collide_top()
block3.update_collide_bottom()
player.update()
enemy.update()
enemy2.update()
enemy3.update()
# Zeichnet den Bildschirm bei jedem Schleifendurchlauf neu
# Macht den als letztes gezeichneten Bildschirm sichtbar
gf.update_screen(ai_settings, screen, player, point, scoreboard, speed, level, lifes, enemy, enemy2, enemy3, block1, block2, block3, field, gameover)
from speed import Speed
import sqlite3
import time
# Connect to database
c = sqlite3.connect('results.db')
# Create db if it doesn't exists
c.execute('''CREATE TABLE IF NOT EXISTS speeds
(download FLOAT, upload FLOAT, ping FLOAT, created_at DATETIME)'''
)
# Get speeds
s = Speed()
r = s.results
upload = r['upload']
download = r['download']
ping = r['ping']
now = time.time()
print(upload, download, ping)
# Add to dabates
c.execute('INSERT INTO speeds VALUES (?,?,?,?)', [download, upload, ping, now])
c.commit()
c.close
#!/usr/bin/env python
from subprocess import Popen, PIPE
import argparse
from speed import Speed, parseIPerfSpeed, KILOBITS
from vms import shape
ATC = '192.168.20.2'
IPERF = '192.168.10.10'
RATES = [
Speed(10000, KILOBITS),
Speed(1000, KILOBITS),
Speed(100, KILOBITS),
Speed(50, KILOBITS),
Speed(25, KILOBITS),
Speed(10, KILOBITS),
Speed(5, KILOBITS),
]
NTESTS = 10
# fixme: move to test utils
def parseIPerfPrefix(s):
b = s.find('0.0-')
e = s.find(' sec', b) + 4
interval = s[b:e].split('-')[1]
b = e + 4
transfer = ' '.join(s[b:].split()[:2])
def rateList(rate_str):
results = []
for r in rate_str.split(','):
results.append(Speed(int(r), KILOBITS))
return results
def running(self):
speed = Speed(self.speed_leader.speed, self.speed_meter.speed)
self.display.set_data((speed, self.speed_meter.distance, self.speed_meter.duration))
self.show()
