Punktanfahren TAKTIK gesucht! (koordinatensystemantrieb)

[magic33]

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

[mare_crisium]

magic33,

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

mare_crisium

[magic33]

ok soweit hab ichs jetz mal

            #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