Scopeuhr mit BASCOM??

in der tat sieht das so auf das ist aber voll blööd. äähm meinst das das rein softwaretechnisch zu lösen ist? man müsste mal in eine turbo pascal unit reinschauen wie die das gemacht haben... aber damit nimmt man ja den reiz der ganzen geschichte. jemand anderes noch eine idee???

Die Inkremente für x und y entsprechdend der Größe der Vektorkomponenten wählen. Der größere Wert ist 1 der kleinere ensprechend geringer.
Das erfordert eine höhere Auflösung bei Lx und Ly. Ausgegeben wid dann nur der "ganzzahlige" Teil.
Manfred

Hä *kopfkratz* langsam jetzt bitte. Soll ich also den wertebereich erweitern und dann ins verhältniss stellen? *fragend guck*

Hallo,
ich hab in der Mittagspause mal schnell in Pseudocode skizziert,
wie ich mir so eine Line-Routine vorstelle.
Müsste eigentlich funktionieren.

Die Linien sind allerdings noch nicht balanciert,
da war noch ein Trick nötig, der mir jetzt auf
die Schnelle nicht einfällt.

Code:

---

;Drawline in Pseudocode.
;-----------------------

;Übergeben werden die Start- und Endpunkte der Linie xs,ys und ys,ye

;Die Routine braucht nur Addition /Subtrktion, kommt ohne Multiplikation / Division aus.
;Alle Variable könne Byte sein.
;Kann problemlos und einfach in Assembler kodiert werden.



Drawline(xs,ys,ys,ye)

;Längen für x und y ausrechnen
xlen=xs-xe
ylen=ys-ye

;Schrittrichtung für x und Y festlegen
if xlen>=0 then xa=1 else xa=-1
if ylen>=0 then ya=1 else ya=-1

;wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
;  ansonsten an der Y-Achse
if abs(xlen) < abs(ylen) then goto walky


walkx:
  temp=xlen
  do
    portx=xs
    porty=ys
    xs=xs+xa        :immer einen Schritt in x-Richtung weiter
    temp=temp-ylen  ;Schritt in Y-Richtung nötig ?
    if temp<=0 then  ;wenn <=0 dann ja
      temp=temp+xlen ;
      ys=ys+ya      ;Schritt in Y-Richtung
    endif
  loop until xs=xe  ;Wiederholen bis Ende der Linie

  Return  ;Ende sub



WalkY:
  temp=ylen
  do
    portx=xs
    porty=ys
    ys=ys+ya
    temp=temp-xlen
    if temp<0 then
      temp=temp+ylen
      xs=xs+xa
    endif
  loop until ys=ye
  return

---

Schau dirs halt mal an...

Ich denke immer noch über die Hardwarelösung nach,
wo die Linie auf dem Scope mittels zweier Integratoren
automatisch gezogen wird.

Gruß Jan

Wenn dx= 12 und dy = 3 ist, dann kann man in jedem Schritt x um 1 erhöhen und y um 1/4 erhöhen und erreicht bei angepasster Schrittweite gleichzeitig den Zielpunkt.
Die Ausgabewerte sollten für den D/A Wandler ganzzahlig sein, die intere Berechnung benötigt dafür eine höhere Auflösung.
Manfred

So habe mal versucht den pseudocode anzupassen, viel war ja nicht mehr zu machen... Es scheint ein bisschen buggy zu sein. Hat jemand anderes schon die hardware nachgebaut???

Code:

---

$regfile = "m128def.dat"
$crystal = 16000000

'#########Variablen Line Funktion
Dim Xlen As Long
Dim Ylen As Long
Dim Xa As Long
Dim Ya As Long
Dim Temp As Long

'#################################

Declare Sub Drawline(byval Xs As Byte , Byval Ys As Byte , Byval Xe As Byte , Byval Ye As Byte)

Config Porta = Output
Config Portc = Output
Config Portf = Output

Z Alias Portf.1

Z = 1                                                      ' dunkel


Do
Call Drawline(0 , 0 , 100 , 100)
Waitms 1


Loop

End




'Drawline in Pseudocode.
';-----------------------
'
';Übergeben werden die Start- und Endpunkte der Linie xs,ys und ys,ye
'
';Die Routine braucht nur Addition /Subtrktion, kommt ohne Multiplikation / Division aus.
';Alle Variable könne Byte sein.
';Kann problemlos und einfach in Assembler kodiert werden.


Sub Drawline(xs As Byte , Ys As Byte , Xe As Byte , Ye As Byte)

';Längen für x und y ausrechnen
xlen=xs-xe
ylen=ys-ye

';Schrittrichtung für x und Y festlegen
if xlen>=0 then xa=1 else xa=-1
if ylen>=0 then ya=1 else ya=-1

';wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
';  ansonsten an der Y-Achse
If Xlen < 0 Then Xlen = Xlen * -1
If Ylen < 0 Then Xlen = Xlen * -1
If Xlen < Ylen Then Goto Walky


walkx:
 Z = 0                                                      'licht einschalten
  temp=xlen
  do
    Porta = Xs
    Portc = Ys
    Waitus 1
    Xs = Xs + Xa                                            ':immer einen Schritt in x-Richtung weiter
    Temp = Temp - ylen                                      ';Schritt in Y-Richtung nötig ?
    If Temp <= 0 Then                                      ';wenn <=0 dann ja
      Temp = Temp + Xlen                                    ';
      Ys = Ys + Ya                                          ';Schritt in Y-Richtung
    endif
  Loop Until Xs = Xe                                        ';Wiederholen bis Ende der Linie
Goto Endofsub

WalkY:
 Z = 0
  temp=ylen
  do
    Porta = Xs
    Portc = Ys
    Waitus 1
    ys=ys+ya
    temp=temp-xlen
    if temp<0 then
      temp=temp+ylen
      xs=xs+xa
    endif
  loop until ys=ye

Endofsub:
 Z = 1                                                      'und wieder aus
  End Sub

---

Hallo Sebastian,
ich habe deinen Code noch mal überarbeitet.
Sollte jetzt funktionieren.
Hauptproblem war das Bascom die Byte-Variablen nicht
als vorzeichenbehaftete Zahlen betrachten kann.
Deshalb habe ich es auf Integer umgeändert.
Probier es doch mal aus,und gib Bescheid, was passiert.
Müsste ein Dreieck angezeigt werden.

Gruß Jan

Code:

---

$regfile = "m128def.dat"
$crystal = 16000000

'#########Variablen Line Funktion
Dim Xlen As Integer
Dim Ylen As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Temp As Integer
'#################################

Declare Sub Drawline(byval Xs As Integer , Byval Ys As Integer , Byval Xe As Integer , Byval Ye As Integer)


Config Porta = Output
Config Portc = Output
Config Portf = Output

Z Alias Portf.1

Z = 1                                                      ' dunkel


Do
Call Drawline(0 , 0 , 100 , 80 )
Call Drawline(100 , 80 , 22 , 33)
Call Drawline(22 , 33 , 0 , 0)
Waitms 1


Loop

End




Sub Drawline(xs As Integer , Ys As Integer , Xe As Integer , Ye As Integer)

