-         

Ergebnis 1 bis 3 von 3

Thema: Punktanfahren TAKTIK gesucht! (koordinatensystemantrieb)

  1. #1
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    19.02.2007
    Beiträge
    210

    Punktanfahren TAKTIK gesucht! (koordinatensystemantrieb)

    Anzeige

    Servus ich weis nicht ob ich hier richtig bin nur halt irgendwo muss ich meinen problem mal angehen

    GESUCHT
    lösung für
    def punktanfahren(self,punkt):

    Hardware 2 Schrittmotoren die am LPT hängen auf L297/L298
    anschluss motor X CLK=data bit 0 Richtung =datenbit 1
    motor Y CLK datenbit 2 richtung =datenbit 3

    ES gibt nun 8 MÖGLICHKEITEN zu fahren da es Positive und negative ganzzahlen zum anfahren gibt

    istx ,isty ist definiert

    gedanken wäre
    def motorx(self,schritte)
    wenn positiv nach rechts
    sonst schritte links

    das gleiche mit motorY

    soweit so gut das bekomm ich hin in eine richtung

    ****aber was wenn schräg****

    def schraeg(self,punkt)
    ????

    hat da jemand ne lösung
    oder gibt es sogar beispile für koorialesAnfahren
    es geht nicht !!! [-X das erst die eine achse dann die andere nacheinander fährt jedoch kann durch die datenstruktur die morore beim gleichen schritt unterschiedlich fahren



    Danke für die rückantwort

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.12.2005
    Beiträge
    535
    magic33,

    google doch mal nach Bresenham-Algorithmus. Damit müsste es gehen.

    mare_crisium

  3. #3
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    19.02.2007
    Beiträge
    210
    ok soweit hab ichs jetz mal
    Code:
                #print freasbahnliste
                self.speed = 0.005
                self.x_ist = 0
                self.y_ist = 0
                global maschine
                maschine.Move_Z_Up()
                print 'hoch'
                for x,linien in enumerate(freasbahnliste):
                    if x < (len(freasbahnliste)/2) and x > 0: # Die Hälfte = nur 1 linie *** > 0 ohne Ummriss
                        for a,punkt in enumerate(linien):
                            if a == 1:
                                maschine.Move_Z_Down()
                                print 'runter'
                            self.punktanfahren(punkt)
                            if a == (len(linien)-1):
                                maschine.Move_Z_Up()
                                print 'hoch'
                self.punktanfahren((0,0))
            
        def punktanfahren(self,punkt):
            print punkt
            xsoll=punkt[0]
            ysoll=punkt[1]
            schrittex=0
            schrittey=0
            if self.x_ist != xsoll:
                schrittex=xsoll-self.x_ist
                #print 'schrittex'
            if self.y_ist != ysoll:
                schrittey=ysoll-self.y_ist
                #print 'schrittey'
            if schrittey == 0 and schrittex != 0:
                self.fahrex(schrittex)
            if schrittex == 0 and schrittey != 0:
                self.fahrey(schrittey)
            if schrittex != 0 and schrittey != 0:
                self.fahrexy(schrittex,schrittey)
            self.x_ist = xsoll
            self.y_ist = ysoll
    
        def fahrex(self,x):
            print "Fahre X",x
            data = 1 #x vor
            data2 = 0
            if x < 0:
                data = 3 #x zurück
                data2 = 2
                x = x * (-1) #negative zahl drehen
            self.p.setInitOut(1) #motor x an            
            time.sleep(0.2)
            for s in xrange(x):
                self.p.setData(data)
                time.sleep(self.speed)
                self.p.setData(data2)
                time.sleep(self.speed)
            self.p.setData(0)
            self.p.setInitOut(0) #motor x aus            
            time.sleep(0.2)
                
        def fahrey(self,y):
            print "Fahre Y",y
            data = 4 #y vor
            data2 = 0
            if y < 0:
                data = 12 #y zurück
                data2 = 8
                y = y * (-1) #negative zahl drehen
            self.p.setSelect(1) #motor y an            
            time.sleep(0.2)
            for s in xrange(y):
                self.p.setData(data)
                time.sleep(self.speed)
                self.p.setData(data2)
                time.sleep(self.speed)
            self.p.setData(0)
            self.p.setSelect(0) #motor y aus            
            time.sleep(0.2)
    
        def fahrexy(self,x,y):
            print "Fahre XY",x,y
    muss ich beim schrägfahren auch den quatranten beachten

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •