CNC Maschinchen

wilm j. schrieb:
> Reicht ein Atmega8 aus, um die drei kleinen gleichzeiitig über eine usb
> uart Schnittstelle anzusteuern ?
> Also das Progrämmchen auf dem PC ist schon in Visual Basic Express
> geschrieben. Es wird dem Atmega8 einfach sagen Motor x mach einen
> Schritt vorwärts, Motor y mach einen Schritt rückwärts, usw.

Das geht schicker. Wenn Du einen etwas größeren AtMega verwendest, 
kannst Du sogenannten G-Code verwenden, das hat den sehr großen Vorteil, 
daß deutlich weniger Daten übertragen werden müssen und daß alles 
timingkritische vom µC abgehandelt wird.

https://en.wikipedia.org/wiki/G-code

Die üblichen 3D-Drucker arbeiten auf diese Art und Weise, und der 
Sourcecode, der da verwendet wird, ist --dank open source-- frei 
verfügbar. Ein Beispiel ist "Marlin"

https://github.com/MarlinFirmware/Marlin

Auch wenn die Hardware Deiner Fräse von den üblichen Kritikern 
bestenfalls als "Käsefräse" bezeichnet werden wird, mit einer 
Ansteuerung auf G-Code-Basis hast Du einen Lerneffekt, den Du auf 
weitere Projekte übertragen können wirst.

Hallo,

g-code möchte ich erst einnmal nicht verwenden, ich möchte vorerst auch 
nur 2d-Bauteile bearbeiten.

Aber da Du meine Frage nicht verneint hast, gehe ich davon aus, dass ein 
Atmega8 reicht ?

Das wirst Du selbst ausprobieren müssen. G-Code lässt sich auch für die 
Ansteuerung von 2D-Fräsen verwenden ...

Ich halte die Vorgehensweise, den PC mehr oder weniger direkt zur 
Schrittmotorsteuerung zu verwenden für eine Sackgasse.

Hallo,

das reicht erst einmal an Infos,

ich werde dann ein Bild vom 1. Frästeil posten :-)

da klemmt nix, ist alles recht freiläufig :-)

MaWin schrieb:
> Für richtig verstandenen G-Code ist ein AVR unterdimensioniert, das
> macht ein PC mit Mach3. Ein AVR kann höchstens Geradenstückchen jeweils
> mit Anfahren und Bremsen, also unsinnig langsam.

Und was machen die ganzen AVRs, die auf den Steuerplatinen diverser 
3D-Drucker sitzen und dort G-Code interpretieren? Die Dinger bewegen 
sich deutlich schneller als übliche Fräsmaschinen.

Hallo!

Deine kleine Käsefräse sieht nicht schlecht aus, für Experimente 
ausreichend.
Schau Dir mal meine Steuerung an, ist mit wenig Kosten gebaut. Für ein 
"von Hand fahren" habe ich einen ATMEGA16 verwendet. Ansonsten ist die 
Lösung von Estlcam mit Arduino schon fast "Profi"-Version, jedenfalls 
bei meiner Steuerung.
Gruß Peter

http://www.hcp-hofbauer.de/indexcnc.htm

Hallo,

muss ich mir bei Gelegenheit mal genauer ansehen, danke für den Link.

Anbei noch ein Bild meiner kleinen Steuerungssoftware.

Schreiber schrieb:
> Die Dinger bewegen sich nur deshalb so schnell weil die Schrittmotoren
> groß und die bewegten Massen (und damit auch die Kräfte) klein sind.

Das ist klar - aber die AVR-basierten Steuerungen können die 
Schrittmotoren mit diesen Geschwindigkeiten ansteuern, d.h. sie verfügen 
über ausreichend Rechenleistung, um diese Geschwindigkeiten zu 
erreichen.
Das ist der Punkt.

Nette Bastelei. Mach doch noch ein paar Winkel an die Z-Achse, wird sie 
gleich stabiler.
Zu Ansteuerung würde ich Dir irgendsoein Open-Source Arduino Teil 
empfehlen.