';Längen für x und y ausrechnen
Xlen = Xe - Xs
Ylen = Ye - Ys

';Schrittrichtung für x und Y festlegen
If Xlen >= 0 Then Xa = 1 Else Xa = 255
If Ylen >= 0 Then Ya = 1 Else Ya = 255

';wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
';  ansonsten an der Y-Achse
If Xlen < 0 Then Xlen = Xlen * -1
If Ylen < 0 Then Ylen = Ylen * -1
If Xlen < Ylen Then Goto Walky


Walkx:
 Z = 0                                                      'licht einschalten
  Temp = Xlen
  Do
    Porta = Low(xs)
    Portc = Low(ys)
    Waitus 1
    Xs = Xs + Xa                                            ':immer einen Schritt in x-Richtung weiter
    Temp = Temp - Ylen                                      ';Schritt in Y-Richtung nötig ?
    If Temp <= 0 Then                                      ';wenn <=0 dann ja
      Temp = Temp + Xlen                                    ';
      Ys = Ys + Ya                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xs) = Low(xe)                            ';Wiederholen bis Ende der Linie
Goto Endofsub

Walky:
 Z = 0
  Temp = Ylen
  Do
    Porta = Low(xs)
    Portc = Low(ys)
    Waitus 1
    Ys = Ys + Ya
    Temp = Temp - xlen
    If Temp < 0 Then
      Temp = Temp + Ylen
      Xs = Xs + Xa
    End If
  Loop Until Low(ys) = Low(ye)

Endofsub:
 Z = 1                                                      'und wieder aus
 End Sub

---

Hallo, habe den code gleich mal probiert.
hatte noch ein anderes problem, das mir vorher nicht aufgefallen ist (siehe bild) Portc ist bestimmt irgendwie durch was anderes belegt, habe portd genommen, jetzt ist die y-linie okay...

Was den code angeht scheint er nicht zu laufen...
Er zeichnet nur eine linie von 0/0 bis 0/30 (ca 1cm hoch)

Hallo,
ich hab mir jetzt mal selbst was zum Testen zusammen gestrickt.
Und bei mir läuft die Line-Sub.
Jedenfalls auf meinem ATmega32.
Ich musste das Programm etwas vereinfachen, damit
meine Testversion-Bascom mit dem Speicher auskommt.
Aber das Prinzip der Line-Routine ist geblieben.
Auf dem Prinzip kann man aufsetzen...
Die Line-Draw Routine werde ich in Assembler schreiben,
damit es richtig schnell wird.

@Sebastian: Testest du mal ?

Gruß Jan

Code:

---

$regfile = "m32def.dat"
$crystal = 16000000

'#########Variablen Line Funktion
Dim Xs As Integer
Dim Xe As Integer
Dim Ys As Integer
Dim Ye As Integer
Dim Xlen As Integer
Dim Ylen As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Temp As Integer
Dim N As Byte
'#################################

Declare Sub Drawline()


Config Porta = Output
Config Portc = Output

'Z Alias Portf.1

'Z = 1                                                      ' dunkel


Do

Restore Daten:
For N = 1 To 14
Read Xs
Read Ys
Read Xe
Read Ye
Call Drawline()
Next

Loop
End




Sub Drawline()

';Längen für x und y ausrechnen
Xlen = Xe - Xs
Ylen = Ye - Ys

';Schrittrichtung für x und Y festlegen
If Xlen >= 0 Then Xa = 1 Else Xa = 255
If Ylen >= 0 Then Ya = 1 Else Ya = 255

';wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
';  ansonsten an der Y-Achse
If Xlen < 0 Then Xlen = Xlen * -1
If Ylen < 0 Then Ylen = Ylen * -1
If Xlen < Ylen Then Goto Walky


Walkx:
' Z = 0                                                      'licht einschalten
  Temp = Xlen
  Shift Temp , Right , 1
  Do
    Porta = Low(xs)
    Portc = Low(ys)
    Waitus 1
    Xs = Xs + Xa                                            ':immer einen Schritt in x-Richtung weiter
    Temp = Temp - Ylen                                      ';Schritt in Y-Richtung nötig ?
    If Temp <= 0 Then                                      ';wenn <=0 dann ja
      Temp = Temp + Xlen                                    ';
      Ys = Ys + Ya                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xs) = Low(xe)                            ';Wiederholen bis Ende der Linie
Goto Endofsub

Walky:
' Z = 0
  Temp = Ylen
  Shift Temp , Right , 1
  Do
    Porta = Low(xs)
    Portc = Low(ys)
    Waitus 1
    Ys = Ys + Ya
    Temp = Temp - Xlen
    If Temp < 0 Then
      Temp = Temp + Ylen
      Xs = Xs + Xa
    End If
  Loop Until Low(ys) = Low(ye)

Endofsub:
 'Z = 1  'und wieder aus
  End Sub


Daten:

Data 0% , 0% , 200% , 0%
Data 200% , 0% , 200% , 200%
Data 200% , 200% , 0% , 200%
Data 0% , 200% , 0% , 0%

Data 20% , 20% , 180% , 80%
Data 180% , 80% , 80% , 180%
Data 80% , 180% , 20% , 20%

Data 100% , 120% , 80% , 120%
Data 80% , 120% , 80% , 100%
Data 80% , 100% , 90% , 100%
Data 90% , 100% , 100% , 90%
Data 100% , 90% , 100% , 80%
Data 100% , 80% , 90% , 70%
Data 90% , 70% , 80% , 70%

---

Na prima, grins. Also ich werds morgen früh gleich mal testen. Bin schon ganz aufgeregt...

@jan: du machst keine pausen (wait) mehr? hatte angst das man gar nix mehr sieht... assembler ist natürlich schon geil, aber der µCOM assembler etwas undurchsichtig. (hatte mal nen grundkurs mit TASM vor jahren) Hast du 10/20k gewählt oder kleiner?

Hallo,
Ich habe 100k und 47k.
Hatte gerade nix anderes in der Menge da.
Ich bin aber erstaunt wie gut es sogar mit diesem
Primitiv-DA-Wandler geht. :-)

Ok, schauen wir morgen mal weiter...

Gruß Jan

Heeyy, mit so einem DA wandler kann man richtig was anfangen (ich kann mich dran erinnern das es mal eine software gab, die damit sound auf dem LPT1 ausgegeben hat, grins)

Also es Läuft suupi. bei mir sieht es allerdings etwas gepunkterer aus, stört mich aber nicht...
Jetzt werde ich mal versuchen die zahlen zu definieren, und eine prozedur zu machen, die offsets mit einrechnet, um die buchstaben/zahlen an beliebige stellen zu positionieren...

Kennt jemand ein vektorprogramm, in dem man evtl auf die schnelle einen zeichensatz erstellen könnte? (oder nehm ich paint?)

Hallo,
Vieleicht sollten wir das etwas vereinheitlichen,
damit nicht so viele Zahlen übergeben werden müssen.
Ich schlage vor zunächst 4 Subroutinen zu definieren:

1. Move(x,y) - bewegt den Strahl unmittelbar auf Punkt x,y ohne eine Linie zu ziehen.

