def SearchContentFromFiles(self, keys):
self.InitKeyArray(keys)
if len(self.keyWords) > 0 and len(self.excelDict) > 0:
for key in self.excelDict.keys():
value = self.excelDict[key]
# print(value.columns)
for col in self.keyWords:
listofPos = self.GetIndexes(value, col)
finalValue = ""
if len(listofPos) > 0:
rowIndex = listofPos[0][0]
colIndex = listofPos[0][1]
finalValue = value.iloc[rowIndex, colIndex + 1]
else:
if not self.IsForcedCol(col):
logger.warning("在文件%s 没找到的列名%d", key, col)
if self.colValuesDict.get(col) == None:
# print("列名为空，要初始化，列名是：", key, col)
colValues = list()
if self.IsForcedCol(col):
finalValue = key
colValues.append(finalValue)
self.colValuesDict[col] = colValues
else:
if self.IsForcedCol(col):
finalValue = key
self.colValuesDict[col].append(finalValue)
def reload(self, fileName):
try:
config = Config.loadConfigFile(fileName)
self.__dict__ = config if config is not None else dict()
self.reloaded.emit()
except:
logger.warning("Can't reload from file `{0}'.".format(fileName))
def __init__(self):
super().__init__()
try:
config = Config.loadConfigFile('config.yaml')
except:
logger.warning("Can't load `config.yaml', using `defaultConfig.yaml' instead.")
config = Config.loadConfigFile('defaultConfig.yaml')
finally:
self.__dict__ = config if config is not None else dict()
def setStatus(self, status):
# check if new status is a valid state.
if status not in list(map(int, Status)):
logger.warning("Status: " + str(status) +
" is invalid, setting STOP status.")
self.status = Status.STOP
return
# backup last status
self.prevStatus = self.status
# set new status
self.status = status
def update(self):
self.updateExternalController()
collisionImminent = False
isUTurning = self.pathRunner.isUTurning()
isParking = self.parking.isParking()
isParked = self.parking.isParked()
isSearchingPark = self.parking.isSearchingPark()
isManualActive = self.manualDrive.isEnabled()
isGoalReached = self.pathRunner.isGoalReach()
collisionImminent = self.collisionAvoidance.isCollisionDetected()
obstacleDetected = self.collisionAvoidance.isObstacleDetected()
logger.debug("collissionImminent: " + str(collisionImminent) +
" obstacleDetected: " + str(obstacleDetected) +
" isUTurning: " + str(isUTurning))
if self.status == PATH_FOLLOWING:
logger.debug("MOTION: PathFollowing")
self.updatePathRunner()
# During path find a object that can be avoid
if collisionImminent and not isUTurning:
self.setStatus(COLLISION_AVOIDANCE)
if isGoalReached:
self.parking.enable()
self.setStatus(PARKING)
elif self.status == PARKING:
logger.debug("MOTION: Parking")
self.updateParking()
if isParked:
self.setStatus(STOP)
# During parking find a object that can be avoid
if collisionImminent and isSearchingPark:
self.setStatus(COLLISION_AVOIDANCE)
elif self.status == COLLISION_AVOIDANCE:
logger.debug("MOTION: Collision Avoidance")
self.updateCollisionAvoidance()
if not collisionImminent:
self.setPrevStatus()
# During path find a object that can't be avoid
if obstacleDetected and not isUTurning and self.prevStatus == PATH_FOLLOWING:
logger.debug("Reset Path")
self.pathRunner.updatePath()
collisionImminent = False
self.collisionAvoidance.resetObstacleDetection()
self.setStatus(PATH_FOLLOWING)
elif self.status == STOP:
logger.debug("MOTION: Stop")
self.setSpeed(0)
self.setAngle(0)
self.parking.disable()
elif self.status == MANUAL:
logger.debug("MOTION: Manual")
self.manualDrive.enable()
self.updateManualDrive()
else:
logger.warning("MOTION STATUS: " + str(self.status))
self.setStatus(STOP)
def parse(xml_text, configuration, is_deprovision=False):
"""
Parse xml tree, retrieving user and ssh key information.
Return self.
"""
ofv_env = OvfEnv()
logger.log_if_verbose(re.sub("<UserPassword>.*?<", "<UserPassword>*<", xml_text))
dom = xml.dom.minidom.parseString(xml_text)
if len(dom.getElementsByTagNameNS(ofv_env.OvfNs, "Environment")) != 1:
logger.error("Unable to parse OVF XML.")
section = None
newer = False
for p in dom.getElementsByTagNameNS(ofv_env.WaNs, "ProvisioningSection"):
for n in p.childNodes:
if n.localName == "Version":
verparts = get_node_text_data(n).split('.')
major = int(verparts[0])
minor = int(verparts[1])
if major > ofv_env.MajorVersion:
newer = True
if major != ofv_env.MajorVersion:
break
if minor > ofv_env.MinorVersion:
newer = True
section = p
if newer:
logger.warning(
"Newer provisioning configuration detected. Please consider updating waagent.")
if section is None:
logger.error(
"Could not find ProvisioningSection with major version=" + str(ofv_env.MajorVersion))
return None
ofv_env.ComputerName = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "HostName")[0])
ofv_env.UserName = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "UserName")[0])
if is_deprovision:
return ofv_env
try:
ofv_env.UserPassword = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "UserPassword")[0])
except (KeyError, ValueError, AttributeError, IndexError):
pass
try:
cd_section = section.getElementsByTagNameNS(ofv_env.WaNs, "CustomData")
if len(cd_section) > 0:
ofv_env.CustomData = get_node_text_data(cd_section[0])
if len(ofv_env.CustomData) > 0:
ext_utils.set_file_contents(constants.LibDir + '/CustomData', bytearray(
translate_custom_data(ofv_env.CustomData, configuration)))
logger.log('Wrote ' + constants.LibDir + '/CustomData')
else:
logger.error('<CustomData> contains no data!')
except Exception as e:
logger.error(str(e) + ' occured creating ' + constants.LibDir + '/CustomData')
disable_ssh_passwd = section.getElementsByTagNameNS(ofv_env.WaNs, "DisableSshPasswordAuthentication")
if len(disable_ssh_passwd) != 0:
ofv_env.DisableSshPasswordAuthentication = (get_node_text_data(disable_ssh_passwd[0]).lower() == "true")
for pkey in section.getElementsByTagNameNS(ofv_env.WaNs, "PublicKey"):
logger.log_if_verbose(repr(pkey))
fp = None
path = None
for c in pkey.childNodes:
if c.localName == "Fingerprint":
fp = get_node_text_data(c).upper()
logger.log_if_verbose(fp)
if c.localName == "Path":
path = get_node_text_data(c)
logger.log_if_verbose(path)
ofv_env.SshPublicKeys += [[fp, path]]
for keyp in section.getElementsByTagNameNS(ofv_env.WaNs, "KeyPair"):
fp = None
path = None
logger.log_if_verbose(repr(keyp))
for c in keyp.childNodes:
if c.localName == "Fingerprint":
fp = get_node_text_data(c).upper()
logger.log_if_verbose(fp)
if c.localName == "Path":
path = get_node_text_data(c)
logger.log_if_verbose(path)
ofv_env.SshKeyPairs += [[fp, path]]
return ofv_env
def _unified_diff(self):
functions = {}
re_control = re.compile(r"^@@ -(.*) \+(.*) @@")
lh_index, lh_content = self._get_indexer(self._file1)
rh_index, rh_content = self._get_indexer(self._file2)
lines = list(difflib.unified_diff(lh_content, rh_content, n=0))
cursor = 0
while cursor < len(lines):
line = lines[cursor].strip()
cursor += 1
if line.startswith(('+++', '---')):
continue
'''
Consume range-info together with corresponding chunk
range-info format is:
@@ -l,s +l,s @@ optional section heading
- => range-info is for left-hand file
+ => range-info is for right-hand file
l => is the starting line number
s => is the number of _total_lines the change hunk applies
,s => is optional, and if omitted number-of-_total_lines defaults to 1.
'''
match = re_control.match(line)
if match is not None:
lh = match.group(1).split(',')
rh = match.group(2).split(',')
lh_start = int(lh[0])
if len(lh) <= 1:
lh_range = 1
else:
lh_range = int(lh[1])
rh_start = int(rh[0])
if len(rh) <= 1:
rh_range = 1
else:
rh_range = int(rh[1])
cursor, diffchunk = self._consume_chunk(lines, cursor)
diffcursor = 0
# if len(diffchunk) <= 0, we can assume that entire diffchunk have been filtered out due
# to ignore_attributes, so therefore we skip this chunk
if len(diffchunk) <= 0:
continue
if lh_range == rh_range:
'''
If ranges are equal, assume that entire diffchunk are line-by-line changes
'''
for index in range(0, rh_range):
linenr = rh_start + index
# Use rh func names, due to that if there was a rename, diff should be reported on the new name
func, total_ = rh_index.get_function_by_linenr(linenr)
try:
(added, changed, deleted, total) = functions[func]
except KeyError:
added, changed, deleted, total = 0, 0, 0, 0
changed += 1
functions[func] = (added, changed, deleted, total_)
else:
while diffcursor < len(diffchunk):
op, line = diffchunk[diffcursor]
diffcursor += 1
added_, changed_, deleted_ = 0, 0, 0
if lh_range != 0:
# Only left-hand changes
linenr = lh_start + diffcursor - 1
func, _ = lh_index.get_function_by_linenr(linenr)
if op == '-':
deleted_ += 1
elif op == '+':
added_ += 1
elif rh_range != 0:
# Only right-hand changes
linenr = rh_start + diffcursor - 1
func, _ = rh_index.get_function_by_linenr(linenr)
if op == '-':
deleted_ += 1
elif op == '+':
added_ += 1
else:
logger.warning("strange range combo:%s at line:%s", match.group(0), diffcursor)
exit(-1)
try:
(added, changed, deleted, total) = functions[func]
except KeyError:
added, changed, deleted, total = 0, 0, 0, 0
added += added_
changed += changed_
deleted += deleted_
# Use rh to calculate function total length, since that is the "new" total.
rh_func, total = rh_index.get_function_by_linenr(linenr)
# if we could not find func in rh side, that means that function got deleted, and thus should
# have size=0, otherwise we report size of random function (or likely global scope)
if rh_func != func:
total = 0
functions[func] = (added, changed, deleted, total)
return functions
def computeParkingAngleAndSpeed(self):
logger.debug("PARKING STATE: " + str(self.status))
# get distance sensors
ds = self.distanceSensors
# set reference
distanceTraveled = self.positioning.getActualDistance()
side = 0
front = 0
rear = 0
bside = 0
fside = 0
if self.status > SEARCH and self.sideOfParkingLot != UNKNOWN:
# get rear and side sensors values
rear = self.distanceSensors.backCenter.getValue()
front = self.distanceSensors.frontCenter.getValue()
if self.sideOfParkingLot == RIGHT:
side = self.distanceSensors.sideRight.getValue()
bside = self.distanceSensors.backRight.getValue()
fside = self.distanceSensors.frontRight.getValue()
elif self.sideOfParkingLot == LEFT:
side = self.distanceSensors.sideLeft.getValue()
bside = self.distanceSensors.backLeft.getValue()
fside = self.distanceSensors.frontLeft.getValue()
# SEARCH status 2
if self.status == SEARCH:
# set slow speed
self.speed = 0.2
# set straight wheels
self.angle = self.lineFollower.getNewSteeringAngle()
if self.lineFollower.isLineLost():
self.resetParkingPosition()
self.angle = self.lineFollower.getSteeringAngleLineSearching()
logger.debug("PARKING angle from Line Follower: " +
str(self.angle))
if abs(self.angle) > 0.25:
self.resetParkingPosition()
# side threshold, if side sensor is greather than threshold the parking lot if occupied
sideThreshold = 650
# get side left sensors values
leftSensorValue = ds.sideLeft.getValue()
rightSensorValue = ds.sideRight.getValue()
# checking parking lot on the LEFT side
if leftSensorValue < sideThreshold and not self.leftIsEmpty:
self.leftIsEmpty = True
self.leftStartingPosition = distanceTraveled
elif leftSensorValue > sideThreshold and self.leftIsEmpty:
self.leftIsEmpty = False
elif self.leftIsEmpty and distanceTraveled - self.leftStartingPosition > CAR_LENGTH + (
CAR_LENGTH * 2 / 3):
self.leftStartingPosition = distanceTraveled
self.sideOfParkingLot = LEFT
self.status = FORWARD
# checking parking lot on the RIGHT side
if rightSensorValue < sideThreshold and not self.rightIsEmpty:
self.rightIsEmpty = True
self.rightStartingPosition = distanceTraveled
elif rightSensorValue > sideThreshold and self.rightIsEmpty:
self.rightIsEmpty = False
elif self.rightIsEmpty and distanceTraveled - self.rightStartingPosition > CAR_LENGTH + (
CAR_LENGTH * 2 / 3):
self.rightStartingPosition = distanceTraveled
self.sideOfParkingLot = RIGHT
self.status = FORWARD
# FORWARD status 3
# this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected
elif self.status == FORWARD:
# distance to travel before starting the maneuver
distance = 0.13
# check if distance traveled is greater than distance to travel
if self.sideOfParkingLot == LEFT:
if distanceTraveled - self.leftStartingPosition >= distance:
self.status = PARKING
elif self.sideOfParkingLot == RIGHT:
if distanceTraveled - self.rightStartingPosition >= distance:
self.status = PARKING
else:
# if parking is found but is not set the side
logger.warning(
"Parking lot found! But I don't know if right or left. Looking for anther one."
)
self.status = SEARCH
# starting the parking manoeuvre 4
elif self.status == PARKING:
# check is the side of the parking lot is known
if self.sideOfParkingLot != LEFT and self.sideOfParkingLot != RIGHT:
logger.error("Side of parking lot is unknown.")
# stop the vehicle, turn the wheels and go back slowly
self.angle = self.sideOfParkingLot
self.speed = -0.1
# back thresholds that tells when contursteer
backCenterThreshold = 610
backSideThreshold = 410
if self.sideOfParkingLot == LEFT:
backCenterThreshold = 625
backSideThreshold = 425
# debug log
logger.debug("Rear: " + str(rear) + " Back Park Side: " +
str(bside))
# if true countersteer
if bside > backSideThreshold or rear > backCenterThreshold:
self.status = PARKING2
# PARKING2 status 5
elif self.status == PARKING2:
# set countersteering angle
if self.angle != 0:
self.angle = -1 * self.sideOfParkingLot
self.speed = -0.05
# set side and back threshold
rearThreshold = 985
sideThreshold = 945
backSideThreshold = 915
# debug log
logger.debug("sideOfParkingLot: " + str(self.sideOfParkingLot) +
" side: " + str(side))
# check if the park is completed
if (bside <= fside and side >= 865):
self.status = CENTER
# check if need some orient adjust
if self.distanceSensors.backDistance(
sideThreshold): #and bside > fside:
self.status = ADJUST_POSITION
# ADJUST_POSITION status 6
elif self.status == ADJUST_POSITION:
# debug log
logger.debug("Need to adjust position")
# set angle
self.angle = self.sideOfParkingLot
self.speed = 0.05
# check if the park is completed
if (bside < fside and side > 865):
self.status = CENTER
if front > 925 or fside > 925 or not self.distanceSensors.backDistance(
825):
self.angle = -1 * self.sideOfParkingLot
self.status = PARKING2
# CENTER status 7
elif self.status == CENTER:
if rear > 950 or (rear < 100 and front < 700):
self.speed = 0.05
elif front > 950 or (front < 100 and rear < 700):
self.speed = -0.05
# set angle streight
if abs(bside - fside) < 50 and abs(rear - front) < 80:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: same distance sides and rear and front!"
)
elif abs(bside - fside) < 50 and rear < 100 and front > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing behind, stay ahead!"
)
elif abs(bside - fside) < 50 and rear < 100 and front > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing behind, stay ahead!"
)
elif abs(bside - fside) < 50 and front < 100 and rear > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing ahead, stay behind!"
)
elif abs(bside - fside) < 20:
self.angle = 0.0
logger.debug("TRYING TO STAY CENTER: same distance sides!")
else:
if self.speed > 0:
nextAngle = 0.2
else:
nextAngle = -0.2
if fside < bside:
nextAngle *= self.sideOfParkingLot
else:
nextAngle *= -self.sideOfParkingLot
self.angle = nextAngle
logger.debug("TRYING TO STAY CENTER: NEED TO GO " +
("right" if self.angle > 0 else "left"))
# STOP status 8
elif self.status == STOP:
self.speed = 0.0
self.angle = 0.0
# invalid status
else:
logger.debug("Invalid parcking status")
def run(self):
logger.info("Running..")
leftIsEmpty = False # flag used to detect left parking lot
rightIsEmpty = False # flag used to detect right parking lot
leftStartingPosition = 0.0 # length of the left parking lot
rightStartingPosition = 0.0 # length of the right parking lot
sideOfParkingLot = 0 # indicates the side of the parking lot found: -1 left, 1 right, 0 not found yet
actualTurn = 0
while self.driver.step() != -1:
## here goes code that should be executed each step ##
# get actual compass value
#compassValues = self.compass.getValues()
#logger.debug("COMPASS: "******"INIT status")
# set wheel angle
self.setAngle(0.0)
# set starting speed
self.setSpeed(0.5)
# set new status
self.setStatus(Status.TURN)
# skip to next cycle to ensure everything is working fine
continue
# FOLLOW LINE STATUS
if self.status == Status.FOLLOW_LINE:
# set cruise speed
self.setSpeed(0.5)
# compute new angle
newAngle = self.lineFollower.getNewSteeringAngle()
# logger.debug("new steering angle: " + str(newAngle))
# set new steering angle
if newAngle != UNKNOWN:
self.setAngle(newAngle)
else:
self.setStatus(Status.TURN)
# TURN STATUS
if self.status == Status.TURN:
if actualTurn < len(self.turns):
turn = self.turns[actualTurn]
self.setAngle(0.5 * turn * MAX_ANGLE)
else:
self.setStatus(Status.STOP)
# compute new angle
newAngle = self.lineFollower.getNewSteeringAngle()
# if line is found
if newAngle != UNKNOWN:
self.setStatus(Status.FOLLOW_LINE)
actualTurn += 1
continue
# FORWARD STATUS
if self.status == Status.FORWARD:
# logger.debug("FORWARD status")
# set cruise speed
self.setSpeed(0.2)
# avoing obstacles
ds = self.distanceSensors
# get distance sensors values
frontLeftSensor = ds.frontLeft.getValue()
frontRightSensor = ds.frontRight.getValue()
sideLeftSensor = ds.sideLeft.getValue()
sideRightSensor = ds.sideRight.getValue()
# set values of thresholds
tolerance = 10
sideThreshold = 950
# check if front left obstacle, turn right
if frontLeftSensor > frontRightSensor + tolerance:
self.setAngle(RIGHT * frontLeftSensor / 500.0 * MAX_ANGLE)
# logger.debug("Steering angle: " + str(RIGHT * frontLeftSensor / 1000.0 * MAX_ANGLE))
logger.debug("Steering angle: " + str(self.angle))
# check if front right obstacle, turn left
elif frontRightSensor > frontLeftSensor + tolerance:
self.setAngle(LEFT * frontRightSensor / 500.0 * MAX_ANGLE)
# logger.debug("Steering angle: " + str(LEFT * frontRightSensor / 1000.0 * MAX_ANGLE))
logger.debug("Steering angle: " + str(self.angle))
# check if side left obstacle, turn slight right
elif sideLeftSensor > sideThreshold:
self.setAngle(RIGHT * sideLeftSensor / 4000.0 * MAX_ANGLE)
# check if side right obstacle, turn slight left
elif sideRightSensor > sideThreshold:
self.setAngle(LEFT * sideRightSensor / 4000.0 * MAX_ANGLE)
# if no obstacle go straight
else:
self.setAngle(self.angle / 1.5)
# SEARCHING_PARK STATUS
if self.status == Status.SEARCHING_PARK:
# set slow speed
self.setSpeed(0.2)
# set straight wheels
self.setAngle(0.0)
# get distance and position sensors
ds = self.distanceSensors
ps = self.positionSensors
#log info for debug
logger.debug("Left Distance Sensor: " +
str(ds.sideLeft.getValue()))
logger.debug("Left Position Sensor: " +
str(ps.frontLeft.getValue()) + " rad")
logger.debug("Left Wheel Length: " +
str(self.leftWheelDistance) + " m")
logger.debug("Starting position: " +
str(leftStartingPosition) + " m")
logger.debug("Parking Lot Length: " +
str(self.leftWheelDistance -
leftStartingPosition) + " m")
sideThreshold = 650
leftSensorValue = ds.sideLeft.getValue()
rightSensorValue = ds.sideRight.getValue()
# checking parking lot on the LEFT side
if leftSensorValue < sideThreshold and not leftIsEmpty:
leftIsEmpty = True
leftStartingPosition = self.leftWheelDistance # 100
elif leftSensorValue > sideThreshold and leftIsEmpty:
leftIsEmpty = False
elif leftIsEmpty and self.leftWheelDistance - leftStartingPosition > LENGTH + LENGTH / 3:
leftStartingPosition = self.leftWheelDistance # 200 - 100
sideOfParkingLot = LEFT
self.setStatus(Status.FORWARD2)
# checking parking lot on the RIGHT side
if rightSensorValue < sideThreshold and not rightIsEmpty:
rightIsEmpty = True
rightStartingPosition = self.rightWheelDistance
elif rightSensorValue > sideThreshold and rightIsEmpty:
rightIsEmpty = False
elif rightIsEmpty and self.rightWheelDistance - rightStartingPosition > LENGTH + LENGTH / 3:
rightStartingPosition = self.rightWheelDistance
sideOfParkingLot = RIGHT
self.setStatus(Status.FORWARD2)
# this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected
if self.status == Status.FORWARD2:
distance = 0.19
if sideOfParkingLot == LEFT:
if self.leftWheelDistance - leftStartingPosition > distance:
self.status = Status.PARKING
elif sideOfParkingLot == RIGHT:
if self.rightWheelDistance - rightStartingPosition > distance:
self.status = Status.PARKING
else:
logger.warning(
"Parking lot not found! I don't know if right or left."
)
self.setStatus(Status.SEARCHING_PARK)
# starting the parking manoeuvre
if self.status == Status.PARKING:
if sideOfParkingLot != LEFT and sideOfParkingLot != RIGHT:
logger.error("side of parking lot unknown.")
exit(1)
# stop the vehicle, turn the wheels and go back
self.setSpeed(0.0)
self.setAngle(sideOfParkingLot * MAX_ANGLE)
self.setSpeed(-0.1)
# when should it turn the other way
backThreshold = 400
ds = self.distanceSensors
rear = ds.back.getValue()
logger.debug("Back sensor: " + str(rear))
if rear > backThreshold:
self.status = Status.PARKING2
if self.status == Status.PARKING2:
self.setAngle(-1 * sideOfParkingLot * MAX_ANGLE)
threshold = 945
rear = self.distanceSensors.back.getValue()
if rear > threshold:
self.setStatus(Status.CENTER)
if self.status == Status.CENTER:
self.setAngle(0.0)
self.setSpeed(0.2)
rear = self.distanceSensors.back.getValue()
front = self.distanceSensors.frontCenter.getValue()
if rear - front < 20:
self.setStatus(Status.STOP)
if self.status == Status.STOP:
self.setSpeed(0.0)
self.setAngle(0.0)
# if obstacle is cleared go forward
if not self.avoidObstacle(
) and self.prevStatus == Status.PARKING2:
self.setStatus(Status.FORWARD)
if self.status == Status.MANUAL:
# get current state
speed = self.speed
angle = self.angle
# logger.debug("Current Key: " + str(currentKey))
# keyboard controlls
# accelerate
if currentKey == self.keyboard.UP:
if speed < 0:
speed += 0.02
else:
speed += 0.008
# break
elif currentKey == self.keyboard.DOWN:
if speed > 0:
speed -= 0.02
else:
speed -= 0.008
# turn left
elif currentKey == self.keyboard.LEFT:
angle -= 0.01
# turn right
elif currentKey == self.keyboard.RIGHT:
angle += 0.01
# handbreak
elif currentKey == ord(' '):
speed /= 4
# update state
self.setSpeed(speed)
self.setAngle(angle)