http://www.precifast.de/cnc-steuerung-mit-arduino-und-grbl/

Schreiber schrieb:
> nicht ganz:
> 1. ein 3D-Drucker bewegt sich meist nur in zwei Achsen gleichzeitig

Der OP schrieb, dass er erstmal nur 2D-Bearbeitung wünscht.
Davon abgesehen kann bspw. Marlin ganz gut mit drei Achsen umgehen. Der 
Extruder stellt in Marlin übrigens eine vollwertige Achse dar.

> 3. die geringen Massen erleichtern die Berechnung der
> Beschleunigungsrampen

Das ist der Software völlig egal. Die berechnet die Rampen anhand der 
gewünschten Maximalbeschleunigung.
Bei größeren Massen und langsamerer Beschleunigung hat sie sogar mehr 
Zeit.

> 4. Der Druckkopf ist relativ einfach anzusteuern, jeder Impuld gibt die
> gleiche Menge Kunststoff

Bei Fräsen hat man nur die Drehzahl, die man üblicherweise einmal 
einstellt.

> Gewindeschneiden auf einer Fräsmaschine ist doch ein anderes Kaliber,
> ebenso das Fräsen von Freiformflächen mit Kurven in allen drei oder mehr
> Achsen.
>
> Einfach mal einem 3D-Drucker zuschauen, dann einer 5-Achs-Fräse
> zuschauen und vergleichen...

Ich empfehle dringend, sich das Foto des OP und seine Zielvorgaben 
anzuschauen.

Diese Fräse wird weder Gewinde schneiden noch 5-Achs-Bearbeitungen 
durchführen.

Dafür reicht ein AVR erstmal aus und die Arduino-Plattform mit Marlin 
dürfte dafür der preiswerteste Start sein (25€).

An den OP: Du solltest wirklich direkt mit G-Code beginnen. Das ist 
einfach der Standard und später kannst Du das recht problemlos auf eine 
eventuelle größere Maschine übertragen.

Eine andere kostenlose Möglichkeit wäre LinuxCNC auf PC.

Jemin K. schrieb:
> Nette Bastelei. Mach doch noch ein paar Winkel an die Z-Achse,
> wird sie
> gleich stabiler.
> Zu Ansteuerung würde ich Dir irgendsoein Open-Source Arduino Teil
> empfehlen.
>
> http://www.precifast.de/cnc-steuerung-mit-arduino-und-grbl/

Das würde die Entwicklungskosten verdoppeln ! :-)

Tany schrieb:
> https://github.com/grbl/grbl/wiki/Configuring-Grbl-v0.9
> Der 328er-Arduiono Booard schafft bis ca. 36 kHz Taktsignal für alle 3
> Achsen,kostet unter 10 Euro. Schnell genug nicht nur für Gerade, sondern
> auch Kreis, Bogen etc....
> Bei 8µStep und einer Übersetzung von 2:1 erreiche ich locker 2,5m/min.
> Beitrag "Projekt: SerialComCNC Serielles Frontend für CNC GRBL mit ATMega"

Das sieht doch schon recht interessant aus - danke für den Hinweis. Für 
einfache Steuerungen ist das durchaus eine Option :-)

Nemesis schrieb:
> Chris D. schrieb:
>> Das sieht doch schon recht interessant aus - danke für den Hinweis. Für
>> einfache Steuerungen ist das durchaus eine Option :-)
>
> Aber hat das Projekt wegen der Nutzung eines veralteten
> Schnittstellenkonzepts eine Zukunft?

Das finde ich jetzt nicht so dramatisch. Serielle Schnittstellen kann 
man problemlos emulieren. Außerdem gibt es ja den Quellcode und man kann 
durchaus weitere Schnittstellen hinzufügen.

Natürlich wird man damit kein CNC-Zentrum betreiben, aber für einfache 
Anwendungen sollte es doch reichen (Dispenser, Bestückungsautomat, 
Frontplattenbearbeitung usw.).