2. Drawabs(x,y) -Zieht eine LInie von der aktuellen Position nach Position x,y

3. Drawrel(x,y) - Zieht eine Linie relativ zur aktuellen Position, also x,y Punkte weiter.

4. Drawobj(Adresse von obj) - Zeichnet ein Objekt auf der aktuellen Position.

Objekt könnte z.B ein Buchstabe oder ein Raumschiff sein
Das Objekt besteht aus relativen sichtbaren und unsichtbaren Linien.
z.B. so:
x,y,0 - unsichtbare Linie von akt.Position
x,y,1 - sichbare LInie
x,y,1 - noch 'ne sichtbare
x,y,9 -letzte (sichtbare) Linie - ende Objekt

Damit könnte man schon mal eine Menge anfangen.
Die Zahlen würdest du als Objekte definieren.

Nur ein Vorschlag...

Gruß Jan

Hi,

also das ganz in kleine unterprogramme aufzuteilen ist ne gute idee, weil das die arbeit hinterher schön einfach macht! Willst du die Z achse mitbenutzen, oder lassen wir sie weg, und der Strahl ist immer ungedimmt? Damit das nachbauen mit den vielen verschiedenen Prozessoren schneller geht habe ich mal den deklarationsteil geändert. X und Y sind direkte aliasse von den ports und können auch so gesetzt werden.

@jan: für vorschläge was die hardwarelösung angeht bin ich zu haben, lasse nächste woche einen prototypen fertigen und habe noch platz auf dem board.

Code:

---


X Alias Porta
Y Alias Portd
Z Alias Portf.1                                            'wenn z=0 dann ist der punkt sichtbar, wenn z=1 then ist der punkt aus

Config X = Output
Config Y = Output

---

Hallo,
Die Z-Achse ist schon irgendwie mit drin.
Move-Befehle sind mit Z=Aus.
Draw-Befehle sind mit Z=An.
Objekte haben in der letzten Zahl 0 oder 1 für Z.

Die Harwarelösung wird so schnell nicht gehen.
Ich muss das selbst erst aufbauen und testen.

Wer weiss, ob das überhaupt so geht, was ich mir da überlegt habe.
OK, ich hab 'ne Menge von dem VECTREX abgeguckt,
und da ging es ja auch...

Mit den Alias für die Ports, das finde ich gut.

Gruß Jan

MMHH oder wir ziehen das jetzt einfach so wie es ist durch....
habe jetzt erstmal ein wenig ordnung gemacht...

Die subs move und showdot sind dazugekommen, generell übergebe ich keine variablen an die subs (wenn jemand anders drüber denkt bitte mitteilen)

Code:

---

$regfile = "m128def.dat"
$crystal = 16000000

'######### Variablen Hauptprogramm
Dim Xs As Integer
Dim Xe As Integer
Dim Ys As Integer
Dim Ye As Integer


'######### Variablen Line Funktion
Dim Xlen As Integer
Dim Ylen As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Temp As Integer
Dim N As Byte


'########### Deklarationsteil für Subroutinen
Declare Sub Drawline
Declare Sub Move
Declare Sub Showdot


'########### Deklarationsteil für Ports
X Alias Porta
Y Alias Portd
Z Alias Portf.1                                            'wenn f=0 dann ist der punkt sichtbar, wenn f=1 then ist der punkt aus

Config X = Output
Config Y = Output


'################# Start Hauptprogramm
Z = 1                                                      ' dunkel


Do

Restore Daten:
For N = 1 To 14
Read Xs
Read Ys
Read Xe
Read Ye
Call Drawline

Next

Loop
End
'################# Ende Haputprogramm; beginn subroutinen



'#############################################################################################################
Sub Drawline
'Längen für x und y ausrechnen
Xlen = Xe - Xs
Ylen = Ye - Ys

'Schrittrichtung für x und Y festlegen
If Xlen >= 0 Then Xa = 1 Else Xa = 255
If Ylen >= 0 Then Ya = 1 Else Ya = 255

'wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
'  ansonsten an der Y-Achse
If Xlen < 0 Then Xlen = Xlen * -1
If Ylen < 0 Then Ylen = Ylen * -1
If Xlen < Ylen Then Goto Walky


Walkx:
  Temp = Xlen
  Shift Temp , Right , 1
  Do
    Call Move                                              'position setzen
    Call Showdot                                            'punkt zeigen
    Xs = Xs + Xa                                            ':immer einen Schritt in x-Richtung weiter
    Temp = Temp - Ylen                                      ';Schritt in Y-Richtung nötig ?
    If Temp <= 0 Then                                      ';wenn <=0 dann ja
      Temp = Temp + Xlen                                    ';
      Ys = Ys + Ya                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xs) = Low(xe)                            ';Wiederholen bis Ende der Linie
Goto Endofsub

Walky:
  Temp = Ylen
  Shift Temp , Right , 1
  Do
    Call Move                                              'position setzen
    Call Showdot                                            'punkt zeigen
    Ys = Ys + Ya
    Temp = Temp - Xlen
    If Temp < 0 Then
      Temp = Temp + Ylen
      Xs = Xs + Xa
    End If
  Loop Until Low(ys) = Low(ye)
Endofsub:
End Sub

'######################################################################################################################

Sub Move                                                    'Bewegt den punkt gedimmt zu der angegebenen position (xs,ys)
X = Low(xs)                                                'x setzen
Y = Low(ys)                                                'y setzen
End Sub

'######################################################################################################################

Sub Showdot                                                'zeigt den punkt an seiner aktuellen position an
Z = 0                                                      'licht ein
Waitus 2                                                    'kurz warten
Z = 1                                                      'lich wieder aus
End Sub

'#####################################################################################################################




Daten:

Data 0% , 0% , 200% , 0%
Data 200% , 0% , 200% , 200%
Data 200% , 200% , 0% , 200%
Data 0% , 200% , 0% , 0%

Data 20% , 20% , 180% , 80%
Data 180% , 80% , 80% , 180%
Data 80% , 180% , 20% , 20%

Data 100% , 120% , 80% , 120%
Data 80% , 120% , 80% , 100%
Data 80% , 100% , 90% , 100%
Data 90% , 100% , 100% , 90%
Data 100% , 90% , 100% , 80%
Data 100% , 80% , 90% , 70%
Data 90% , 70% , 80% , 70%

---

Die drawabs und drawrel können ja auf drawline basieren und dürften relativ schnell realisiert sein. also wenn man global mit xs und xe bzw ys und ye arbeitet ist xe und ye ja einfach auszurechnen... werde ich denke ich nachher mal machen

Zitat:

---

Die drawabs und drawrel können ja auf drawline basieren und dürften relativ schnell realisiert sein

---

Genau, ich seh schon - du hast das drauf... :-)
Wichtig ist nur: Hinterher ist xs,ys das vorherige xe,ye.

Die Variablen xs,ys,xe,ye und auch z global zu definieren,
finde ich auch gut so, das spart ne Menge Speicher und
Rechenzeit.


Wenn ich nachher nach Hause komme, werd ich mich dann
mit Drawobj befassen, damit von mir auch noch was kommt.

