Challenge: draw LEGO

First commit

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;
 

iqrobot.py

@@ -1,12 +1,10 @@
 # LEGO type:standard slot:6 autostart
 
-import math
+from spike import PrimeHub, Motor, MotorPair, ColorSensor, DistanceSensor, MotionSensor
-
-from spike import PrimeHub, Motor, MotorPair, ColorSensor, MotionSensor, DistanceSensor
 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
+        self.motionSensor = MotionSensor()
-        LEFT_MOTOR_PORT = 'E'
-        RIGHT_MOTOR_PORT = 'F'
 
-        # 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):
+
+    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 main(self):
+        
         '''
-        Gibt die gefahrene Strecke basierend auf den Radumdrehungen zurück 
+        self.moveStick(30)
-        '''
+        if self.colorSensor.get_reflected_light() > 1:
-        return -self.linker_motor.get_degrees_counted()/360 * self.rad_umfang
+            self.show('ANGRY')
-
-
-    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
-        
-        #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
         else:
-            richtung = 1
+            self.show('SAD')
-        while abs(drehung) > 2:
-            self.antrieb.move(amount=richtung * 0.1, steering=100)
-            drehung = self.bewegungsSensor.get_yaw_angle()
-            print(drehung)
-
-    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
-
-    def schaufel(self,prozent, speed=20):
-        """
-        Lässt die Schaufel fahren
-
-        :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.")
-
-
-
 
 
+        colorIntensity = self.getColorIntensity()
+        print("Farbintensität: " + str(colorIntensity))
+        '''
+
+    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")  
+
+    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")

iqrobot_schreiber.py

@@ -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 :)")
-
-

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 ####################################
+# Definiere an welchen Ports die Sensoren angeschlossen sind 
-'''
-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
-'''
 
+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:
+# Das Programm
-iqRobot.show('HAPPY')
  
-def huenchenaufgabe():
+# Variablen
-    iqRobot.fahre_gerade_aus(40,60)
+penStatus = False # Oben
-    iqRobot.drehe(-40,True)
-    iqRobot.fahre_gerade_aus(20,60)
-    iqRobot.drehe(-20)
-    iqRobot.fahre_gerade_aus(55,60)
-    iqRobot.heber(10,30)
 
-def hologram_alt():
+# Methoden
-    iqRobot.fahre_gerade_aus(cm=75,speed=80)
+def togglePen():
-    iqRobot.drehe(45, False)
+    global penStatus
-    iqRobot.fahre_gerade_aus(cm=14,speed=70)
+    if(penStatus == True):
-    iqRobot.fahre_gerade_aus(cm=-13,speed=50)
+        iqRobot.moveGabel(20)
-    iqRobot.drehe(-45, False)
+        penStatus = False
-    iqRobot.fahre_gerade_aus(cm=-75,speed=50)
+    if(penStatus == False):
+       iqRobot.moveGabel(-20)
+       penStatus = True
 
-def druckmaschine():
+def printChar(c):
-    iqRobot.fahre_gerade_aus(19,30)
+    global penStatus
-    iqRobot.drehe(-45)  
+    if(c == "L"):
-    iqRobot.fahre_gerade_aus(20,30)
+        print("Printing the character L")
-    iqRobot.fahre_gerade_aus(-15,30)
+        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 hologram():
+    if(c == "G"):
-    iqRobot.drehe(45)
+        print("Printing the character G")
-    iqRobot.fahre_gerade_aus(37.5,30)
+    if(c == "O"):
-    iqRobot.drehe(45)
+        print("Printing the character O")
-    iqRobot.fahre_gerade_aus(15,30)
-    iqRobot.fahre_gerade_aus(-15,30)
 
-def augmented_reality():
+wait_for_seconds(5)
-    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)
+printChar("L")
-#iqRobot.drehe(38)
+printChar("E")
-#iqRobot.fahre_gerade_aus(33,25)
+printChar("G")
-iqRobot.schaufel(1600, speed=100 )
+printChar("O")
-iqRobot.schaufel(-1600, speed=100 )