wilm j. schrieb:
> Anbei noch ein Bild meiner kleinen Steuerungssoftware.

Das IST G-Code, von jemandem der dummerweise nicht vorher nachgeguckt 
hat, was G-Code ist und deswegen alles inkompatibel anders gemacht hat.

Echter G-Code kann natürlich mehr. Vor allem echte Kreis(bögen) sind 
schwieriger. Vereinfachend sind die über die Definitionsstelle 
weitergeltenden Parameter. Und schick ist es, jedes Kommando bloss als 
Makro aufzufassen (wie es Mach3 tut), dann kann man durch Ablegen eines 
Makros einfach ein neues Kommando definieren.

Tany schrieb:
> man muß sich
> nicht mehr um die G-Code bemühen.

So einfach ist das jetzt auch nicht. Zumindest dann nicht, wenn man das 
Programm NICHT nur von vorn bis zum Ende durchlaufen lassen will. Will 
man am PC eine Bewegungssimulation oder nur die Bahnen anzeigen, muß man 
den GCode-Interpreter dann sogar zweimal implementieren (und das 
hoffentlich kompatibel).

MaWin schrieb:
> Für richtig verstandenen G-Code ist ein AVR unterdimensioniert, das
> macht ein PC mit Mach3. Ein AVR kann höchstens Geradenstückchen jeweils
> mit Anfahren und Bremsen, also unsinnig langsam.
> Serielle mit Steps bei 115000bps und 3 Achsen pro Byte (und 4 bit für
> Zeitpunkt) erlaubt zwar 11000 Schritte pro Sekunde, aber im festen
> Raster von 1/11000 Sekunde, was zu ruckeligem Fahren führt (mit der
> Frage, ob das VB Programm hinterherkommt) . Pro byte nur 1 Achse aber 6
> bit Zeitpunkt macht 3600 Schritte pro Sekunde, besseres timing erlaubt,
> aber nur 500upm im Halbschritt erlaubt, Mikroschritt damit eher
> verbietet.

Wenn man über ein Thema nicht wirklich Bescheid weiss, sollte man nicht 
solch einen Unsinn posten.
MaWin ich bin von Dir echt enttäuscht :)

Ich empfehle Dir dringend das Studium von
https://github.com/grbl/grbl/wiki

Hallo,

habe mir jetzt einen "Serial Converter CP2102" zugelegt und ein kleiner 
Atmega8 ist auch schon bestellt.

Hat jemand einen link wo beschrieben ist, wie ich die beiden genau 
miteinander verbinde ?

is' ja cool


und der emuliert mir auch gleich meine serielle schnittstelle ?

und programmieren kann ich ihn auch gleich ?

mh, sehe gerade, dass das teil nur 14 I/O Pins hat, das wird knapp für 
obiges vorhaben

3x motoren mit je 4 pins bin ich schon bei 12

fräsmotor an/aus schalten vielleicht nochmal 2 ?

da sind rückmeldungen zum rechner nicht mehr möglich

wilm j. schrieb:
> Dazu habe ich mir 3x 28BYJ-48 – 5V Schrittmotoren beim Chinesen meines
> Vetrauens bestellt.

Also diese hier:
http://www.ebay.de/itm/28BYJ-48-5V-Schrittmotor-DC-inkl-Endstufe-ULN2003-Treiber-Board-fur-Arduino-/171564426881?hash=item27f2096681

Wenn Du die mit den beliegenden ULN2003 Treiber Board mit 5V betreibst, 
dann kannst Du Fräsen knicken. Die Achse hält man mit 2 Fingern locker 
fest.

Ich habe damit auch schon mal experimentiert und um dem Ganzen etwas 
Drehmoment zu verleihen hilft:
ULN2003 Treiber Board mit 12 V betreiben. Dann werden die Motörchen 
allerdings heiss.