Gruß Jan

Habe es nun doch mit lokalen variablen gemacht, spart überlegungen und somit dass ich immer fragen guckend auf meinen monitor starre *G*

Drawabs und drawrel sind drin.

(achja ich habe die verstärkung am oszi verstellt, deshalb ist das objekt auf dem bild so dammed klein)

Code:

---

'#################################################################################################################
'#################### Achtung stack einstellungen verdoppeln!! ###################################################
'#################################################################################################################

$regfile = "m128def.dat"
$crystal = 16000000

'######### Variablen Hauptprogramm
Dim Xh1 As Integer
Dim Xh2 As Integer
Dim Yh1 As Integer
Dim Yh2 As Integer

Dim Aktx As Integer                                        'aktuelle x position
Dim Akty As Integer                                        'aktuelle y position

'######### Variablen Line Funktion
Dim Xlen As Integer
Dim Ylen As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Temp As Integer
Dim N As Byte

'########## Hilfsvariablen für drawrel
Dim Xr1 As Integer
Dim Yr1 As Integer



'########### Deklarationsteil für Subroutinen
Declare Sub Drawabs(byval X3 As Integer , Byval Y3 As Integer)      'Zeichnet vom aktuellen Punkt zu den angegebenen kordinaten eine linie
Declare Sub Drawrel(byval X2 As Integer , Byval Y2 As Integer)      'Zeichnet vom aktuellen Punkt zur relativen position eine linie

Declare Sub Drawline(byval Xs As Integer , Byval Ys As Integer , Byval Xe As Integer , Byval Ye As Integer)
Declare Sub Move(byval X1 As Integer , Byval Y1 As Integer)
Declare Sub Showdot


'########### Deklarationsteil für Ports
X Alias Porta
Y Alias Portd
Z Alias Portf.1                                            'wenn f=0 dann ist der punkt sichtbar, wenn f=1 then ist der punkt aus

Config X = Output
Config Y = Output


'################# Start Hauptprogramm
Z = 1                                                      ' dunkel


Do

Call Move(50 , 50)

Call Drawrel(0 , 100)
Call Drawrel(100 , 0)
Call Drawrel(0 , -100)
Call Drawrel( -100 , 0)                                    'wieder bei 50,50

Call Drawabs(150 , 150)
Call Drawabs(100 , 200)
Call Drawabs(50 , 150)

Call Drawrel(100 , -100)

Loop
End
'################# Ende Haputprogramm; beginn subroutinen#########################################################



Sub Drawabs(byval X3 As Integer , Byval Y3 As Integer)
Call Drawline(aktx , Akty , X3 , Y3)
End Sub
'############################################################################################################

Sub Drawrel(byval X2 As Integer , Byval Y2 As Integer)
Xr1 = Aktx + X2
Yr1 = Akty + Y2
Call Drawline(aktx , Akty , Xr1 , Yr1)
End Sub




'#############################################################################################################
Sub Drawline(byval Xs As Integer , Byval Ys As Integer , Byval Xe As Integer , Byval Ye As Integer)
'Sub Drawline
'Längen für x und y ausrechnen
Xlen = Xe - Xs
Ylen = Ye - Ys

'Schrittrichtung für x und Y festlegen
If Xlen >= 0 Then Xa = 1 Else Xa = 255
If Ylen >= 0 Then Ya = 1 Else Ya = 255

'wenn xlänge grösser ist, dann laufen wir an der X-Achse entlang
'  ansonsten an der Y-Achse
If Xlen < 0 Then Xlen = Xlen * -1
If Ylen < 0 Then Ylen = Ylen * -1
If Xlen < Ylen Then Goto Walky


Walkx:
  Temp = Xlen
  Shift Temp , Right , 1
  Do
    Call Move(xs , Ys)                                      'position setzen
    Call Showdot                                            'punkt zeigen
    Xs = Xs + Xa                                            ':immer einen Schritt in x-Richtung weiter
    Temp = Temp - Ylen                                      ';Schritt in Y-Richtung nötig ?
    If Temp <= 0 Then                                      ';wenn <=0 dann ja
      Temp = Temp + Xlen                                    ';
      Ys = Ys + Ya                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xs) = Low(xe)                            ';Wiederholen bis Ende der Linie
Goto Endofsub

Walky:
  Temp = Ylen
  Shift Temp , Right , 1
  Do
    Call Move(xs , Ys)                                      'position setzen
    Call Showdot                                            'punkt zeigen
    Ys = Ys + Ya
    Temp = Temp - Xlen
    If Temp < 0 Then
      Temp = Temp + Ylen
      Xs = Xs + Xa
    End If
  Loop Until Low(ys) = Low(ye)
Endofsub:
End Sub

'######################################################################################################################

Sub Move(byval X1 As Integer , Byval Y1 As Integer)                                                    'Bewegt den punkt gedimmt zu der angegebenen position (xs,ys)
X = Low(x1)                                                'x setzen
Y = Low(y1)                                                'y setzen
Aktx = Low(x1)                                              'x setzen
Akty = Low(y1)                                              'y setzen
End Sub

'######################################################################################################################

Sub Showdot                                                'zeigt den punkt an seiner aktuellen position an
Z = 0                                                      'licht ein
Waitus 2                                                    'kurz warten
Z = 1                                                      'lich wieder aus
End Sub

'#####################################################################################################################

---

Gute Arbeit, Sebastian !
Dein Programm läuft auch bei mir auf dem Mega32 einwandfrei.
Ich muss nur die Ports umsetzen, geht ja dank Alias sehr einfach.

Ich werde mich jetzt mal an die Objektdarstellung geben.
Es wird wohl sinnvoll sein, die Objekte auch drehbar zu machen.
Naja...Nächster Schritt... Eins nach dem Anderen...

Gruß Jan

Wie willst du (falls du das planst) den Font einbauen?
Ich bin mal gespannt ob wir nich das drehende IC zu sehen kriegen, aber dafür habe ich wohl in Mathe nicht genug aufgepasst *grins*

wenn ihr das in winavr-c proggen tut, geht es wesentlich schneller.
es ist schade um die arbeit wenn ihr es in bascom umsetzt.
euro routinen sind klug erdacht, werden aber wieder durch das langsame bascom versaubeutelt. aus eurer kategorie heraus erwarte ich eigentlich winavr-c.
mfg pebisoft

Hallo,

das Bascom nicht unbedingt langsamer ist als C wurde hier im forum glaube ich schonmal bewiesen. Leider haben hier einige (ICH übrigens auch) gar keine Erfahrung mit C und wollen es evtl auch gar nicht? (finde Pascal und Basic wesentlich angenehmer zu lesen)
Wenn dir der Beitrag hier nicht passt, werde ich ihn von Frank verschieben lassen.

Achja ich möchte eigentlich das aufkommen von diskussionen vermeiden, die nicht zum Thema gehören. Habe das schon oft beobachtet (auch bei mikrocontroller.net) das einige leute sachen posten die nicht zum eintrag gehören, was ich nicht sehr angenehm finde, und die auch besonders bei langen threads oft verwirren.

