diff --git a/README.md b/README.md index d7c0858..baba04a 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Importiere den Code entweder über die Shell oder einen Git Client: - für Mac oder Windows: https://www.sourcetreeapp.com/ -Benutzername und Passwort für Makerlab eingeben +Username und PW für Makerlab eingeben Übersicht über Git Commands: https://ndpsoftware.com/git-cheatsheet.html#loc=workspace; diff --git a/iqrobot.py b/iqrobot.py index b830cd8..2d67cd8 100644 --- a/iqrobot.py +++ b/iqrobot.py @@ -1,12 +1,10 @@ # LEGO type:standard slot:6 autostart -import math - -from spike import PrimeHub, Motor, MotorPair, ColorSensor, MotionSensor, DistanceSensor +from spike import PrimeHub, Motor, MotorPair, ColorSensor, DistanceSensor, MotionSensor from spike.control import wait_for_seconds -print("Lade IQ-Bibliothek") - +HELLO = "HELLO IQ" +VERSION = "V1" ''' Wir nutzen "Duck typing", dh wir schreiben hinter jede Variabel mit ':' die Klasse, zB `leftMotor: Motor` @@ -14,38 +12,25 @@ damit man dann später auch wieder Code Completion hat bei Nutzung der Variablen ''' class IQRobot: - def __init__(self, hub: PrimeHub): - + def __init__(self, hub: PrimeHub, leftMotorPort: str, rightMotorPort: str, colorSensorPort: str, stickMotorPort: str, gabelMotorPort: str, distanceSensorPort: str): self.hub: PrimeHub = hub + if (leftMotorPort != ''): + self.leftMotor: Motor = Motor(leftMotorPort) + if (rightMotorPort != ''): + self.rightMotor: Motor = Motor(rightMotorPort) + if (leftMotorPort != '' and rightMotorPort != ''): + self.movementMotors: MotorPair = MotorPair(leftMotorPort, rightMotorPort) + if (colorSensorPort != ''): + self.colorSensor: ColorSensor = ColorSensor(colorSensorPort) + if (stickMotorPort != ''): + self.stickMotor: Motor = Motor(stickMotorPort) + if (gabelMotorPort != ''): + self.gabelMotor: Motor = Motor(gabelMotorPort) + if (distanceSensorPort != ''): + self.distanceSensor: DistanceSensor = DistanceSensor(distanceSensorPort) - # Radantrieb - LEFT_MOTOR_PORT = 'E' - RIGHT_MOTOR_PORT = 'F' + self.motionSensor = MotionSensor() - # Motoren für Aufsätze - FRONT_MOTOR_RIGHT_PORT = "B" - FRONT_MOTOR_LEFT_PORT = "A" - - self.bothFrontMotors: MotorPair = MotorPair(FRONT_MOTOR_LEFT_PORT, FRONT_MOTOR_RIGHT_PORT) - self.linker_motor_vorne: Motor = Motor(FRONT_MOTOR_LEFT_PORT) - self.linker_motor_vorne.set_stall_detection(stop_when_stalled=True) - self.rechter_motor_vorne: Motor = Motor(FRONT_MOTOR_RIGHT_PORT) - self.rechter_motor_vorne.set_stall_detection(stop_when_stalled=True) - - self.linker_motor: Motor = Motor(LEFT_MOTOR_PORT) - - self.antrieb: MotorPair = MotorPair(LEFT_MOTOR_PORT, RIGHT_MOTOR_PORT) - # Radumfang neu berechnen und Motor konfigurieren - # Radius der Antriebsräder - self.rad_radius = 2.1 - # Abstand zwischen Rädern (Mitte) und Vorderseite des Roboters - self.abstand_rad_front = 5.55 - self.rad_umfang = 2 * math.pi * self.rad_radius - self.antrieb.set_motor_rotation(self.rad_umfang) - - self.bewegungsSensor: MotionSensor = MotionSensor() - - self.abstandsSensor: DistanceSensor = DistanceSensor("D") def show(self, image: str): ''' @@ -54,180 +39,130 @@ class IQRobot: ''' self.hub.light_matrix.show_image(image) - def strecke_gefahren(self): - ''' - Gibt die gefahrene Strecke basierend auf den Radumdrehungen zurück - ''' - return -self.linker_motor.get_degrees_counted()/360 * self.rad_umfang + + def driveForward_for_sec(self, seconds: float): + # Fahre die übergebene Anzahl seconds gerade aus + self.movementMotors.start() + wait_for_seconds(seconds) + self.movementMotors.stop() + + + def driveBackward_for_sec(self, seconds: float): + # Fahre die übergebene Anzahl seconds gerade aus + self.movementMotors.set_default_speed(-100)() + self.movementMotors.start() + wait_for_seconds(seconds) + self.movementMotors.stop() + + def getColorIntensity(self): + # Ermittele Farbintensität über den Farbsensor + (red, green, blue, colorIntensity) = self.colorSensor.get_rgb_intensity() + return colorIntensity - def drehe(self, grad=90, with_reset=True, speed=10): - """ - Funktion um den Roboter auf der Stelle zu drehen - - :param int grad: Grad um die der Roboter gedreht werden soll - mittels Vorzeichen +/- kann links oder rechts herum gedreht werden - :param bool with_reset: Parameter, um den Gierwinkel zurückzusetzen, Standard: True - """ - - # ist überhaupt etwas zu tun für uns? d.h. grad ist enweder 0 oder 360 - if grad == 0 or grad == 360 : - print("nichts zu tun") - return - - # soll der Gierwinkel zurückgesetzt werden? - if with_reset: - self.bewegungsSensor.reset_yaw_angle() # Gierwinkel zurücksetzen + def main(self): - #steering = 100 if grad > 0 else -100 - toleranz = 0 # Toleranz soll null sein. Kann erhöht werden, falls der Roboter sich unendlich dreht. - aktuell = self.bewegungsSensor.get_yaw_angle() # Aktuelle Position - ziel = grad - steering = 100 if ziel > aktuell else -100 - self.antrieb.start(steering=steering, speed=speed) # Mit bestimmer Geschwindigkeit starten - differenz = ziel - aktuell - print ("Start Ziel: {}, Aktuell: {}".format(ziel, aktuell)) - - # wiederhole solange der Grad der Drehung noch nicht erreicht ist - while abs(differenz) > toleranz : - aktuell = self.bewegungsSensor.get_yaw_angle() - differenz = ziel - aktuell - pass - - # stoppe die Bewegung - self.antrieb.stop() - print ("Final Ziel: {}, Aktuell: {}".format(ziel, aktuell)) - - def fahre_gerade_aus(self, cm, speed=20): - """ - Funktion um den Roboter geradeaus fahren zu lassen - - :param int cm: Strecke in cm, die der Roboter geradeaus fahren soll - :param int speed: Geschwindigkeit zum Fahren der Strecke, Standard: 20 - """ - - # ist überhaupt etwas zu tun für uns? d.h. cm = 0 - if cm == 0 : - print("nichts zu tun") - return - - # wollen wir vorwärts oder rückwarts fahren? - richtung = 1 - if cm < 0: - richtung = -1 - speed = speed * richtung # Die Geschwindigkeit soll negativ sein, wenn wir rückwärts fahren - - # Alles zurücksetzen - self.linker_motor.set_degrees_counted(0) - self.bewegungsSensor.reset_yaw_angle() - - # Mit irgendeiner Geschwindigkeit g>0 starten. Wert ist irrelevant - self.antrieb.start_tank(10, 10) - self.antrieb.set_default_speed(10) - - linker_speed=speed # Geschwindigkeit linker Motor - rechter_speed=speed # Geschwindigkeit rechter Motor - kp = 1.5 # Verstärkungsfaktor zur Regelung - ki = 1.0 # Integralfaktor zur Regelung - sum_cm = 0 # bereits gefahrene Strecke - versatz = 0 # aktueller Versatz - sum_versatz = 0 # Summe des Versatzes über Zeit - - # wiederhole solange die gefahrene Strecke noch nicht erreicht ist - while sum_cm < cm * richtung: - wait_for_seconds(0.05) # Sonst wird das zu oft ausgeführt - sum_cm = self.strecke_gefahren() * richtung # Gefahrene Strecke, ggf. eben negativ machen - versatz = self.bewegungsSensor.get_yaw_angle() # Um wie viel sind wir falsch? - sum_versatz = sum_versatz + versatz - abweichung = (kp * versatz + ki * sum_versatz) / 100 # Abweichung berechnen, um zu korrigieren - linker_speed = speed * (1 - abweichung * richtung) - rechter_speed = speed * (1 + abweichung * richtung) - self.antrieb.start_tank_at_power(int(linker_speed), int(rechter_speed)) # Mit neuer Geschwindigkeit starten - #print("Versatz: " + str(versatz) + " , linker Speed: " + str(linker_speed) + ", rechter Speed: " + str(rechter_speed) + ", strecke: " + str(sum_cm)) - - self.antrieb.stop() # Stoppen - self.drehe(-versatz) # Da Versatz immer != 0, korrigieren - - def fahre_mit_drehung(self, strecke1, grad, strecke2): - """ - Funktion für eine Fahrt mit 1. Strecke, dann Drehung in der Mitte, dann 2. Strecke - Vereinfacht die Logik, da der Roboter durch die Drehung einen Versatz hat gegenüber einer - Strecke die mit dem Lineal ausgemessen wurde - """ - self.fahre_gerade_geregelt(strecke1 + self.abstand_rad_front) - self.drehe(grad) - self.fahre_gerade_geregelt(strecke2 - self.abstand_rad_front) - - - #deprecated - def fahre_gerade_aus_alt(self, cm: float, speed: int): - """ - Funktion zum gerade aus fahren mit Korrektur am Ende - Wird nicht mehr aktiv genutzt, da wir jetzt fahre_gerade_aus haben, - welche geregelt ist, und der Roboter daher nicht schief wird. - - :param int cm: Zentimeter die gerade aus gefahren werden soll - :param speed: Geschwindigkeit mit der gefahren wird - """ - - self.bewegungsSensor.reset_yaw_angle() - - self.antrieb.move_tank(amount=cm,left_speed=speed, right_speed=speed) - drehung = self.bewegungsSensor.get_yaw_angle() - print(drehung) - if drehung > 0: - richtung = -1 + ''' + self.moveStick(30) + if self.colorSensor.get_reflected_light() > 1: + self.show('ANGRY') else: - richtung = 1 - while abs(drehung) > 2: - self.antrieb.move(amount=richtung * 0.1, steering=100) - drehung = self.bewegungsSensor.get_yaw_angle() - print(drehung) + self.show('SAD') - def heber(self, cm,speed): - """ - Lässt den Heber fahren - :param speed: Geschwindigkeit, mit der der Heber bewegt wird - :param cm: Um wie viel soll der Heber bewegt werden? - """ - self.bothFrontMotors.move_tank(-cm*3.3,"cm", -speed, speed) # Heber bewegen + colorIntensity = self.getColorIntensity() + print("Farbintensität: " + str(colorIntensity)) + ''' - def schaufel(self,prozent, speed=20): - """ - Lässt die Schaufel fahren + def rotateRobot(self,degrees,speed) : + #Lasse den Roboter bei Bedarf um eine bestimmte Anzahl an Grad sanft und behutsam nach Links oder Rechts drehen, + # um den Nutzer zu befriedigen + self.motionSensor.reset_yaw_angle() + if (degrees > 0): + self.leftMotor.start(speed) + self.rightMotor.start(-speed) + elif (degrees < 0): + self.leftMotor.start(-speed) + self.rightMotor.start(speed) + while (self.motionSensor.get_yaw_angle() > degrees) : + self.leftMotor.stop() + self.rightMotor.stop() + print("Disabled") - :param prozent: Auf wie viel Prozent soll die Schaufel bewegt werden? - """ - volle_umdrehung=0.29 - rotations=volle_umdrehung*prozent/100 - #self.bothFrontMotors.move(rotations, unit='rotations',speed=20) - self.bothFrontMotors.move_tank(rotations, 'rotations', speed, -speed) - - # TODO: Geregeltes Fahren ist noch nicht eingebaut - def fahre_bis_abstand(self, abstand: int, speed=30, geregelt=True): - """ - Nutzt den Abstandssensor, um zu fahren, bis ein Abstand erreicht ist - - :param abstand: Abstand zum Objekt - :param speed: Geschwindigkeit, mit der gefahren wird - :param geregelt: Soll mit Regler gefahren werden? - """ - self.antrieb.start_at_power(speed) - abstand_gerade = self.abstandsSensor.get_distance_cm() - while abstand_gerade > abstand: - abstand_gerade = self.abstandsSensor.get_distance_cm() - print(str(abstand_gerade)) - self.antrieb.stop() - - -print("Fertig geladen.") + def gyroRotation(self, angle, rotate_mode = 0, stop = True): + global run_generator, runSmall + run_generator = False + speed = 30 + + #set standard variables + rotatedDistance = 0 + steering = 1 + + #gyro sensor calibration + angle = angle * (2400/2443) #experimental value based on 20 rotations of the robot + + #Setting variables based on inputs + loop = True + gyroStartValue = self.motionSensor.get_yaw_angle() #Yaw angle used due to orientation of the self.hub. This might need to be changed + + #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: + rotatedDistance = self.motionSensor.get_yaw_angle() #Yaw angle used due to orientation of the self.hub. This might need to be changed + + print(abs(rotatedDistance - gyroStartValue)) + + #Checking for variants + #Both Motors turn, robot moves on the spot + if rotate_mode == 0: + self.rightMotor.start_at_power(int(speed) * steering) + self.leftMotor.start_at_power(int(speed) * steering) + + elif rotate_mode == 1: + + if angle * speed > 0: + self.leftMotor.start_at_power(- int(speed)) + else: + self.rightMotor.start_at_power(+ int(speed)) + + + if abs(angle) <= abs(rotatedDistance - gyroStartValue): + loop = False + break + #Stops movement motors for increased accuracy while stopping + if stop: + self.rightMotor.stop() + self.leftMotor.stop() + + return # End of gyroStraightDrive + + def moveStick(self,degrees) : + #Bewege sanft und langsam die Schleuderstange am hinteren Rumpf des Geräts + self.stickMotor.run_for_degrees(degrees) + + def moveGabel(self,degrees) : + #Bewege sanft und langsam die ungewöhnlich große sich bewegende Stange am vorderen Rumpf des Geräts + self.gabelMotor.run_for_degrees(degrees) + + def getDistance (self) : + cmDistance = self.distanceSensor.get_distance_cm(short_range=False) + return cmDistance + + def getShortDistance (self) : + cmDistance = self.distanceSensor.get_distance_cm(short_range=True) + return cmDistance + +print("Programm Library loaded") \ No newline at end of file diff --git a/iqrobot_schreiber.py b/iqrobot_schreiber.py deleted file mode 100644 index 404e187..0000000 --- a/iqrobot_schreiber.py +++ /dev/null @@ -1,187 +0,0 @@ -# LEGO type:standard slot:7 autostart - -######################################################################## -# "ALTE" VERSION MIT DER WIR VERSUCHT HABEN DAS WORT "LEGO" ZU SCHREIBEN -######################################################################## - -from spike import PrimeHub, Motor, MotorPair, ColorSensor, MotionSensor -from spike.control import wait_for_seconds - -HELLO = "HELLO IQ 2" - -''' -Wir nutzen "Duck typing", dh wir schreiben hinter jede Variabel mit ':' die Klasse, zB `leftMotor: Motor` -damit man dann später auch wieder Code Completion hat bei Nutzung der Variablen -''' -class IQRobot: - - def __init__(self, hub: PrimeHub, colorSensorPort: str, typ: str): - self.hub: PrimeHub = hub - self.typ=typ - if self.typ=="backstein": - LEFT_MOTOR_PORT = 'F' - RIGHT_MOTOR_PORT = 'B' - FRONT_MOTOR_RIGHT_PORT = "E" - self.frontMotorRight: Motor = Motor(FRONT_MOTOR_RIGHT_PORT) - elif self.typ=="brickies": - LEFT_MOTOR_PORT = 'E' - RIGHT_MOTOR_PORT = 'F' - FRONT_MOTOR_RIGHT_PORT = "B" - FRONT_MOTOR_LEFT_PORT = "A" - self.frontMotorRight: Motor = Motor(FRONT_MOTOR_RIGHT_PORT) - self.frontMotorLeft: Motor = Motor(FRONT_MOTOR_LEFT_PORT) - self.bothFrontMotors: MotorPair = MotorPair(FRONT_MOTOR_LEFT_PORT, FRONT_MOTOR_RIGHT_PORT) - - self.leftMotor: Motor = Motor(LEFT_MOTOR_PORT) - self.rightMotor: Motor = Motor(RIGHT_MOTOR_PORT) - self.movementMotors: MotorPair = MotorPair(LEFT_MOTOR_PORT, RIGHT_MOTOR_PORT) - #self.colorSensor: ColorSensor = ColorSensor(colorSensorPort) - #self.frontMotorLeft: Motor = Motor("C") - self.motionSensor: MotionSensor = MotionSensor() - - - def show(self, image: str): - ''' - Zeige Bild auf LED Matrix des Spikes - image: Bildname wie zB 'HAPPY' - ''' - self.hub.light_matrix.show_image(image) - - - def driveForward_for_sec(self, seconds: float): - # Fahre die übergebene Anzahl seconds gerade aus - self.movementMotors.start() - wait_for_seconds(seconds) - self.movementMotors.stop() - - def getColorIntensity(self): - # Ermittele Farbintensität über den Farbsensor - (red, green, blue, colorIntensity) = self.colorSensor.get_rgb_intensity() - return colorIntensity - - def drehe(self, grad=90, with_reset=True): - if with_reset: - self.motionSensor.reset_yaw_angle() - steering = 100 if grad > 0 else -100 - self.movementMotors.start(steering=steering, speed=10) - while abs(self.motionSensor.get_yaw_angle()) < abs(grad): - pass - self.movementMotors.stop() - - - def drehe_robot(self, grad=90): - if self.typ == "backstein": - radius=9.5 - stift_versatz=2.2 - if self.typ == "brickies": - radius=17.4 - stift_versatz=0.3 - self.fahre_gerade(-radius - stift_versatz) - self.drehe(grad) - self.fahre_gerade(radius - stift_versatz) - - def fahre_gerade(self, cm, zeichne=False): - if zeichne: - self.bewege_stift(1) # Stift runter - self.motionSensor.reset_yaw_angle() - if self.typ == "brickies": - cm = -cm - self.movementMotors.move(cm) - if zeichne: - self.bewege_stift(-1) # Stift hoch - versatz = self.motionSensor.get_yaw_angle() - self.drehe(grad=-versatz) - - def buchstabe_zu_segmenten(self, buchstabe): - # Segmente um Buchstaben zu schreiben - # 4_ - # 5 |__|3 - # 0 |6_|2 - # 1 - # - buchstabe_zu_segmenten = {"L": [1,1,0,0,0,1,0], "E": [1,1,0,0,1,1,1], "G": [1,1,1,0,1,1,0], "O": [1,1,1,1,1,1,0]} - return buchstabe_zu_segmenten[buchstabe] - - - def bewege_stift(self, richtung): - if self.typ == "backstein": - self.frontMotorRight.run_for_rotations(richtung*0.4) - if self.typ == "brickies": - #print("bewege stift brickies") - self.bothFrontMotors.move(-richtung*0.2, unit='rotations', speed=5) - - def schreibe_buchstabe(self, buchstabe): - print("Schreibe " + buchstabe) - segmente = self.buchstabe_zu_segmenten(buchstabe) - grad_drehung=-90 - self.fahre_gerade(2) - self.drehe_robot(-grad_drehung) # drehe rechts - for segment_nummer, segment in enumerate(segmente): - print("Segment: " + str(segment) + " , Segment Nummer: " + str(segment_nummer)) - if segment==1: - self.fahre_gerade(5, zeichne=True) - else: - self.fahre_gerade(5) - if segment_nummer != 2 and segment_nummer != 6: - self.drehe_robot(grad_drehung) # drehe links - - - def schreibeL(self, schreibe=True, zurueck=False): - if zurueck: - step = 5 - faktor = -1 - else: - step = 1 - faktor = 1 - print("Schreibe L") - #self.frontMotorRight.run_for_rotations(-0.4) - radius=9.5 - stift_versatz=2.2 - if schreibe: - self.frontMotorRight.run_for_rotations(0.4) - self.movementMotors.set_default_speed(10) - - while (True): - if step == 0: - break - if step == 1: - self.movementMotors.move(faktor * 5) - if schreibe: - self.frontMotorRight.run_for_rotations(-0.4) - if step == 2: - self.movementMotors.move(faktor * (-radius - stift_versatz)) - if step == 3: - self.drehe(faktor * -90) - if step == 4: - self.movementMotors.move(faktor*(radius - stift_versatz)) - if schreibe: - self.frontMotorRight.run_for_rotations(0.4) - if step == 5: - self.movementMotors.move(faktor * 2) - if schreibe: - self.frontMotorRight.run_for_rotations(-0.4) - if step == 6: - break - step += faktor - # Fahre 5 cm rückwerts - # dann drehe nach rechts 90° - # und fahre 2cm fohrwärts - #stift hoch - - - def schreibeLego(self): - #self.schreibeL() - #self.schreibeL(schreibe=False, zurueck=True) - self.movementMotors.set_default_speed(10) - self.bewege_stift(-1) - self.fahre_gerade(4, zeichne=True) - self.drehe_robot() - self.fahre_gerade(4, zeichne=True) - #self.schreibe_buchstabe("L") - #self.schreibe_buchstabe("E") - #self.schreibe_buchstabe("G") - #self.schreibe_buchstabe("O") - -print("successfully loaded the IQ Lego teams code :)") - - diff --git a/main.py b/main.py index 723c52b..08e2983 100644 --- a/main.py +++ b/main.py @@ -12,6 +12,7 @@ if battery.voltage() < 8000: #set threshold for battery level print("Spannung der Batterie zu niedrig: " + str(battery.voltage()) + " \n" + "--------------------------------------- \n " + "#### UNBEDINGT ROBOTER AUFLADEN !!! #### \n" + + "#### SONST KOMMT MARKUS OPTITZ !!!! #### \n" + "---------------------------------------- \n") else: print("Spannung der Batterie " + str(battery.voltage()) + "\n") @@ -27,11 +28,11 @@ def importFile(slotid=0, precompiled=False, module_name='importFile'): with open("/projects/.slots","rt") as f: slots = eval(str(f.read())) print(slots) - #print(os.listdir("/projects/"+str(slots[slotid]["id"]))) + print(os.listdir("/projects/"+str(slots[slotid]["id"]))) with open("/projects/"+str(slots[slotid]["id"])+"/__init__"+suffix,"rb") as f: print("trying to read import program") program = f.read() - #print(program) + print(program) try: os.remove("/"+module_name+suffix) except: @@ -50,70 +51,69 @@ def importFile(slotid=0, precompiled=False, module_name='importFile'): # Importiere Code aus der Datei "iqrobot.py" # Dateiname und Modulname sollten gleich sein, dann kann man Code Completion nutzen -importFile(slotid=6, precompiled=True, module_name="iqrobot") +importFile(slotid=6, precompiled=False, module_name="iqrobot") import iqrobot as iq +print(iq.HELLO) -################### Hauptcode #################################### -''' -Code zum Lösen einer Aufgabe, kann oben importierten Code nutzen -Es können auch pro Aufgabe eigene Funktionen geschrieben werden -Wichtig ist, dass die PORTS der Sensoren überall gleich sind -und auch `hub` als Instanz von PrimeHub -dh auch an die Funktionen im importierten Code übergeben werde -''' +# Definiere an welchen Ports die Sensoren angeschlossen sind +COLOR_SENSOR_PORT = 'D' +LEFT_MOTOR_PORT = 'B' +RIGHT_MOTOR_PORT = 'F' +STICK_MOTOR_PORT = '' +GABEL_MOTOR_PORT = 'E' +DISTANCE_SENSOR_PORT = '' +#penStatus = False # Initialisieren des Hubs, der Aktoren und Sensoren hub = PrimeHub() # Initialisiere Robot Klasse mit unseren Funktionen -iqRobot: iq.IQRobot = iq.IQRobot(hub) +iqRobot: iq.IQRobot = iq.IQRobot(hub, LEFT_MOTOR_PORT, RIGHT_MOTOR_PORT, COLOR_SENSOR_PORT, STICK_MOTOR_PORT, GABEL_MOTOR_PORT, DISTANCE_SENSOR_PORT) -# Führe Funktionen aus unser Robot Klasse aus: -iqRobot.show('HAPPY') +# Das Programm + +# Variablen +penStatus = False # Oben -def huenchenaufgabe(): - iqRobot.fahre_gerade_aus(40,60) - iqRobot.drehe(-40,True) - iqRobot.fahre_gerade_aus(20,60) - iqRobot.drehe(-20) - iqRobot.fahre_gerade_aus(55,60) - iqRobot.heber(10,30) +# Methoden +def togglePen(): + global penStatus + if(penStatus == True): + iqRobot.moveGabel(20) + penStatus = False + if(penStatus == False): + iqRobot.moveGabel(-20) + penStatus = True -def hologram_alt(): - iqRobot.fahre_gerade_aus(cm=75,speed=80) - iqRobot.drehe(45, False) - iqRobot.fahre_gerade_aus(cm=14,speed=70) - iqRobot.fahre_gerade_aus(cm=-13,speed=50) - iqRobot.drehe(-45, False) - iqRobot.fahre_gerade_aus(cm=-75,speed=50) +def printChar(c): + global penStatus + if(c == "L"): + print("Printing the character L") + if not(penStatus == "False"): + print("Toggling pen") + togglePen() + iqRobot.driveForward_for_sec(2.0) + # iqRobot.leftMotor.run_for_degrees(360) + # iqRobot.rotateRobot(degrees=100, speed=100) + iqRobot.gyroRotation(angle=90) + iqRobot.driveForward_for_sec(1.0) + if(c == "E"): + print("Printing the character E") + if(penStatus == True): + togglePen() + iqRobot.driveForward_for_sec(0.1) + togglePen() + iqRobot.driveForward_for_sec(1.0) + togglePen() -def druckmaschine(): - iqRobot.fahre_gerade_aus(19,30) - iqRobot.drehe(-45) - iqRobot.fahre_gerade_aus(20,30) - iqRobot.fahre_gerade_aus(-15,30) + if(c == "G"): + print("Printing the character G") + if(c == "O"): + print("Printing the character O") -def hologram(): - iqRobot.drehe(45) - iqRobot.fahre_gerade_aus(37.5,30) - iqRobot.drehe(45) - iqRobot.fahre_gerade_aus(15,30) - iqRobot.fahre_gerade_aus(-15,30) +wait_for_seconds(5) -def augmented_reality(): - iqRobot.drehe(-135) - iqRobot.fahre_gerade_aus(42,30) - iqRobot.drehe(90) - iqRobot.fahre_gerade_aus(12,30) - iqRobot.schaufel(-100) - iqRobot.fahre_gerade_aus(-3,30) - iqRobot.drehe(90) - iqRobot.fahre_gerade_aus(20,30) - iqRobot.drehe(-90) - iqRobot.fahre_gerade_aus(5,20) - -#iqRobot.fahre_gerade_aus(16, 20) -#iqRobot.drehe(38) -#iqRobot.fahre_gerade_aus(33,25) -iqRobot.schaufel(1600, speed=100 ) -iqRobot.schaufel(-1600, speed=100 ) \ No newline at end of file +printChar("L") +printChar("E") +printChar("G") +printChar("O")