Oder gleich besser A4988 Boards an mind. 12V nehmen:
http://www.ebay.de/itm/A4988-Stepper-Motor-Schrittmotor-Treiber-Driver-3D-Drucker-Arduino-RepRap-CNC-/221727610250?hash=item339ffed58a
Die Temperatur der Motörchen bleibt dabei gemässigt und das Drehmoment 
ist für die nagelgrossen Motörchen gut.
Und Du kommst dann auch mit den benötigten Pins zurecht. Pro Achse nur 
Step- und Direction-Pin, event. noch Enable.

Allerdings wird Dir das Fräsen trotz allem keinen Spass bereiten.
Die 28BYJ-48 Motörchen haben unglaubliches Vor- Rückwärts-Spiel im 
eingebauten Getriebe. Fast schon eine viertel Achsumdrehung.

wilm j. schrieb:
> habe mir jetzt einen "Serial Converter CP2102" zugelegt und ein kleiner
> Atmega8 ist auch schon bestellt.

Warum einen ollen Atmega 8 und CP2102?
Tany hat Dir dazu ja auch schon geschrieben.

Aber mach mal, jeder muss da seine eigenen Erfahrungen machen.
Ich musste da auch mal durch :)

W.S. schrieb:
> wilm j. schrieb:
>> Also das Progrämmchen auf dem PC ist schon in Visual Basic Express
>> geschrieben. Es wird dem Atmega8 einfach sagen Motor x mach einen
>> Schritt vorwärts, Motor y mach einen Schritt rückwärts, usw.
>
> Genau DAS ist der falsche Denkansatz.
>
> Bedenke doch, daß das BS auf dem PC den Anwendungen die Rechenzeit nach
> seinem Gutdünken zuteilt. Darauf kannst du keine zeitabhängigen
> Funktionen aufbauen. Sowas MUSS also in den µC hinein. Der muß dann die
> Koordination aller beteiligten Dinge, also X zu Y, Anlaufverhalten,
> Bremszeiten usw. erledigen.
>
> Auf der Schnittstelle zwischen PC und µC sähe das dann etwa so aus:
> wert X; wert Y; up Fräser; schnellgang; stop;
> wert X; wert Y; down Fräser; geraderfräsgang; stop;
>
> und alle Zeit- und Koordinatenberechnungen macht der µC anschließend.
>
> W.S.

ja das habe ich mittlerweile auch eingesehen, werde es jetzt so machen, 
dass die teilstrecke übertragen wird den rest macht dann der atmega


> Wenn Du die mit den beliegenden ULN2003 Treiber Board mit 5V betreibst,
> dann kannst Du Fräsen knicken. Die Achse hält man mit 2 Fingern locker
> fest.

das kann ich nicht nachvollziehen, habe sie getestet und gemerkt, dass 
sie recht kraftvoll sind
spiel habe ich ebenfalls nicht festellen können


aber wie verbinde ich denn nun den Serial Converter CP2102 mit dem 
atmega ?

hallo, gibt es irgendwo ein beispiel für die kommunikation zwischen pc 
und cp2102 in bascom ?

wilm j. schrieb:
> hallo, gibt es irgendwo ein beispiel für die kommunikation zwischen pc
> und cp2102 in bascom ?

Google kaputt?
Bascom Hilfe defekt?
Befehle print input get irgenwo verloren?

hallo,

ich habe jetzt die verbidnung hinbekommen.
ich kann vom pc senden und empfangen.

leider ist die übertragung recht fehlerhaft, nur ca. jedes 3. 
sendesignal kommt korrekt an.

die baudrate ist im controller und im pc auf 1200 eingestellt.

aus dem bascom progi:

$regfile = "m8adef.dat"
$crystal = 1000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 4800
Kommunikation mit dem pc
Enable Urxc
On Urxc Onrxd
Enable Interrupts
Dim Ts As String * 10
do
...
...
loop

Onrxd:
   Ts = Ts + Chr(udr)
Return

ne sind schon 1200 auf beiden seiten

wilm j. schrieb:
> ne sind schon 1200 auf beiden seiten

Und warum dann das Coding mit 4800? war hier falsch übernommen, es sind 
1200