Hallo,
Also es geht weiter !
Das mit den Objekten ging viel einfacher als ich erwartet hatte.
ich musste allerdings leider das Programm ziemlich umbauen,
weil es wegen der ständigen Herumschieberei der Variablen
so gebremst wurde, das es schon zu Flimmern anfing.
Ich hab wieder auf globale Vars umgestellt. Sorry :-(

Aber dafür bewegen sich jetzt schon zwei Objekte
schön flüssig über den Oszi-Schirm. :-)

Probier es mal aus.

Z-Achse hab ich immer noch "ausgeblendet"

Gruß Jan

Code:

---



$regfile = "m32def.dat"
$crystal = 16000000


'######### Variablen Hauptprogramm
Dim H As Integer
Dim Hs As Integer
Dim Ss As Byte


'########### Variablen Vektorgrafik
Dim X As Integer
Dim Y As Integer
Dim Z As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Xe As Integer
Dim Ye As Integer
Dim Xs As Integer
Dim Ys As Integer
Dim T as integer



'########### Deklarationsteil für Subroutinen
Declare Sub Moverel
Declare Sub Moveabs
Declare Sub Drawrel                                        'Zeichnet vom aktuellen Punkt zur relativen position eine linie
Declare Sub Drawabs                                        'Zeichnet vom aktuellen Punkt zu den angegebenen kordinaten eine linie
Declare Sub Showdot
Declare Sub Drawobj

'########### Deklarationsteil für Ports
Xp Alias Porta
Yp Alias Portc
Zp Alias Portf.1                                            'wenn f=0 dann ist der punkt sichtbar, wenn f=1 then ist der punkt aus

Config Xp = Output
Config Yp = Output



'################# Start Hauptprogramm

'Zp = 1                                                      ' dunkel

H = 0
Hs = 1
Ss = 0

Do

  X = 50 : Y = 50 : Call Moveabs

  X = 100 : Y = 0 : Call Drawrel
  X = 0 : Y = 100 : Call Drawrel
  X = -100 : Y = 0 : Call Drawrel
  X = 0 : Y = -100 : Call Drawrel

  Xa = 50 : Ya = 150 : X = 100 : Y = 200 : Call Drawabs
  Xa = 150 : Ya = 150 : X = 100 : Y = 200 : Call Drawabs
  Xa = 50 : Ya = 150 : X = 150 : Y = 50 : Call Drawabs
  Xa = 50 : Ya = 50 : X = 150 : Y = 150 : Call Drawabs

  X = 0 : Y = 0 : Call Moveabs

  Restore Obj5 : X = 60 : Y = 80 : Call Drawobj
  Restore Obj5 : X = 130 : Y = 80 : Call Drawobj

  H = H + Hs
  If H = 200 Then Hs = -1
  If H = 0 Then Hs = 1
  Restore Obj5 : X = 20 : Y = H : Call Drawobj

  Ss = Ss + 1
  Restore Spaceship : X = Ss : Y = 170 : Call Drawobj

Loop

End




'################# Ende Haputprogramm; beginn subroutinen


Sub Drawabs
X = X - Xa : Y = Y - Xa
Xp = Low(xa) : Yp = Low(ya)
Call Drawrel
End Sub

'#################################
Sub Drawrel
Xe = Xa + X : Ye = Ya + Y
Xs = 1 : Ys = 1

If X < 0 Then
 Xs = -1 : X = 0 - X
End If
If Y < 0 Then
 Ys = -1 : Y = 0 - Y
End If
If X < Y Then Goto Walky

Walkx:
  T = X
  Shift T , Right , 1
  Do
    'Zp = 0
    Xp = Xa : Yp = Ya
    Xa = Xa + Xs                                            ':immer einen Schritt in x-Richtung weiter
    T = T - Y                                              ';Schritt in Y-Richtung nötig ?
    If T <= 0 Then                                          ';wenn <=0 dann ja
      T = T + X                                            ';
      Ya = Ya + Ys                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xa) = Low(xe)                            ';Wiederholen bis Ende der Linie
    'Zp = 1
  Goto Ex1

Walky:
  T = Y
  Shift T , Right , 1
  Do
  'Zp = 0
    Xp = Xa : Yp = Ya
    Ya = Ya + Ys                                            ':immer einen Schritt in x-Richtung weiter
    T = T - X                                              ';Schritt in Y-Richtung nötig ?
    If T <= 0 Then                                          ';wenn <=0 dann ja
      T = T + Y                                            ';
      Xa = Xa + Xs                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(ya) = Low(ye)                            ';Wiederholen bis Ende der Linie
    'Zp = 1
Ex1:
    End Sub
'##############################

Sub Moveabs                                                'Bewegt den punkt gedimmt zu der angegebenen position (x,y)
Xa = Low(x)                                                'Xaktuell setzen
Ya = Low(y)                                                'Xaktuell setzen
Xp = Low(x)                                                'Xport setzen
Yp = Low(y)                                                'yPort setzen
End Sub

'##############################

Sub Moverel
Xa = Xa + X : Ya = Ya + Y
End Sub

'##############################

Sub Showdot                                                'zeigt den punkt an seiner aktuellen position an
'Zp = 0                                                      'licht ein
Waitus 2                                                    'kurz warten
'Zp = 1                                                      'lichtwieder aus
End Sub

'##############################

Sub Drawobj
Call Moveabs
Do
  Read X : Read Y : Read Z
  If Z > 0 Then Call Drawrel Else Call Moverel
Loop Until Z > 1
End Sub


'######## Objektdefinitionen
'X, Y, Z
'X, Y, Z
'X und Y sind relative Positionen
'z=0 bedeutet moverel
'z=1 bedeutet sichtbare Linie
'Ende Objekt ist wenn z=3

Spaceship:
Data 15% , 8% , 1%
Data -15% , 8% , 1%
Data 6% , -8% , 1%
Data -6% , -8% , 1%
Data 4% , 8% , 0%
Data -5% , 3% , 1%
Data 5% , -3% , 1%
Data -5% , 0% , 1%
Data 5% , 0% , 1%
Data -5% , -3% , 1%
Data 5% , 3% , 3%

Obj5:
Data 5% , 0% , 1%
Data 5% , 5% , 1%
Data 0% , 5% , 1%
Data -5% , 5% , 1%
Data -5% , 0% , 1%
Data 0% , 10% , 1%
Data 10% , 0% , 3%

---

@Pebisoft:

Hallo Peter,
schön, das du dich auch dafür interessierst.

Warum machst du nicht mit, und steuerst auch
ein paar hilfreiche Ideen dazu bei,
um die Sache voranzubringen ?

Als nächstes möchten wir Objekte drehen und skalieren können.
Hast du da einen Vorschlag für, wie man das machen könnte ?

Gerne auch in C.


Gruß Jan

Hallo,
ich denke das das so passt mit Z... (spart jedes mal ein bisschen zeit) man kann ja den anschluss lassen, und nur wenn man es nicht anders vermeiden kann ausblenden.... Habe noch ein altes RFT oszi wo der vorbesitzer ganzganz schlecht mit umgegangen ist... wenn das hier schön läuft, werde ich die röhre und den trafo nehmen und mal schauen was man vielleicht stand alone anrichten kann. melde mich dann wenn die software läuft.

