Projekte/LegoLeague
3
0
Fork 0
Code Issues 2 Pull requests Projects Releases Packages Wiki Activity
LegoLeague/gorobot.py

984 lines
41 KiB
Python
Raw Normal View History

Initial code with Python stubs for Lego Spike API, Go Robot Code and an example how to structure our code
2023-02-14 16:43:41 +00:00
# LEGO type:standard slot:3 autostart
import math
from spike import PrimeHub, Motor, MotorPair, ColorSensor
from spike.control import wait_for_seconds, Timer
from hub import battery
hub = PrimeHub()
import hub as hub2
import sys
"""
Initialize motor and color Sensors
"""
# adjust the sensor ports until they match your configuration,
# we recommend assigning your ports to the ones in the program for ease of use
colorE = ColorSensor('E')
colorF = ColorSensor('E')
smallMotorA = Motor('A')
smallMotorD = Motor('B')
#Preperation for parallel code execution
accelerate = True
run_generator = True
runSmall = True
lastAngle = 0
oldAngle = 0
gyroValue = 0
# Create your objects here.
hub = PrimeHub()
#PID value Definition
pRegler = 0.0
iRegler = 0.0
dRegler = 0.0
pReglerLight = 0.0
iReglerLight = 0.0
dReglerLight = 0.0
#Set variables based on robot
circumference = 17.6 #circumference of the wheel powered by the robot in cm
sensordistance = 7 #distance between the two light sensors in cm. Used in Tangent alignment 6.4 in studs
cancel = False
inMain = True
class DriveBase:
def __init__(self, hub, leftMotor, rightMotor):
self.hub = hub
self.leftMotor = Motor(leftMotor)
self.rightMotor = Motor(rightMotor)
self.movement_motors = MotorPair(leftMotor, rightMotor)
def lineFollower(self, distance, startspeed, maxspeed, endspeed, sensorPort, side, addspeed = 0.2, brakeStart = 0.7 , stopMethod=None, generator = None, stop = True):
"""
This is the function used to let the robot follow a line until either the entered distance has been achieved or the other sensor of the robot senses a line.
Like all functions that drive the robot this function has linear acceleration and breaking. It also uses PID values that are automatically set depending on the
current speed of the robot (See function PIDCalculationLight)
Parameters
-------------
distance: The value tells the program the distance the robot has to drive. Type: Integer. Default: No default value
speed: The speed which the robot is supposed to start at. Type: Integer. Default: No default value
maxspeed: The highest speed at which the robot drives. Type: Integer. Default: No default value
endspeed: The speed which the robot achieves at the end of the function. Type: Integer. Default: No default value
addspeed: The percentage after which the robot reaches its maxspeed. Type: Float. Default: No default value
brakeStart: The value which we use to tell the robot after what percentage of the distance we need to slow down. Type: Float. Default: No default value
stopMethod: the Stopmethod the robot uses to stop. If no stopMethod is passed stopDistance is used instead. Default: stopDistance
generator: the generator that runs something parallel while driving. Default: No default value
stop: the boolean that determines whether the robot should stop the motors after driving or not. Default: True
"""
if cancel:
return
global run_generator, runSmall
if generator == None:
run_generator = False
#set the speed the robot starts at
speed = startspeed
#reset PID values to eliminate bugs
change = 0
old_change = 0
integral = 0
#reset the driven distance of the robot to eliminate bugs
#specifies the color sensor
colorsensor = ColorSensor(sensorPort)
#Get degrees of motors turned before robot has moved, allows for distance calculation without resetting motors
loop = True
#Going backwards is not supported on our robot due to the motors then being in front of the colour sensors and the program not working
if distance < 0:
print('ERR: distance < 0')
distance = abs(distance)
#Calculate target values for the motors to turn to
finalDistance = (distance / 17.6) * 360
#Calculate after what distance the robot has to reach max speed
accelerateDistance = finalDistance * addspeed
deccelerateDistance = finalDistance * (1 - brakeStart)
invert = 1
#Calculation of steering factor, depending on which side of the line we are on
if side == "left":
invert = 1
elif side == "right":
invert = -1
#Calculation of the start of the robot slowing down
self.left_Startvalue = self.leftMotor.get_degrees_counted()
self.right_Startvalue = self.rightMotor.get_degrees_counted()
drivenDistance = getDrivenDistance(self)
brakeStartValue = brakeStart * finalDistance
while loop:
if cancel:
print("cancel")
break
if run_generator: #run parallel code execution
next(generator)
#Checks the driven distance as an average of both motors for increased accuracy
oldDrivenDistance = drivenDistance
drivenDistance = getDrivenDistance(self)
#Calculates target value for Robot as the edge of black and white lines
old_change = change
change = colorsensor.get_reflected_light() - 50
#Steering factor calculation using PID, sets new I value
steering = (((change * pReglerLight) + (integral * iReglerLight) + (dReglerLight * (change - old_change)))) * invert
integral = change + integral
#Calculation of current speed for robot, used for acceleratiion, braking etc.
speed = speedCalculation(speed, startspeed, maxspeed, endspeed, accelerateDistance, deccelerateDistance, brakeStartValue, drivenDistance, oldDrivenDistance)
pidCalculationLight(speed)
#PID value updates
steering = max(-100, min(steering, 100))
#Driving using speed values calculated with PID and acceleration for steering, use of distance check
self.movement_motors.start_at_power(int(speed), int(steering))
if stopMethod != None:
if stopMethod.loop():
loop = False
else:
if finalDistance < drivenDistance:
break
if stop:
self.movement_motors.stop()
run_generator = True
runSmall = True
generator = 0
return
def gyroRotation(self, angle, startspeed, maxspeed, endspeed, addspeed = 0.3, brakeStart = 0.7, rotate_mode = 0, stopMethod = None, generator = None, stop = True):
"""
This is the function that we use to make the robot turn the length of a specific angle or for the robot to turn until it senses a line. Even in this function the robot
can accelerate and slow down. It also has Gyrosensor calibrations based on our experimental experience.
Parameters
-------------
angle: The angle which the robot is supposed to turn. Use negative numbers to turn counterclockwise. Type: Integer. Default value: No default value
startspeed: The speed which the robot is supposed to start at. Type: Integer. Default: No default value
maxspeed: The highest speed at which the robot drives. Type: Integer. Default: No default value
endspeed: The speed which the robot achieves at the end of the function. Type: Integer. Default: No default value
addspeed: The percentage after which the robot reaches the maxspeed. Type: Float. Default: No default value
brakeStart: The percentage after which the robot starts slowing down until it reaches endspeed. Type: Float. Default: No default value
rotate_mode: Different turning types. 0: Both motors turn, robot turns on the spot. 1: Only the outer motor turns, resulting in a corner. Type: Integer. Default: 0
stopMethod: the Stopmethod the robot uses to stop. If no stopMethod is passed stopDistance is used instead. Default: stopDistance
generator: the generator that runs something parallel while driving. Default: No default value
stop: the boolean that determines whether the robot should stop the motors after driving or not. Default: True
"""
if cancel:
return
global run_generator, runSmall
if generator == None:
run_generator = False
if rotate_mode == 0:
startspeed = abs(startspeed)
maxspeed = abs(maxspeed)
endspeed = abs(endspeed)
speed = startspeed
#set standard variables
rotatedDistance = 0
steering = 1
accelerateDistance = abs(angle * addspeed)
deccelerateDistance = abs(angle * (1 - brakeStart))
#gyro sensor calibration
angle = angle * (2400/2443) #experimental value based on 20 rotations of the robot
#Setting variables based on inputs
loop = True
gyroStartValue = getGyroValue() #Yaw angle used due to orientation of the self.hub. This might need to be changed
brakeStartValue = (angle + gyroStartValue) * brakeStart
#Inversion of steering value for turning counter clockwise
if angle < 0:
steering = -1
#Testing to see if turining is necessary, turns until loop = False
while loop:
if cancel:
break
if run_generator: #run parallel code execution
next(generator)
oldRotatedDistance = rotatedDistance
rotatedDistance = getGyroValue() #Yaw angle used due to orientation of the self.hub. This might need to be changed
#Checking for variants
#Both Motors turn, robot moves on the spot
if rotate_mode == 0:
self.movement_motors.start_tank_at_power(int(speed) * steering, -int(speed) * steering)
#Only outer motor turns, robot has a wide turning radius
elif rotate_mode == 1:
if angle * speed > 0:
self.leftMotor.start_at_power(- int(speed))
else:
self.rightMotor.start_at_power(+ int(speed))
if stopMethod != None:
if stopMethod.loop():
loop = False
break
elif abs(angle) <= abs(rotatedDistance - gyroStartValue):
loop = False
break
#Stops movement motors for increased accuracy while stopping
if stop:
self.movement_motors.stop()
run_generator = True
runSmall = True
return # End of gyroStraightDrive
def gyroStraightDrive(self, distance, startspeed, maxspeed, endspeed, addspeed = 0.3, brakeStart = 0.7, stopMethod=None, offset = 0, generator = None, stop = True):
"""
This is the function that we use to make the robot go forwards or backwards without drifting. It can accelerate, it can slow down and there's also PID. You can set the values
in a way where you can either drive until the entered distance has been achieved or until the robot senses a line.
Parameters
-------------
distance: the distance that the robot is supposed to drive. Type: Integer. Default: No default value
speed: The speed which the robot is supposed to start at. Type: Integer. Default: No default value
maxspeed: The highest speed at which the robot drives. Type: Integer. Default: No default value
endspeed: The speed which the robot achieves at the end of the function. Type: Integer. Default: No default value
addspeed: The speed which the robot adds in order to accelerate. Type: Float. Default: 0.2
brakeStart: The value which we use to tell the robot after what percentage of the distance we need to slow down. Type: Float. Default: 0.8
port: This value tells the program whether the robot is supposed to check for a black line with the specified light snsor. Type: String. Default: 0
lightValue: This value tells the program the value the robot should stop at if port sees it. Type: Integer. Default: 0
align_variant: Tells the robot to align itself to a line if it sees one. 0: No alignment. 1: standard alignment. 2: tangent based alignment Type: Integer. Default: 0
detectLineStart: The value which we use to tell the robot after what percentage of the distance we need to look for the line to drive to. Type: Float. Default: 0
offset: The value sends the robot in a direction which is indicated by the value entered. Type: Integer. Default: 0
generator: Function executed while robot is executing gyroStraightDrive. Write the wanted function and its parameters here. Type: . Default: 0
stopMethod: the Stopmethod the robot uses to stop. If no stopMethod is passed stopDistance is used instead. Default: stopDistance
generator: the generator that runs something parallel while driving. Default: No default value
stop: the boolean that determines whether the robot should stop the motors after driving or not. Default: True
"""
if cancel:
return
global run_generator, runSmall
global pRegler, iRegler, dRegler
if generator == None:
run_generator = False
#Set starting speed of robot
speed = startspeed
#Sets PID values
change = 0
old_change = 0
integral = 0
steeringSum = 0
invert = -1
#Sets values based on user inputs
loop = True
gyroStartValue = getGyroValue()
#Error check for distance
if distance < 0:
print('ERR: distance < 0')
distance = abs(distance)
#Calulation of degrees the motors should turn to
#17.6 is wheel circumference in cm. You might need to adapt it
rotateDistance = (distance / 17.6) * 360
accelerateDistance = rotateDistance * addspeed
deccelerateDistance = rotateDistance * (1 - brakeStart)
#Inversion of target rotation value for negative values
if speed < 0:
invert = 1
#Calculation of braking point
self.left_Startvalue = self.leftMotor.get_degrees_counted()
self.right_Startvalue = self.rightMotor.get_degrees_counted()
brakeStartValue = brakeStart * rotateDistance
drivenDistance = getDrivenDistance(self)
while loop:
if cancel:
break
if run_generator: #run parallel code execution
next(generator)
#Calculation of driven distance and PID values
oldDrivenDistance = drivenDistance
drivenDistance = getDrivenDistance(self)
pidCalculation(speed)
change = getGyroValue() - gyroStartValue #yaw angle used due to orientation of the self.hub
currenSteering = (change * pRegler + integral * iRegler + dRegler * (change - old_change)) + offset + steeringSum*0.02
currenSteering = max(-100, min(currenSteering, 100))
#print("steering: " + str(currenSteering) + " gyro: " + str(change) + " integral: " + str(integral))
steeringSum += change
integral += change - old_change
old_change = change
#Calculation of speed based on acceleration and braking, calculation of steering value for robot to drive perfectly straight
speed = speedCalculation(speed, startspeed,maxspeed, endspeed, accelerateDistance, deccelerateDistance, brakeStartValue, drivenDistance, oldDrivenDistance)
self.movement_motors.start_at_power(int(speed), invert * int(currenSteering))
if stopMethod != None:
if stopMethod.loop():
loop = False
elif rotateDistance < drivenDistance:
loop = False
if stop:
self.movement_motors.stop()
run_generator = True
runSmall = True
return #End of gyroStraightDrive
def arcRotation(self, radius, angle, startspeed, maxspeed, endspeed, addspeed = 0.3, brakeStart = 0.7, stopMethod=None, generator = None, stop = True):
"""
This is the function that we use to make the robot drive a curve with a specified radius and to a given angle
Parameters
-------------
radius: the radius of the curve the robot is supposed to drive; measured from the outside edge of the casing. Type: Integer. Default: 0
angle: the angle that the robot is supposed to rotate on the curve. Type: Integer. Default: 0
speed: The speed which the robot is supposed to start at. Type: Integer. Default: No default value
maxspeed: The highest speed at which the robot drives. Type: Integer. Default: No default value
endspeed: The speed which the robot achieves at the end of the function. Type: Integer. Default: No default value
addspeed: The speed which the robot adds in order to accelerate. Type: Float. Default: 0.2
brakeStart: The value which we use to tell the robot after what percentage of the distance we need to slow down. Type: Float. Default: 0.8
stopMethod: the Stopmethod the robot uses to stop. If no stopMethod is passed stopDistance is used instead. Default: stopDistance
generator: the generator that runs something parallel while driving. Default: No default value
stop: the boolean that determines whether the robot should stop the motors after driving or not. Default: True
"""
if cancel:
print("cancel")
return
global run_generator, runSmall
if generator == None:
run_generator = False
angle = angle * (336/360) #gyro calibration
gyroStartValue = getGyroValue()
finalGyroValue = gyroStartValue + angle
currentAngle = gyroStartValue
accelerateDistance = abs(angle * addspeed)
deccelerateDistance = abs(angle * (1 - brakeStart))
brakeStartValue = abs(angle * brakeStart)
loop = True
#Calculating the speed ratios based on the given radius
if angle * startspeed > 0:
speed_ratio_left = (radius+14) / (radius+2) #calculate speed ratios for motors. These will need to be adapted based on your robot design
speed_ratio_right = 1
else:
speed_ratio_left = 1
speed_ratio_right = (radius+14) / (radius+2)
#Calculating the first speed to drive with
left_speed = speedCalculation(startspeed, startspeed, maxspeed, endspeed, accelerateDistance, deccelerateDistance, brakeStartValue, 1, 0)
right_speed = speedCalculation(startspeed, startspeed , maxspeed , endspeed , accelerateDistance, deccelerateDistance, brakeStartValue, 1, 0)
while loop:
#when the cancel button is pressed stop the gyrostraight drive directly
if cancel:
break
if run_generator: #run parallel code execution
next(generator)
currentAngle = getGyroValue() #Yaw angle used due to orientation of the self.hub. This might need to be changed
#Calculating the current speed the robot should drive
left_speed = speedCalculation(left_speed, startspeed, maxspeed, endspeed, accelerateDistance, deccelerateDistance, brakeStartValue, 1, 0)
right_speed = speedCalculation(right_speed, startspeed , maxspeed , endspeed , accelerateDistance, deccelerateDistance, brakeStartValue, 1, 0)
self.movement_motors.start_tank_at_power(int(left_speed* speed_ratio_left), int(right_speed* speed_ratio_right))
#if there is a stopMethod passed use it and stop the loop if it returns true otherwise check if the robot has rotated to the given angle
if stopMethod != None:
#print("stoMeth")
if stopMethod.loop():
loop = False
break
(angle / abs(angle))
if finalGyroValue * (angle / abs(angle)) < currentAngle * (angle / abs(angle)):
#print("finalGyroValue: " + str(finalGyroValue) + " rotatedDistance: " + str(currentAngle))
loop = False
break
#if stop is true then stop the motors otherwise don't stop the motor
if stop:
self.movement_motors.stop()
run_generator = True
runSmall = True
return #End of arcRotation
def resetGyroValue():
global gyroValue
hub2.motion.yaw_pitch_roll(0)
gyroValue = 0
def getGyroValue():
#this method is used to return the absolute gyro Angle and the angle returned by this method doesn't reset at 180 degree
global lastAngle
global oldAngle
global gyroValue
#gets the angle returned by the spike prime program. The problem is the default get_yaw_angle resets at 180 and -179 back to 0
angle = hub.motion_sensor.get_yaw_angle()
if angle != lastAngle:
oldAngle = lastAngle
lastAngle = angle
if angle == 179 and oldAngle == 178:
hub2.motion.yaw_pitch_roll(0)#reset
gyroValue += 179
angle = 0
if angle == -180 and oldAngle == -179:
hub2.motion.yaw_pitch_roll(0) #reset
gyroValue -= 180
angle = 0
return gyroValue + angle
def getDrivenDistance(data):
#print(str(abs(data.leftMotor.get_degrees_counted() - data.left_Startvalue)) + " .:. " + str(abs(data.rightMotor.get_degrees_counted() - data.right_Startvalue)))
drivenDistance = (
abs(data.leftMotor.get_degrees_counted() - data.left_Startvalue) +
abs(data.rightMotor.get_degrees_counted() - data.right_Startvalue)) / 2
return drivenDistance
def defaultClass(object, db):
object.db = db
object.leftMotor = db.leftMotor
object.rightMotor = db.rightMotor
object.left_Startvalue = abs(db.leftMotor.get_degrees_counted())
object.right_Startvalue = abs(db.rightMotor.get_degrees_counted())
return object
class stopMethods(): #This class has all our stopmethods for easier coding and less redundancy
class stopLine():
"""
Drive until a Line is detected
Parameters
-------------
db: the drivebase of the robot
port: Port to detect line on
lightvalue: Value of the light to detect
detectLineDistance: Distance until start detecting a line
"""
def __init__(self, db, port, lightvalue, detectLineDistance):
self = defaultClass(self, db)
self.port = port
self.detectLineDistance = (detectLineDistance / 17.6) * 360
#if lightvalue bigger 50 stop when lightvalue is higher
self.lightvalue = lightvalue
def loop(self):
drivenDistance = getDrivenDistance(self)
if abs(self.detectLineDistance) < abs(drivenDistance):
if self.lightvalue > 50:
if ColorSensor(self.port).get_reflected_light() > self.lightvalue:
return True
else:
if ColorSensor(self.port).get_reflected_light() < self.lightvalue:
return True
return False
class stopAlign():
"""
Drive until a Line is detected
Parameters
-------------
db: the drivebase of the robot
port: Port to detect line on
lightvalue: Value of the light to detect
speed: speed at which the robot searches for other line
"""
def __init__(self, db, lightvalue, speed):
self = defaultClass(self, db)
self.speed = speed
#if lightvalue bigger 50 stop when lightvalue is higher
self.lightValue = lightvalue
def loop(self):
if colorE.get_reflected_light() < self.lightValue:
self.rightMotor.stop()
#Turning robot so that other colour sensor is over line
while True:
self.leftMotor.start_at_power(-int(self.speed))
#Line detection and stopping
if colorF.get_reflected_light() < self.lightValue or cancel:
self.leftMotor.stop()
return True
#Colour sensor F sees line first
elif colorF.get_reflected_light() < self.lightValue:
self.leftMotor.stop()
#Turning robot so that other colour sensor is over line
while True:
self.rightMotor.start_at_power(int(self.speed))
#Line detection and stopping
if colorE.get_reflected_light() < self.lightValue or cancel:
self.rightMotor.stop()
return True
return False
class stopTangens():
"""
Drive until a Line is detected
Parameters
-------------
db: the drivebase of the robot
port: Port to detect line on
lightvalue: Value of the light to detect
speed: Distance until start detecting a line
"""
def __init__(self, db, lightvalue, speed):
self.count = 0
self = defaultClass(self, db)
self.speed = speed
#if lightvalue bigger 50 stop when lightvalue is higher
self.lightValue = lightvalue
self.detectedLineDistance = 0
self.invert = 1
if speed < 0:
self.invert = -1
def loop(self):
drivenDistance = getDrivenDistance(self)
if colorE.get_reflected_light() < self.lightValue:
#measuring the distance the robot has driven since it has seen the line
if(self.detectedLineDistance == 0):
self.detectedLineDistance = getDrivenDistance(self)
self.detectedPort = 'E'
elif self.detectedPort == 'F':
db.movement_motors.stop() #Stops robot with sensor F on the line
angle = math.degrees(math.atan(((drivenDistance - self.detectedLineDistance) / 360 * circumference) / sensordistance)) #Calculating angle that needs to be turned using tangent
#print("angle: " + str(angle))
db.gyroRotation(-angle, self.invert * self.speed, self.invert * self.speed, self.invert * self.speed, rotate_mode=1) #Standard gyrorotation for alignment, but inverting speed values if necessary
db.movement_motors.stop() #Stopping robot for increased reliability
return True
#Colour sensor F sees line first
elif colorF.get_reflected_light() < self.lightValue:
#measuring the distnace the robot has driven since it has seen the line
if(self.detectedLineDistance == 0):
self.detectedLineDistance = drivenDistance
self.detectedPort = 'F'
elif self.detectedPort == 'E':
db.movement_motors.stop() #Stops robot with sensor E on the line
angle = math.degrees(math.atan(((drivenDistance - self.detectedLineDistance) / 360 * circumference) / sensordistance)) #Calculation angle that needs to be turned using tangent
db.gyroRotation(angle, self.invert * self.speed, self.invert * self.speed, self.invert * self.speed, rotate_mode=1) #Standard gyrorotation for alignment, but inverting speed values if necessary
db.movement_motors.stop() #Stopping robot for increased reliablity
return True
return False
class stopDegree():
"""
Roates until a certain degree is reached
Parameters
-------------
db: the drivebase of the robot
angle: the angle to rotate
"""
def __init__(self, db, angle):
self.angle = angle * (336/360)
self.gyroStartValue = getGyroValue() #Yaw angle used due to orientation of the self.hub.
def loop(self):
rotatedDistance = getGyroValue() #Yaw angle used due to orientation of the self.hub.
if abs(self.angle) <= abs(rotatedDistance - self.gyroStartValue):
return True
else:
return False
class stopTime():
"""
Drive until a certain time is reached
Parameters
-------------
db: the drivebase of the robot
time: the time to drive
"""
def __init__(self, db, time) -> None:
self = defaultClass(self, db)
self.time = time
self.timer = Timer()
self.startTime = self.timer.now()
def loop(self):
if self.timer.now() > self.startTime + self.time:
return True
else:
return False
class stopResistance():
"""
Drive until the Robot doesn't move anymore
Parameters
-------------
db: the drivebase of the robot
restistance: the value the resistance has to be below to stop
"""
def __init__(self, db, resistance):
self = defaultClass(self, db)
self.resistance = resistance
self.timer = Timer()
self.startTime = 0
self.lower = False
self.runs = 0
def loop(self):
self.runs += 1
motion = abs(hub2.motion.accelerometer(True)[2])
if motion < self.resistance:
self.lower = True
if self.runs > 15:
if self.lower:
if self.startTime == 0:
self.startTime = self.timer.now()
if self.timer.now() > self.startTime:
return True
else:
self.lower = False
return False
def motorResistance(speed, port, resistancevalue):
"""
lets the motor stop when it hits an obstacle
"""
if abs(resistancevalue) > abs(speed):
return
if cancel:
return
if port == "A":
smallMotorA.start_at_power(speed)
while True:
old_position = smallMotorA.get_position()
wait_for_seconds(0.4)
if abs(old_position - smallMotorA.get_position())<resistancevalue or cancel:
smallMotorA.stop()
print("detected stalling")
return
elif port == "D":
smallMotorD.start_at_power(speed)
while True:
old_position = smallMotorD.get_position()
wait_for_seconds(0.4)
if abs(old_position - smallMotorD.get_position())<resistancevalue or cancel:
smallMotorD.stop()
print("detected stalling")
return
else:
print("wrong port selected. Select A or D")
return
def speedCalculation(speed, startspeed, maxspeed, endspeed, accelerateDistance, deccelerateDistance, brakeStartValue, drivenDistance, oldDrivenDistance):
"""
Used to calculate all the speeds in out programs. Done seperatly to reduce redundancy. Brakes and accelerates
Parameters
-------------
speed: The current speed the robot has
startspeed: Speed the robot starts at. Type: Integer. Default: No default value.
maxspeed: The maximum speed the robot reaches. Type: Integer. Default: No default value.
endspeed: Speed the robot aims for while braking, minimum speed at the end of the program. Type: Integer. Default: No default value.
addspeed: Percentage of the distance after which the robot reaches the maximum speed. Type: Integer. Default: No default value.
brakeStartValue: Percentage of the driven distance after which the robot starts braking. Type: Integer. Default: No default value.
drivenDistance: Calculation of the driven distance in degrees. Type: Integer. Default: No default value.
"""
addSpeedPerDegree = (maxspeed - startspeed) / accelerateDistance
subSpeedPerDegree = (maxspeed - endspeed) / deccelerateDistance
subtraction = (abs(drivenDistance) - abs(oldDrivenDistance) if abs(drivenDistance) - abs(oldDrivenDistance) >= 1 else 1) * subSpeedPerDegree
addition = (abs(drivenDistance) - abs(oldDrivenDistance) if abs(drivenDistance) - abs(oldDrivenDistance) >= 1 else 1) * addSpeedPerDegree
if abs(drivenDistance) > abs(brakeStartValue):
if abs(speed) > abs(endspeed):
speed = speed - subtraction
elif abs(speed) < abs(maxspeed):
speed = speed + addition
return speed
def breakFunction(args):
"""
Allows you to manually stop currently executing round but still stays in main.
This is much quicker and more reliable than pressing the center button.
"""
global cancel, inMain
if not inMain:
cancel = True
def pidCalculation(speed):
#golbally sets PID values based on current speed of the robot, allows for fast and accurate driving
global pRegler
global iRegler
global dRegler
#Important note: These PID values are experimental and based on our design for the robot. You will need to adjust them manually. You can also set them statically as you can see below
if speed > 0:
pRegler = -0.17 * speed + 12.83
iRegler = 12
dRegler = 1.94 * speed - 51.9
if pRegler < 3.2:
pRegler = 3.2
else:
pRegler = (11.1 * abs(speed))/(0.5 * abs(speed) -7) - 20
iRegler = 10
#iRegler = 0.02
dRegler = 1.15**(- abs(speed)+49) + 88
def pidCalculationLight(speed):
#Sets the PID values for the lineFollower based on current speed. Allows for accurate and fast driving
#Important note: these PID values are experimental and based on our design for the robot. You will need to adjust them. See above on how to do so
global pReglerLight
global dReglerLight
pReglerLight = -0.04 * speed + 4.11
dReglerLight = 0.98 * speed - 34.2
#set hard bottom for d value, as otherwise the values don't work
if dReglerLight < 5:
dReglerLight = 5
def driveMotor(rotations, speed, port):
"""
Allows you to drive a small motor in parallel to driving with gyroStraightDrive
Parameters
-------------
rotations: the rotations the motor turns
speed: the speed at which the motor turns
port: the motor used. Note: this cannot be the same motors as configured in the motor Drivebase
"""
global runSmall
global run_generator
if cancel:
runSmall = False
run_generator = False
while runSmall:
smallMotor = Motor(port)
smallMotor.set_degrees_counted(0)
loop_small = True
while loop_small:
drivenDistance = smallMotor.get_degrees_counted()
smallMotor.start_at_power(speed)
if (abs(drivenDistance) > abs(rotations) * 360):
loop_small = False
if cancel:
loop_small = False
yield
smallMotor.stop()
runSmall = False
run_generator = False
yield
hub2.motion.yaw_pitch_roll(0)
db = DriveBase(hub, 'A', 'B') #this lets us conveniently hand over our motors (B: left driver; C: right driver). This is necessary for the cancel function
def exampleOne():
#This example aims to show all the options for following a line. See the specific documentation of the function for further information.
db.lineFollower(15, 25, 35, 25, 'E', 'left') #follows the left side of a line on the E sensor for 15cm. Accelerates from speed 25 to 35 and ends on 25 again
hub.left_button.wait_until_pressed()
db.lineFollower(15, 25, 35, 25, 'E', 'left', 0.4, 0.6) #same line follower as before but with a longer acceleration and breaking period
hub.left_button.wait_until_pressed()
db.lineFollower(15, 25, 35, 25, 'E', 'left', stopMethod=stopMethods.stopLine(db, 'F', 0.7)) #same linefollower as the first, but this time stopping, when the other sensor sees a black line after at least 70% of the driven distance
hub.left_button.wait_until_pressed()
db.lineFollower(15, 25, 35, 25, 'E', 'left', stopMethod=stopMethods.stopResistance(db, 20)) #same as first linefollower, but stops when desired resistance is reached. Test the resistance value based on your robot
hub.left_button.wait_until_pressed()
generator = driveMotor(5, 100, 'A')
db.lineFollower(15, 25, 35, 25, 'E', 'left', generator=generator) #same as first linefollower, but drives while turning the A-Motor for 5 rotations
hub.left_button.wait_until_pressed()
db.lineFollower(15, 25, 35, 25, 'E', 'left', stop=False) #same as first linefollower, but does not actively brake the motors. The transistion form this action to the next is then smoother
return
def exampleTwo():
#This example aims to show all the options for turning the robot. See the specific documentation of the function for further information.
db.gyroRotation(90, 25, 35, 25) #turns the robot 90° clockwise while accelerating from speed 25 to 35 and back down to 25
hub.left_button.wait_until_pressed()
db.gyroRotation(90, 25, 35, 25, 0.4, 0.5) #same turning as in first rotation but with longer acceleration/braking phase
hub.left_button.wait_until_pressed()
db.gyroRotation(90, 25, 35, 25, rotate_mode=1) #same turn as in first rotation but this time turning using only one wheel rather than turning on the spot. Your speeds may need to be higher for this
hub.left_button.wait_until_pressed()
db.gyroRotation(90, 25, 35, 25, stopMethod=stopMethods.stopAlign(db, 25, 25)) #aligns the robot with a line in turning path
hub.left_button.wait_until_pressed()
db.gyroRotation(90, 25, 35, 25, stopMethod=stopMethods.stopLine(db, 'E', 25, 0.7)) #turns until the robot sees a line on sensor E after at least 70% of turning
hub.left_button.wait_until_pressed()
db.gyroRotation(90, 25, 35, 25, stopMethod=stopMethods.stopTangens(db, 25, 25)) #aligns the robot like stopAlign but is a bit more precise
hub.left_button.wait_until_pressed()
#remaining parameters are the same as in linefollower. Please refer to exampleOne or the documentation of the individual functions
return
def exampleThree():
#This example aims to show all the options for driving in a straight line. See the specific documentation of the function for further information.
db.gyroStraightDrive(30, 25, 35, 25) #drives in a straight line for 30cm
hub.left_button.wait_until_pressed()
db.gyroStraightDrive(30, 25, 55, 25, 0.1, 0.9) #same as first drive, but faster and with harder acceleration/braking
hub.left_button.wait_until_pressed()
db.gyroStraightDrive(30, 25, 35, 25, offset=15) #same as first drive, but aims 15° in clockwise direction as target orientation
#remaining features of code are explained in previous examples. Please refer to exampleOne, exampleTwo and additional documentation within individual functions
return
def exampleFour():
#This example aims to show all the options for turning in a large curve. See the specific documentation of the function for further information.
db.arcRotation(5, 35, 25, 30, 25) #robot drives 35° on a circle with a radius of 5cm measured from the inside edge of the robot
#remaining features of code are explained in previous examples. Please refer to exampleOne, exampleTwo and additional documentation within individual functions
return
def exampleFive():
#add your own code here
return
def exampleSix():
#add your own code here
return
class bcolors:
BATTERY = '\033[32m'
BATTERY_LOW = '\033[31m'
ENDC = '\033[0m'
pReglerLight = 1.6
iReglerLight = 0.009
dReglerLight = 16
accelerate = True
# see comment for breakFunction
#hub2.button.right.callback(breakFunction)
gyroValue = 0
#Battery voltage printout in console for monitoring charge
if battery.voltage() < 8000: #set threshold for battery level
print(bcolors.BATTERY_LOW + "battery voltage is too low: " + str(battery.voltage()) + " \n ----------------------------- \n >>>> please charge robot <<<< \n ----------------------------- \n"+ bcolors.ENDC)
else:
print(bcolors.BATTERY + "battery voltage: " + str(battery.voltage()) + bcolors.ENDC)
db.movement_motors.set_stop_action("hold") #hold motors on wait for increased reliability
print("successfully loaded the Go-Robot code :)")
Reference in a new issue Copy permalink