Stop-Bit? 1

Fluss-Steuerung ausgeschaltet? ja

Einstellung virt. COM-Port?
1200 bits/sek
datenbits: 8
parität: keine
stoppbits: 1
flusssteuerung: keine

Die Steuerungs-SW ist selbst geschrieben? jo, aber sie macht ja auch 
nicht viel außer ein paar zeichen senden und empfangen. und ab und zu 
kommt ja auch der richtige wert zurück.

Sicher, dass dort alles O.K. ist? jo

Ich würde mal mit HTERM ein paar Daten / Befehle austauschen.

Aufbau gelötet oder via Steckbrett? steckbrett

würde ein quarz evtl. die sache etwas stabiler in der übertragung machen 
?

habe jetzt eine text-datei über hterm gesendet

die daten stimmen

keine ahnung was man da falsch machen kann, in der steuerungs-sw steht 
jedenfalls das hier :

        SerialPort1.PortName = "COM6"
        SerialPort1.BaudRate = "1200"
        SerialPort1.DataBits = 8
        SerialPort1.Parity = Parity.None
        SerialPort1.StopBits = StopBits.One
        SerialPort1.Handshake = Handshake.None
        SerialPort1.Encoding = System.Text.Encoding.Default
        SerialPort1.Open()

zum senden benutze ich dann:

        SerialPort1.Write("blabla" & vbCr)

sollte doch so funktionieren, oder gibt es beim atmega8 besonderes zu 
beachten ?

mh, habe jetzt anstatt "default" "ascii" genommen

wie vorher, funktioniert die datenübertragung nur ab und zu korrekt

bringt auch alles nix

hatte mittlerweile zum testen auf com2 umbenannt, hat aber auch nix 
gebracht

hterm habe ich auch nochmals angeschmissen, hatte mich vertan, es 
werdern doch nicht alle daten korrekt zurückgegeben


shit..

folgende zeilen liefern ein exakte übereinstimmung der daten:
Onrxd:
   I = Udr
   Print Chr(i);
Return
(siehe anhang weißes feld zeile 1-6)

wenn es so eingestellt ist, ist die übertragung fehlerhaft:
Onrxd:
   I = Udr
   Print Chr(i)
Return
(siehe anhang weißes feld zeile 7-)

wilm j. schrieb:
> Print Chr(i);

> Print Chr(i)


Das Print-Kommando hängt einen Zeilenvorschub an, wenn es nicht mit 
einem Semikolon abgeschlossen wird.

Der Empfang funktioniert also völlig korrekt, Du hast die empfangenen 
Daten nur "falsch" ausgegeben.

nein warum auch immer nicht, denn der code

Onrxd:
   I = Udr
      Ts = Ts + Chr(i)
      Print Ts
Return

liefert das ergebnis wie im anhang dargestellt.

übertragen wurde das wort "spindel"

wilm j. schrieb:
> mh, sehe gerade, dass das teil nur 14 I/O Pins hat, das wird knapp für
> obiges vorhaben
>
> 3x motoren mit je 4 pins bin ich schon bei 12
>
> fräsmotor an/aus schalten vielleicht nochmal 2 ?
>
> da sind rückmeldungen zum rechner nicht mehr möglich

vielleicht ein Arduino mighty 1284p mit mehr flash, mehr Ram, mehr 
Ports?
http://www.ebay.com/itm/Mighty-Mini-ATMega1284p-compatible-with-Arduino-/331463717483

dazu noch einen FTDI oder CH340 Adapter für USB an PC

wilm j. schrieb:
> nein warum auch immer nicht, denn der code

Hier liegt der Fehler darin, daß Du die Print-Anweisung in Onrxd 
aufrufst, was je nach Menge der bereits empfangenen Zeichen einfach 
länger dauert, als Du dafür Zeit hast.

Bedenke, daß die Zeichen mit einer konstanten Datenrate eintrudeln; wenn 
Du aber Dich noch mit einem einzelnen Zeichen beschäftigst, wenn schon 
das nächste ankommt, dann geht dieses nächste Zeichen unweigerlich 
verloren.