@jan: Wie machst du die objekte - im kopf??

hallo, ich habe ein projekt mit einem fernseher (15cm) 12volt, habe horizontale und vertikale steuerung abgeklemmt und die strahlausschaltung. bei mir auf dem arbeitstisch steht nur die bildröhre, die ich im rahmen befestigt habe. man kann auch schön die frequenz mit pwm simulieren.
habe alle anschlüsse an der röhre steckbar gemacht. steuere die beiden jetzt über einen avr an und einem verstärkungstransistor. die endausschläge des strahls brauchen ca 12 volt. kann den strahl nach rechts nach links nach oben und nach unten schicken. schalte ihn ein wenn er leuchten muss oder auch nicht. eine einfache und günstige lösung. es funktioniert genauso wie auf dem scope. eine schöne experimentielle grundlage auch für diejenigen, die sich kein scope leisten können. die kleinen fernseher mit 12v netzteil bekommt man/frau bei ebay schon für 15 euro. mfg pebisoft

Also das prog läuft soweit. Habe Z erstmal drin gelassen, weil wenn man nur das shiffchen und die 5 bewegt (mit 10ms pause) dann prennt der eine punkt doch schon ganz schön... Da das nun funktioniert, wäre ein font echt geil, meinst du einstrich font oder so jeder character mit nem rahmen zu zeichnen sieht besser aus??

Hallo phebisoft, sorry für den etwas garstigen eintrag von mir gestern. War warscheinlich überreagiert.. Mit dem TV ist echt ne geile idee, was mich interessiert ist, pfeifft der trafo in den dingern immernoch so erbärmlich, wie bei dem, den ich mir vor 10 jahren mal gekauft habe?

zur zeit arbeite ich am cmu2cam projekt und am gameboycam projekt im zusammenhang mit video-capture, übertragen der bilder seriell zum pc, daten als ton-frequenz vom avr über video/audio-funk vom robby zum pc und den ton auswerten und umwandeln in daten. objekterkennung mit einem gegrabten video-bild von einer lifeübertragung und objekterkennung an einem seriell übertragenen bild.
also zur zeit ausgelastet.
mfg pebisoft

also der 15cm fernseher ist 4 monate alt. das was du jetzt geschrieben hast mit pfeifen ist mir neu, also ich höre gar nichts, ausser der lautsprecher hatte vorher gerauscht, wo noch alles zusammengebaut war.
ich weiss auch nicht, wie hoch die strahlsteuerung bei deinem alten tragbaren fernseher ist, die technik hat sich geändert. ich habe mich auch gefreut, das ich mit 12v die strahlendanschläge erreicht habe.
mfg pebisoft

Morgen, ihr seid am Werken wie die Wilden, will euch nicht lang aufhalten

FONT: Jan hat ja schon so ein Object vordefiniert. Man könnte versuchen:
Polyline-Object, xy immer relativ zu origin und einheitsgröße. Dadurch konnte man das blank-out-bit und end-of object durchaus in die zwei Werte einpacken, würde sicher reichen
Zum aufbau dann immer scale und position angeben

Obj-n
const EOL = 128 ' end of polyline
const VIS = 128 ' visible (Z = on)

DIM array (256) as WORD ' 256 ist max-.anzahl

array(n) = makeint ( X1 . Y1 + VIS ) ' visible
incr n
array(n) = makeint ( X2 . Y2 ) ' blank
incr n
.....
array(n) = makeint ( Xn + EOL . Yn + VIS ) ' end poly, visible
incr n


Nachteil: beim suchen der variabel langen Poly's muß man durch die ganze table und mitzählen für den character-Index
Wenn man platz hat, könnt man natürlich auch eine Vector-table machen.
(mit dynamischem Aufbau für das aktuelle Frame zum refreshen)

Das drehen ist ja eigentlich kein Problem, aber eine Arbeit, müßt man schauen, ob noch Leistung übrigbleibt.

So, nun laß ich euch wieder wüten.

mmhh,

also der einfachheit halber würde ich einfach vorschlagen alle fonts was-weiss-ich 20x30 zu machen. dann kann man sie gleichmäßig positionieren, zum bleistift für ne uhr. habe heute 4 stunden heimfahrt als beifahrer vor mir, da werde ich mir mal drüber gedanken machen... ich denke millimeterpapier und los gehts

Zitat:

---

ich denke millimeterpapier und los gehts

---

Genau, so isses und 20x30 finde ich okay.
Wichtig ist noch, das jedes Zeichen die gleiche Ursprungsposition hat.
z.B. unten links. Dann muss man je nach Zeichen
evtl. erst mal 'ne leere LInie zum wirklichen Anfang des Zeichens ziehen.
z.B beim "V", beim "P" dagegen passt es schon.
Für eine Uhr brauchen wir erstmal nur die Zahlen.

UIch bastel heute Nachmittag weiter dran...

Gruß Jan

Also ich lasse jedes zeichen unten links (0,0) anfangen und gehe davon dann weiter.. Jedes Zeichen wird drei vier dots spaces dazwischen haben, sodass man direkt das nächst an position 20 oder 21 daneben bauen kann.

Das ist ein ziemliches geduldsspiel... hier erstmal die ersten. Verbesserungen werden gerne angenommen....


[code]

Obj1:
Data 0% , 16% , 0%
Data 16% , 14% , 1%
Data 0% , -30% , 3%


Obj2:
Data 0% , 26% , 0%
Data 0% , 2% , 1%
Data 4% , 2% , 1%
Data 9% , 0% , 1%
Data 5% , -4% , 1%
Data 0% , -3% , 1%
Data -18% , -23% , 1%
Data 6% , 3% , 1%
Data 8% , 0% , 1%
Data 6% , -3% , 3%



Obj3:
Data 0% , 3% , 0%
Data 4% , -3% , 1%
Data 10% , 0% , 1%
Data 4% , 3% , 1%
Data 0% , 10% , 1%
Data -3% , 3% , 1%
Data -2% , 0% , 1%
Data 2% , 0% , 0%
Data 3% , 3% , 1%
Data 0% , 8% , 1%
Data -4% , 3% , 1%
Data -10% , 0% , 1%
Data -4% , -3% , 3%

Obj4:
Data 11% , 0% , 0%
Data 0% , 17% , 1%
Data 6% , -5% , 0%
Data -17% , 0% , 1%
Data 17% , 18% , 3%

Obj5:
Data 0% , 4% , 0%
Data 4% , -4% , 1%
Data 10% , 0% , 1%
Data 5% , 5% , 1%
Data 0% , 8% , 1%
Data -5% , 5% , 1%
Data -9% , 0% , 1%
Data -5% , -6% , 1%
Data 0% , 18% , 1%
Data 17% , 0% , 3%

Obj6:
Data 0% , 10% , 0%
Data 0% , -5% , 1%
Data 4% , -4% , 1%
Data 10% , 0% , 1%
Data 5% , 5% , 1%
Data 0% , 8% , 1%
Data -5% , 5% , 1%
Data -9% , 0% , 1%
Data -5% , -6% , 1%
Data 0% , 15% , 1%
Data 4% , 4% , 1%
Data 8% , 0% , 1%
Data 5% , -4% , 3%



