# 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())= 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 :)")