Du solltest in Onrxd die empfangen Zeichen nur in einen Puffer 
stopfen, die Auswertung (und vor allem das Wieder-Zurücksenden) aber an 
anderer Stelle.

Tany schrieb:
> Ich sehe nirgendwo eine Puffer deklariert, weder für rx nocht tx...

Eben. Das muss er halt alles noch basteln.

ich dachte folgender code würde zum erfolg führen:

On Urxc Onrxd
Enable Urxc
Enable Interrupts

Dim Ts As String * 10

do
.
.
.
loop

Onrxd:
   I = Udr
   Ts = Ts + Chr(i)
Return


tut's aber nich, oder eben nur manchmal

und wenn ich anstatt

Onrxd:
   I = Udr
   Ts = Ts + Chr(i)
Return

mit

Onrxd:
   I = Udr
   Print Chr(i);
Return

i direkt ausgebe

werden die richtigen daten ausgegeben

also wo bleiben denn wohl die fehlenden zeichen wenn ich versuche den 
string wieder zusammenzusetzen?

Wenn Du hier immer nur Bruchstücke des kompletten Codes einstellst wird 
das nix.

$regfile = "m8adef.dat"
$crystal = 1000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 1200
'Config Serialin = Buffered , Size = 10

'Kommunikation mit dem pc
'Config Serialin = Buffered , Size = 30 , Bytematch = 13
On Urxc Onrxd
Enable Urxc
Enable Interrupts
Dim I As Byte
Dim Ez As Integer 
'kontrollzaehler für empfangswerte (bei ez=3)alles empfangen
Dim Uee As String * 1                                       'zum 
festestellen des uebertragungsende
Dim Ts As String * 100                                      'teilstring 
emfangener daten
Dim Ltsk As Integer                                         'laenge 
teilstring mit abgeschnittenem "enter"
Dim Dx As Long
Dim Dy As Long
Dim Dz As Long
Dim Actcom As String * 100                                  'aktuelles 
kommando
'fräsarbeiten
Declare Sub Bewegung(byval Wx As Long , Byval Wy As Long , Byval Wz As 
Long , Byval Spmm As Long)
Declare Sub Motorx(rx As Integer)
Declare Sub Motory(ry As Integer)
Declare Sub Motorz(rz As Integer)
Dim Indx As Integer , Indy As Integer , Indz As Integer     'zustaende 
für motorx,y,z
   Indx = 1
   Indy = 1
   Indz = 1

'ports setzen
Config Portb = Output
Config Portc = Output
Config Portd.7 = Output                                     'spindel


'motorzustaende
  'motorx
   Dim Mx(4) As Byte
   Mx(1).1 = 1
   Mx(1).2 = 1
   Mx(1).3 = 0
   Mx(1).4 = 0
   Mx(2).1 = 0
   Mx(2).2 = 1
   Mx(2).3 = 1
   Mx(2).4 = 0
   Mx(3).1 = 0
   Mx(3).2 = 0
   Mx(3).3 = 1
   Mx(3).4 = 1
   Mx(4).1 = 1
   Mx(4).2 = 0
   Mx(4).3 = 0
   Mx(4).4 = 1
  'motory
   Dim My(4) As Byte
   My(1).1 = 1
   My(1).2 = 1
   My(1).3 = 0
   My(1).4 = 0
   My(2).1 = 0
   My(2).2 = 1
   My(2).3 = 1
   My(2).4 = 0
   My(3).1 = 0
   My(3).2 = 0
   My(3).3 = 1
   My(3).4 = 1
   My(4).1 = 1
   My(4).2 = 0
   My(4).3 = 0
   My(4).4 = 1
  'motorz
   Dim Mz(4) As Byte
   Mz(1).1 = 1
   Mz(1).2 = 1
   Mz(1).3 = 0
   Mz(1).4 = 0
   Mz(2).1 = 0
   Mz(2).2 = 1
   Mz(2).3 = 1
   Mz(2).4 = 0
   Mz(3).1 = 0
   Mz(3).2 = 0
   Mz(3).3 = 1
   Mz(3).4 = 1
   Mz(4).1 = 1
   Mz(4).2 = 0
   Mz(4).3 = 0
   Mz(4).4 = 1