Obj7:
Data 0% , 30% , 0%
Data 12% , 0% , 1%
Data 0% , -30% , 1%
Data -6% , 15% , 0%
Data 12% , 0% , 3%

Obj8:
Data 4% , 0% , 0%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 6% , 1%
Data -18% , 8% , 1%
Data 0% , 6% , 1%
Data 4% , 4% , 1%
Data 10% , 0% , 1%
Data 4% , -5% , 1%
Data 0% , -6% , 1%
Data -18% , -8% , 1%
Data 0% , -6% , 1%
Data 4% , -5% , 3%


Obj9:
Data 0% , 5% , 0%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 20% , 1%
Data -4% , 5% , 1%
Data -10% , 0% , 1%
Data -4% , -5% , 1%
Data 0% , -7% , 1%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 4% , 3%

Obj0:
Data 0% , 5% , 0%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 20% , 1%
Data -4% , 5% , 1%
Data -10% , 0% , 1%
Data -4% , -5% , 1%
Data 0% , -20% , 3%

Objdp:
Data 7% , 7% , 0%
Data 4% , 0% , 1%
Data 0% , 4% , 1%
Data -4% , 0% , 1%
Data 0% , -4% , 1%
Data 0% , 12% , 0%
Data 4% , 0% , 1%
Data 0% , 4% , 1%
Data -4% , 0% , 1%
Data 0% , -4% , 3%

Hallo,

vielleicht erklärt ihr mich jetzt für bekloppt, aber man könnte doch (vorrausgesetzt man hat genug freie ports auf 10bit gehen, oder? Das würde die auflösung imens vergrößern.. (habe jetzt 6 ziffern gut lesbar in ein 1x1cm kästchen geschoben)

Zitat:

---

vielleicht erklärt ihr mich jetzt für bekloppt,

---

Nee, so schnell nicht :-)
Aber im Ernst, du hast im Prinzip bzw. in der Theorie Recht.
Aber in der Praxis macht die die begrenze Genauigkeit der
Widerstandswerte und der Ausgangsspannnugen bzw. Ströme
der Ports einen Strich durch die Rechnung.
Schon bei 10Bit Auflösung, also 10 Ports, muss die Genauigkeit
allein der Widerstände besser als 1 Promille sein,
damit das noch Sinn macht.
Ich habe schon bei 8 Stufen mit den einfachen
5%-Kohleschichtwiderständen deutlich sichbare
Unregelmässigkeiten in den Kurven.
Ich würde sagen bei 8-Bit ist mit dieser einfachen Methode Schluss.
Da brauchst du schon einen richtigen 12-Bit oder mehr DA-Wandler.

Bei der Hardware-Methode mit den Integratoren ist das besser,
da können die zwei (mit S&H nur einer) 8-Bit D/A-Wandler zusammen
65535 Richtungen eines Vektors vorgeben, und die Länge
wird durch die Integrationszeit bestimmt.
Da kann man einen viel grösseren Bereich mit den gleichen Wandlern
abdecken, weil alle Vektoren immer relativ erzeugt werden.

Gruß Jan

P.S. Muss deine Zahlen gleich mal ausprobieren...

Die zahlen sehen bei mir eher "dem zwecke entsprechend" aus, grins. wenn man einen 12bit da converter nehmen würde, wäre das doch eigentlich ne super lösung. ´mit dem integrator da blick ich nicht so ganz durch. da muss ich wohl erstmal das alte formel und schaltungsbuch konsultieren, grins

Kannst ja mal hier die software angucken, die sollte wohl besser sein als millimeterpapier.

So. kann erst wieder montag probieren. habe daheim noch kein oszi...

Hallo Sebastian,
Deine Zahlen sehen einwandfrei aus,
nur die 4, die 6 und die 7 könnten noch
etwas "Politur" vertragen.
Sonst Klasse !

Ich hab das Programm noch etwas verändert,
da waren noch einige Bugs drin.

Ich hab es jetzt so gemacht, das die Subs zwar
X und Y nutzen, aber nie verändern, so das man
die nicht immer neu setzen muss.

Mit dem Z-Eingang muss ich jetzt doch was machen,
sonst sieht man immer die Anfangs-und Endpunkte
der Linien und Objekte.

Ich bleib dran...

Gruß Jan

Code:

---



$regfile = "m32def.dat"
$crystal = 16000000


'######### Variablen Hauptprogramm
Dim H As Integer
Dim Hs As Integer
Dim Ss As Byte


'########### Variablen Vektorgrafik
Dim X As Integer
Dim Y As Integer
Dim Z As Integer
Dim Xa As Integer
Dim Ya As Integer
Dim Xe As Integer
Dim Ye As Integer
Dim Xs As Integer
Dim Ys As Integer
Dim Xl As Integer
Dim Yl As Integer
Dim Xo As Integer
Dim Yo As Integer
Dim Zo As Integer
Dim T As Integer



'########### Deklarationsteil für Subroutinen
Declare Sub Moverel
Declare Sub Moveabs
Declare Sub Drawrel                                        'Zeichnet vom aktuellen Punkt zur relativen position eine linie
Declare Sub Drawabs                                        'Zeichnet vom aktuellen Punkt zu den angegebenen kordinaten eine linie
Declare Sub Showdot
Declare Sub Drawobj

'########### Deklarationsteil für Ports
Xp Alias Porta
Yp Alias Portc
Zp Alias Portf.1                                            'wenn f=0 dann ist der punkt sichtbar, wenn f=1 then ist der punkt aus

Config Xp = Output
Config Yp = Output



'################# Start Hauptprogramm

'Zp = 1                                                      ' dunkel

H = 0
Hs = 1
Ss = 0

Do

  X = 50 : Y = 50 : Moveabs


  X = 100 : Y = 0 : Drawrel
  X = 0 : Y = 100 : Drawrel
  X = -100 : Y = 0 : Drawrel
  X = 0 : Y = -100 : Drawrel

  Xa = 50 : Ya = 150 : Xe = 100 : Ye = 200 : Drawabs
  Xa = 150 : Ya = 150 : Xe = 100 : Ye = 200 : Drawabs
  Xa = 50 : Ya = 150 : Xe = 150 : Ye = 50 : Drawabs
  Xa = 50 : Ya = 50 : Xe = 150 : Ye = 150 : Drawabs

  X = 0 : Y = 0 : Moveabs


  Restore Obj5 : X = 58 : Y = 80 : Drawobj
  Restore Obj5 : X = 128 : Y = 80 : Drawobj

  Ss = Ss + 1
  Restore Spaceship : X = Ss : Y = 170 : Drawobj

  Y = 0
  X = 0 : Restore Obj0 : Drawobj
  X = 22 : Restore Obj1 : Drawobj
  X = 44 : Restore Obj2 : Drawobj
  X = 66 : Restore Obj3 : Drawobj
  X = 88 : Restore Obj4 : Drawobj
  X = 110 : Restore Obj5 : Drawobj
  X = 132 : Restore Obj6 : Drawobj
  X = 154 : Restore Obj7 : Drawobj
  X = 176 : Restore Obj8 : Drawobj
  X = 198 : Restore Obj9 : Drawobj
  X = 220 : Restore Objdp : Drawobj