Do
'Kommandoempfangsroutine
Uee = Right(ts , 1)
If Asc(uee) = 13 Then
   Ltsk = Len(ts) - 1
   Ts = Left(ts , Ltsk)
   Print "Ts:"
   Print Ts
   'Actcom auswerten
   If Actcom = "dx" Then
      Dx = Val(ts)
      Actcom = ""
      'Print "dx: " ; Dx
      End If
   If Actcom = "dy" Then
      Dy = Val(ts)
      Actcom = ""
      'Print "dy: " ; Dy
      End If
   If Actcom = "dz" Then
      Dz = Val(ts)
      Actcom = ""
      'Print "dz: " ; Dz
      End If

   'TS auswerten
   If Ts = "dx" Then
      Actcom = "dx"
      'Print "Actcom = dx"
      End If
   If Ts = "dy" Then
      Actcom = "dy"
      'Print "Actcom = dy"
      End If
   If Ts = "dz" Then
      Actcom = "dz"
      'Print "Actcom = dz"
      End If
   If Ts = "spindel" Then
      Actcom = "spindel"
      End If
   If Ts = "go" Then
      Actcom = "go"
      End If
   Ts = ""
End If
   If Actcom = "spindel" Then
      Toggle Portd.7
      Actcom = ""
      End If
   If Actcom = "go" Then
      Call Bewegung(dx , Dy , Dz , 4000.1)
      Actcom = ""
      End If


Loop



Onrxd:
   I = Udr
   Ts = Ts + Chr(i)
Return

Sub Bewegung(byval Wx As Long , Byval Wy As Long , Byval Wz As Long , 
Byval Spmm As Long)
   'schritte und teilschritte
   Dim Schritt As Long
   'nötige schritte
   Dim Srx As Long , Sry As Long , Srz As Long
   'maximale schritte aus srx,sry,srz
   Dim Srmax As Long
   'hilfsvar
   Dim Srmaxsrx As Long , Srmaxsry As Long , Srmaxsrz As Long
   'schritte ermitteln
   Srx = Wx * Spmm
   Sry = Wy * Spmm
   Srz = Wz * Spmm
   If Srx >= Sry Then
      Srmax = Srx
      Else
      Srmax = Sry
      End If
   If Srz > Srmax Then
      Srmax = Srz
      End If
   'go signale für schrittmotorimpuls 1=vorwärts, -1=rückwärts
   Dim Gox As Integer , Goy As Integer , Goz As Integer
   'auslöseintervalle
   Dim Isrx As Long , Isry As Long , Isrz As Long
   Isrx = 0
   Isry = 0
   Isrz = 0
   For Schritt = 1 To Srmax
      Gox = 0
      Goy = 0
      Goz = 0
      'Motor x
      If Srx <> 0 Then
         Isrx = Isrx + 1
         Srmaxsrx = Srmax / Srx
         If Isrx = Abs(srmaxsrx) Then
            Isrx = 0
            Gox = Abs(srx) / Srx
            End If
         End If
      'Motor y
      If Sry <> 0 Then
         Isry = Isry + 1
         Srmaxsry = Srmax / Sry
         If Isry = Abs(srmaxsry) Then
            Isry = 0
            Goy = Abs(sry) / Sry
            End If
         End If
      'Motor z
      If Srz <> 0 Then
         Isrz = Isrz + 1
         Srmaxsrz = Srmax / Srz
         If Isrz = Abs(srmaxsrz) Then
            Isrz = 0
            Goz = Abs(srz) / Srz
            End If
         End If
      'Daten zum Motor schicken
      Call Motorx(gox)
      Call Motory(goy)
      Call Motorz(goz)

      'aktuelle koordinaten