Loop

End




'################# Ende Haputprogramm; beginn subroutinen



Sub Drawabs
X = Xe - Xa : Y = Ye - Ya
Xp = Low(xa) : Yp = Low(ya)
Call Drawrel
End Sub

'#################################
Sub Drawrel
Xe = Xa + X : Ye = Ya + Y
Xl = X : Yl = Y
Xs = 1 : Ys = 1

If Xl < 0 Then
 Xs = -1 : Xl = 0 - Xl
End If
If Yl < 0 Then
 Ys = -1 : Yl = 0 - Yl
End If
If Xl < Yl Then Goto Walky

Walkx:
  T = Xl
  Shift T , Right , 1
  Do
    'Zp = 0
    Xp = Xa : Yp = Ya
    Xa = Xa + Xs                                            ':immer einen Schritt in x-Richtung weiter
    T = T - Yl                                              ';Schritt in Y-Richtung nötig ?
    If T <= 0 Then                                          ';wenn <=0 dann ja
      T = T + Xl                                            ';
      Ya = Ya + Ys                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(xa) = Low(xe)                            ';Wiederholen bis Ende der Linie
    'Zp = 1
  Goto Ex1

Walky:
  T = Yl
  Shift T , Right , 1
  Do
  'Zp = 0
    Xp = Xa : Yp = Ya
    Ya = Ya + Ys                                            ':immer einen Schritt in x-Richtung weiter
    T = T - Xl                                              ';Schritt in Y-Richtung nötig ?
    If T <= 0 Then                                          ';wenn <=0 dann ja
      T = T + Yl                                            ';
      Xa = Xa + Xs                                          ';Schritt in Y-Richtung
    End If
    Loop Until Low(ya) = Low(ye)                            ';Wiederholen bis Ende der Linie
    'Zp = 1
Ex1:
    End Sub
'##############################

Sub Moveabs                                                'Bewegt den punkt gedimmt zu der angegebenen position (x,y)
Xa = Low(x)                                                'Xaktuell setzen
Ya = Low(y)                                                'Xaktuell setzen
Xp = Low(x)                                                'Xport setzen
Yp = Low(y)                                                'yPort setzen
End Sub

'##############################

Sub Moverel
Xa = Xa + X : Ya = Ya + Y
End Sub

'##############################

Sub Showdot                                                'zeigt den punkt an seiner aktuellen position an
'Zp = 0                                                      'licht ein
Waitus 2                                                    'kurz warten
'Zp = 1                                                      'lichtwieder aus
End Sub

'##############################

Sub Drawobj
Xo = X : Yo = Y
Call Moveabs
Do
  Read X : Read Y : Read Z
  If Z > 0 Then Call Drawrel Else Call Moverel
Loop Until Z > 1
X = Xo : Y = Yo
End Sub


'######## Objektdefinitionen
'X, Y, Z
'X, Y, Z
'X und Y sind relative Positionen
'z=0 bedeutet moverel
'z=1 bedeutet sichtbare Linie
'Ende Objekt ist wenn z=3

Spaceship:
Data 15% , 8% , 1%
Data -15% , 8% , 1%
Data 6% , -8% , 1%
Data -6% , -8% , 1%
Data 4% , 8% , 0%
Data -5% , 3% , 1%
Data 5% , -3% , 1%
Data -5% , 0% , 1%
Data 5% , 0% , 1%
Data -5% , -3% , 1%
Data 5% , 3% , 3%


Obj1:
Data 0% , 16% , 0%
Data 16% , 14% , 1%
Data 0% , -30% , 3%

Obj2:
Data 0% , 26% , 0%
Data 0% , 2% , 1%
Data 4% , 2% , 1%
Data 9% , 0% , 1%
Data 5% , -4% , 1%
Data 0% , -3% , 1%
Data -18% , -23% , 1%
Data 6% , 3% , 1%
Data 8% , 0% , 1%
Data 6% , -3% , 3%

Obj3:
Data 0% , 3% , 0%
Data 4% , -3% , 1%
Data 10% , 0% , 1%
Data 4% , 3% , 1%
Data 0% , 10% , 1%
Data -3% , 3% , 1%
Data -2% , 0% , 1%
Data 2% , 0% , 0%
Data 3% , 3% , 1%
Data 0% , 8% , 1%
Data -4% , 3% , 1%
Data -10% , 0% , 1%
Data -4% , -3% , 3%

Obj4:
Data 11% , 0% , 0%
Data 0% , 17% , 1%
Data 6% , -5% , 0%
Data -17% , 0% , 1%
Data 17% , 18% , 3%

Obj5:
Data 0% , 4% , 0%
Data 4% , -4% , 1%
Data 10% , 0% , 1%
Data 5% , 5% , 1%
Data 0% , 8% , 1%
Data -5% , 5% , 1%
Data -9% , 0% , 1%
Data -5% , -6% , 1%
Data 0% , 18% , 1%
Data 17% , 0% , 3%

Obj6:
Data 0% , 10% , 0%
Data 0% , -5% , 1%
Data 4% , -4% , 1%
Data 10% , 0% , 1%
Data 5% , 5% , 1%
Data 0% , 8% , 1%
Data -5% , 5% , 1%
Data -9% , 0% , 1%
Data -5% , -6% , 1%
Data 0% , 15% , 1%
Data 4% , 4% , 1%
Data 8% , 0% , 1%
Data 5% , -4% , 3%

Obj7:
Data 0% , 30% , 0%
Data 12% , 0% , 1%
Data 0% , -30% , 1%
Data -6% , 15% , 0%
Data 12% , 0% , 3%

Obj8:
Data 4% , 0% , 0%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 6% , 1%
Data -18% , 8% , 1%
Data 0% , 6% , 1%
Data 4% , 4% , 1%
Data 10% , 0% , 1%
Data 4% , -5% , 1%
Data 0% , -6% , 1%
Data -18% , -8% , 1%
Data 0% , -6% , 1%
Data 4% , -5% , 3%

Obj9:
Data 0% , 5% , 0%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 20% , 1%
Data -4% , 5% , 1%
Data -10% , 0% , 1%
Data -4% , -5% , 1%
Data 0% , -7% , 1%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 4% , 3%

Obj0:
Data 0% , 5% , 0%
Data 4% , -5% , 1%
Data 10% , 0% , 1%
Data 4% , 5% , 1%
Data 0% , 20% , 1%
Data -4% , 5% , 1%
Data -10% , 0% , 1%
Data -4% , -5% , 1%
Data 0% , -20% , 3%

Objdp:
Data 7% , 7% , 0%
Data 4% , 0% , 1%
Data 0% , 4% , 1%
Data -4% , 0% , 1%
Data 0% , -4% , 1%
Data 0% , 12% , 0%
Data 4% , 0% , 1%
Data 0% , 4% , 1%
Data -4% , 0% , 1%
Data 0% , -4% , 3%

---