'      Akx + = Gox / Spmm
'      Aky + = Goy / Spmm
'      Akz + = Goz / Spmm
      Next
End Sub

Sub Motorx(rx As Integer )
   Indx = Indx + Rx
   'wenn obergrenze erreicht, dann auf anfang setzen
   If Indx > 4 Then
      Indx = 1
      End If
   'wenn untergrenze erreicht, dann auf ende setzen
   If Indx < 1 Then
      Indx = 4
      End If
   'ports setzen
   Portb.0 = Mx(indx).1
   Portb.1 = Mx(indx).2
   Portb.2 = Mx(indx).3
   Portb.3 = Mx(indx).4
End Sub
Sub Motory(ry As Integer )
   Indy = Indy + Ry
   'wenn obergrenze erreicht, dann auf anfang setzen
   If Indy > 4 Then
      Indy = 1
      End If
   'wenn untergrenze erreicht, dann auf ende setzen
   If Indy < 1 Then
      Indy = 4
      End If
   'ports setzen
   Portb.4 = My(indy).1
   Portb.5 = My(indy).2
   Portc.0 = My(indy).3
   Portc.1 = My(indy).4
End Sub
Sub Motorz(rz As Integer )
   Indz = Indz + Rz
   'wenn obergrenze erreicht, dann auf anfang setzen
   If Indz > 4 Then
      Indz = 1
      End If
   'wenn untergrenze erreicht, dann auf ende setzen
   If Indz < 1 Then
      Indz = 4
      End If
   'ports setzen
   Portc.2 = Mz(indz).1
   Portc.3 = Mz(indz).2
   Portc.4 = Mz(indz).3
   Portc.5 = Mz(indz).4
End Sub

hab das ganze mal entschlackt und auf das nötigste reduziert:

$regfile = "m8adef.dat"
$crystal = 1000000
$hwstack = 100
$swstack = 100
$framesize = 100
$baud = 1200

On Urxc Onrxd
Enable Urxc
Enable Interrupts
Dim I As Byte
Dim Uee As String * 1
Dim Ts As String * 100

Do
Uee = Right(ts , 1)
If Asc(uee) = 13 Then
   Print "Ts:"
   Print Ts
   Ts = ""
End If

Loop

Onrxd:
   Ts = Ts + Chr(udr)
Return



funktioniert aber immernoch nich richtig

Von Bascom habe ich kaum Ahnung, aber das funktioniert zuerst mal auch 
mit 115200 baud. Must nur den Kopf anpassen. An deiner Stelle würde ich 
aber für alle Fälle einen Buffer vorsehen damit nichts verloren geht..

1

$regfile = "m328pdef.dat"

2

$crystal = 16000000

3

$hwstack = 100

4

$swstack = 100

5

$framesize = 100

6

$baud = 115200

7

8

On Urxc Onrxd

9

Enable Urxc

10

Enable Interrupts

11

12

Dim Ts As String * 100

13

Dim Flagrx As Boolean

14

15

Ts = ""

16

Flagrx = 0

17

18

Do

19

20

If Flagrx = 1 Then

21

  If Right(ts , 1) = Chr(13) Then

22

    Print "Ts: " ; Ts

23

    Ts = ""

24

  End If

25

  Flagrx = 0

26

End If

27

28

Loop

29

30

31

32

Onrxd:

33

   Ts = Ts + Chr(udr)

34

   Flagrx = 1

35

Return

besten dank an albert für den überarbeiteten code, es funktioniert,
allerdings mit $baud = 4800

warum der coe besser funktioniert als meiner verstehe ich allerdings 
nicht, aer egal.

jetzt bräuchte ich allerdings noch eine güntige stromquelle.
hat da jemand was für folgende verbraucher:
3x schrittmotor 28BYJ-48 – 5V
1x fräsmotor 5 -12V
1x atmega

kann man da vielleicht auch ein altes pc-netzteil nehmen ?