Verlaufsdiagramm y/T

[Bonze]

also ich bin der meinung, sry aber die while schleifen sidn nicht das richtige für diesen einsatz,.
hab jetzt mal noch ne for schleife ringemacht welche mir den pointer_x hochzählt,.
jetzt werde einzelne punkte auf dem display angezeigt, schonmal etwas,.

aufruf im pogramm

Do
   Messergebnis = Getadc(5)
   Volt = Messergebnis * Adc_multi
   Print "ADC wert" ; Volt
   Dim Help As String * 10
   Help = "Temp Sim "
   Lcd_string = Str(volt)
   Lcdtext Lcd_string , 40 , 200 , 5 , Blue , White

   Neu = Volt
   Call Lcd_draw_time_dia(zwischenspeicher , Neu)
   Zwischenspeicher = Neu
loop 
end

Sub Lcd_draw_time_dia(byval Alt As Word , Neu As Word)
    'Lcd_set_pixel(byval X1 As Word , Y1 As Word , Color As Word)

   Const Start_x = 30
   Const Start_y = 30
   Const End_x = 280
   Const End_y = 310
   Dim Pointer_x As Word
   Dim Pointer_y As Word
   Dim X As Word
   Dim Y As Word
   Dim I As Integer
   'Local Alt As Word
   'Local Neu As Word
   Local Mitte As Word
   Local Richtung As Integer

   '*Koordinatenkreuz zeichnen
   Call Lcd_h_line(30 , 240 , 30 , White)
   Call Lcd_v_line(30 , 320 , 30 , White)
   '##########################
    Pointer_x = 30                                          'diagramm startet bei 30pixeln
   Pointer_y = 30                                           'diagramm startetbei 30pixeln

    Call Lcd_set_pixel(alt , Pointer_x , Yellow)
    Mitte = Neu - Alt
    Shift Mitte , Right , 1 , Signed                        'Diff = Diff / 2
    Mitte = Mitte + Alt
    Richtung = -1

    '*linie steigt oder fällt
    If Neu > Alt Then
       Richtung = 1
    End If

    Pointer_y = Start_y + 1                                 'startwert in y-richtung

    Print "alt: " ; Alt
    Print "neu: " ; Neu
    Print "mitte " ; Mitte
    Print "pointer_y " ; Pointer_y

    Pointer_y = Pointer_y + Richtung
    Pointer_y = Pointer_y + Alt

    For Pointer_x = Start_x To End_x Step 1
        While Pointer_y <> Mitte                            'pointer_y ungleich mitte |hier wird die erste Hälfte gezeichnet

             Call Lcd_set_pixel(pointer_y , Pointer_x , White)
             Print "alt-mitte  pointer_y: " ; Pointer_y ; "Pointer_x: " ; Pointer_x
             Pointer_y = Pointer_y + Richtung
        Wend

    Incr Pointer_x                                          'erhöhe pointer_x um eins

        While Pointer_y <> Neu                              'pointer_y ungleich mitte |und nun die zweite Hälfte
             Call Lcd_set_pixel(pointer_y , Pointer_x , White)
             Print "mitte_neu hälfte pointer_Y: " ; Pointer_y ; "Pointer_x: " ; Pointer_x
             Pointer_y = Pointer_y + Richtung
        Wend
    Incr Pointer_x                                          'erhöhe pointer_x um eins
       Call Lcd_set_pixel(neu , Pointer_x , White)

        Print "neuer Wert : " ; Neu ; "P_x: " ; Pointer_x
    Next
End Sub

 

[HinterBlauenAugen]

Hallo Bonze,
du machst hier aber etwas anderes als vorher besprochen. Wenn du eine Linie von einem beliebigen Anfangspunkt zu einem beliebigen Endpunkt laufen lassen willst, bleibt dir nichts anderes übrig, als einen entsprechenden Algorithmus zu benutzen.
Wir sprachen aber davon, nur zwei benachbarten Messwerte miteinander zu verbinden. Die stehen in den Spalten x und x+1. Nur dann kannst du meine Art verwenden.

ADC wert6.0
alt: 0
neu: 6
mitte 3
1hälfte i: 1P_x: 30
1hälfte i: 2P_x: 30
2hälfte i: 3P_x: 31
2hälfte i: 4P_x: 31
2hälfte i: 5P_x: 31
neu: 6P_x: 31

Dass sind exakt die Werte, die ich erwartet hätte.

HBA

 

[Bonze]

ok, werds dann doch ein bisschen anders machen, werd dann irgendwie versuchen einen algorythmus zu verwenden , der mir die werte fortlaufend schreibtmit scrollen,.

wobei dann die frage aufkommen würde, wie ich am besten die messwerte fortlaufend in das array schreibe, schreiben und lesen is ja kein problem, nur "weiterschieben",...

 

[HinterBlauenAugen]

ok, werds dann doch ein bisschen anders machen, werd dann irgendwie versuchen einen algorythmus zu verwenden , der mir die werte fortlaufend schreibtmit scrollen,.

Das scrollen hat doch zunächst mal nichts mit der Art zu tun, wie du die Punkte berechnest.
Ich verstehe noch nicht, was an der Art oben nicht funktioniert. Die Print Ausgabe ist korrekt, wieso kommen dann irgendwelche Punkte auf dem Display? Versuche doch mal zu bestimmen, wo die Punkte landen. Und zeige dann noch einmal deinen Code, der nur ein Wertepaar Alt, Neu ausgeben sollte.

wobei dann die frage aufkommen würde, wie ich am besten die messwerte fortlaufend in das array schreibe, schreiben und lesen is ja kein problem, nur "weiterschieben",...

Auf keinen Fall solltest du die Werte im Array verschieben. Wenn du alle 5min einen Wert abspeicherst und das über 24h, dann sind das 288 Werte (passt gerade noch auf dein LCD). Wenn du die verschiebst dauert das ewig.
Du kannst das ganz leicht über einen Zeiger machen, der dir die aktuelle Schreibposition im Array speichert. Du willst dann immer den ältesten der 288 Werte überschreiben und dieser soll dann ganz rechts dargestellt werden. Wenn du z.B. an die Position 100 im Array gerade geschrieben hast, dann gibst du die Werte von 101 - 288 von links nach rechts auf deinem Display aus. Anschliessend noch die Werte von 1 - 100. Nach dem nächsten Schreiben auf die Position 101 werden dann entsprechend die Werte von 102-288 und 1 bis 101 ausgegeben. Dadurch ergibt sich der Eindruck, dass auf dem Display nach links gescrollt wird.

HBA

 

[Bonze]

hier mal ein bild direkt nach dem st5art, oben links sieht man die kleinen weissen punkte, und das 2Bild nachdem ich am Poti hochgedreht hab ,.

 

[Bonze]

so habs mal versucht mit nem array zu machen

*******************************************************************************
'Config DIA
'****************5***************************************************************
Dim Dia_i As Word                                           'zaehlvariable
Dia_i = 0
Dim Test As Word
Dim Werte(288) As Word
Dim Pointer_x As Word
Const Start_x = 30
Const End_x = Start_x + 288
Const Start_y = 30
Pointer_x = Start_x

DO
Call Lcd_draw_time_dia(test , Dia_i)  
loop
'*******************************************************************************
'*******************************************************************************
'Schreibt Y/T diagramm
'*******************************************************************************
Sub Lcd_draw_time_dia(byval Wert As Word , Dia_i As Word)
    'Lcd_set_pixel(byval X1 As Word , Y1 As Word , Color As Word)
      'array füllen
      Werte(dia_i) = Wert + Start_y
      Print "Array " ; Dia_i ; " wert " ; Werte(dia_i)

                                                  'erhöhe i um 1
      If Dia_i >= 288 Then
         Dia_i = 0
      End If

      If Pointer_x <= End_x Then
         Pointer_x = Pointer_x + 1
      Else
         Pointer_x = Start_x
      End If

      Print "pointer_x" ; Pointer_x
      Call Lcd_set_pixel(werte(dia_i) , Pointer_x , White)
      Incr Dia_i
End Sub

ich denke für die scrollfunktion sollte noch soetwas wie das hier rein ,.

dia_i stellt sozusagen mein array-zeiger dar, bzw dia_i wird bei jedem aufruf von der Sub 1 hochgezählt, und bei 288 wieder auf 0 gesetzt

die werte von 0 bis dia_i

while i<dia_icall
lcd_set_pixel werte(i).....
incr i
wend

die werte von dia_i bis 288

temp = 288-dia_i
while temp<288
lcd_set_pixel werte(temp).....
incr temp
wend

 

[Bonze]

also , ich hab nen großen durchhänger, hab schon viles ausproiert jedoh nichts funktioniert wie ich es möchte
also
es gibt

pixel_x 'pixel welches momentan beschrieben wird in x-richtung
pixel_y 'pixel welches gerade beschrieben wird in y-richtung
wert ' mein "temp" wert
pointer_array_temp ist derzähler des arrays
array_temp(288)

gehe ich richtig in der annahme das ich 2 funktionen machen muss? mit einer wirds sehr sehr schwierig,.

1.Sub write_temp_to_array(wert)
wird über nen timerinterrupt alle 5mins aufgerufen:
Sie füllt mir das Array mit temp werten

2.Sub lcd_write_dia()
zeichnet mir das Diagramm

 

[dino03]

Hi,

gehe ich richtig in der annahme das ich 2 funktionen machen muss? mit einer wirds sehr sehr schwierig,.

1.Sub write_temp_to_array(wert)
wird über nen timerinterrupt alle 5mins aufgerufen:
Sie füllt mir das Array mit temp werten

2.Sub lcd_write_dia()
zeichnet mir das Diagramm

das würde ich auch so sehen. Macht man bei nem Puffer für ne RS232 ja
auch. Eine Funktion die den Puffer mit Daten vom Interface füllt und eine
Funktion mit der man die Daten aus dem Puffer abrufen kann.

Dann hast du nen Schreibzeiger der dir mitteilt wo die aktuelle Position im
Puffer ist und du hast nen Lesezeiger der von der aktuellen Position+1 bis
zur aktuellen Position die Daten ans Display liefert. Beim Lesen wird mit
Überlauf über das Ende des Puffers (also nach dem Ende gehts vorne wieder
los) die Daten ausgelesen. Darum nennt man sowas auch Ringpuffer.

Du brauchst also einige Variablen für den Puffer die zusammenspielen ...
1. Schreibzeiger (bei jedem Schreibvorgang +1)
2. Lesezeiger (Beim Anzeigen von Schreibzeiger+1 bis Schreibzeiger)
3. Zähler (Zeiger) für deine X-Position im Diagramm (beim Anzeigen von 0 bis ganz rechts)

Schreibvorgang :
- Schreibzeiger +1
- Wenn das Ende des Puffers überschritten ist, dann auf Pufferanfang setzen
- Den Datenwert an der Position des Schreibzeigers im Puffer ablegen

Anzeigevorgang :
- X-Position auf 0 (ganz links)
- Lesezeiger auf Schreibzeiger +1
- Wenn das Ende des Puffers dabei überschritten ist dann Lesezeiger auf
Anfang des Puffers
- Datenwert lesen
- Pixel setzen
- Datenwert (X,Y) speichern
* X-Position +1
- Lesezeiger +1 (wieder mit Überprüfung auf Pufferende)
- Datenwert lesen
- Linie vom alten gespeicherten Datenwert (X,Y) zum neuen Datenwert ziehen
- Datenwert (X,Y) als neuen "alten" Wert speichern
- weiter bei * bis der Lesezeiger den Schreibzeiger erreicht hat oder das
rechte Ende des Dispays erreicht ist.

So sollte es funktionieren.

Gruß
Dino

 

[Bonze]

Temp Werte schreiben in array, das ganze wird mit nem Timer aufgerufen

Write_temp:                                                 'zählt Anzahl Timer überlauf
   If Zeit2 = 5 Then

    Zeit2 = 0
    Print "schreibe temp ins array"
    Messergebnis = Getadc(5)
    Volt = Messergebnis * Adc_multi
    Test = Messergebnis / 100
    Test = Test + 30'30 is nur debugwert im vom rand wegzukommen

    If Pointer_temp_array >= 288 Then
          Pointer_temp_array = 0
       Else
          Incr Pointer_temp_array
    End If

    Temp_array(pointer_temp_array) = Test
   Else
      Incr Zeit2
   End If
Return

ich hätte jetzt gedacht das ich schon auf nem guten weg bin, aber bekomme doch nur ne linie gezeichnet und

Sub Lcd_draw_time_dia(byval Wert As Word)
    'Lcd_set_pixel(byval X1 As Word , Y1 As Word , Color As Word)

      Local Pointer_read As Word
      Local Wert2 As Word
      Local Wert3 As Word
      'Pointer_read = 0
      'pixel_x = pos des anzuzeigenden Pixels
      'pointer_read = lesezeiger
      'pointer_temp_array = schreibzeiger
If Pixel_x < End_x Then
         Incr Pixel_x
       Else
         Pixel_x = 0
       End If
       If Pointer_read >= 288 Then
          Pointer_read = 0
       Else
          Pointer_read = Pointer_temp_array + 1             'erhöhe pointer um 1
       End If
       Call Lcd_set_pixel(Temp_array(pointer_read) ,pixel_x  , White)
      '|0----------------------x------------------288|
      '| 2.teil                     1teil


      'DEBUGAUSGABEN
      Print "pointer_read " ; Pointer_read
      Print "pixel_x" ; Pixel_x
      Print "Array Speicherplatz" ; Pointer_temp_array

End Sub

hier mal meine Debugausgabe

male pixel_x 99
lese von Array Speicherplatz 155
lese pointer_read 156
male pixel_x 100
lese von Array Speicherplatz 155
lese pointer_read 156
male pixel_x 101
lese von Array Speicherplatz 155
lese pointer_read 156
male pixel_x 102
lese von Array Speicherplatz 155
lese pointer_read 156

 

[HinterBlauenAugen]

If Pointer_temp_array >= 288 Then
Pointer_temp_array = 0

Ist dein Array 0-basiert?

Pointer_read = Pointer_temp_array + 1 'erhöhe pointer um 1

Wo ist denn die Schleife hin, die über alle Array Werte läuft? Dies gibt doch nur einen Wert aus.

HBA

 

[Bonze]

mh,

versteh nur nich wo ich da noch ne schleife hinpacken sll, bzw welchen wert ich hochzählen soll den pointer_temp_array?
oder den pointer_read?
oder soll ich pixel_x hochzählen von 0-280?
bin leicht verwirrt.

un ich dachte bei bascom sind alle Arrays 0 basiert, pointer_temp_array gibt ja den ersten wert des temp_arrays an ,.
und das ist doch null,.
das array enthält "elemente" von 0-288
?

programm sieht so aus in pseudo code
timer //ruft write_array alle 5s auf

do

sub call lcd_write_dia
//schleife welche mein array ausgibt? von 0 bis pointer_array_temp-1 , und dann von pointer_array_temp+1 bis 288 ?
//oder ist das jetzt totaler blödsinn ?

loop

write_array:
//temp auslesen und
//array von 0-288 füllen (alle 5s (statt 5mins) ein neuer eintrag)

im moment wird pro avr programmdurchgang nur 1 pixel gesetzt,.

 

[dino03]

Hi,

Temp Werte schreiben in array, das ganze wird mit nem Timer aufgerufen

Write_temp:                                                 'zählt Anzahl Timer überlauf
   If Zeit2 = 5 Then

    Zeit2 = 0
    Print "schreibe temp ins array"
    Messergebnis = Getadc(5)
    Volt = Messergebnis * Adc_multi
    Test = Messergebnis / 100
    Test = Test + 30'30 is nur debugwert im vom rand wegzukommen

    If Pointer_temp_array >= 288 Then ' <<< Dieser Test nach dem Increment
          Pointer_temp_array = 0  ' <<< und dann wenn Array-Ende auf Anfang setzen
       Else
          Incr Pointer_temp_array ' <<<<< IMMER incrementieren und danach testen
    End If

    Temp_array(pointer_temp_array) = Test
   Else
      Incr Zeit2
   End If
Return

ich hätte jetzt gedacht das ich schon auf nem guten weg bin, aber bekomme doch nur ne linie gezeichnet und

Sub Lcd_draw_time_dia(byval Wert As Word)
    'Lcd_set_pixel(byval X1 As Word , Y1 As Word , Color As Word) '<<< ???? Das wird nix ! Du brauchst ne Schleife !!

      Local Pointer_read As Word
      Local Wert2 As Word
      Local Wert3 As Word
      'Pointer_read = 0
      'pixel_x = pos des anzuzeigenden Pixels
      'pointer_read = lesezeiger
      'pointer_temp_array = schreibzeiger
If Pixel_x < End_x Then
         Incr Pixel_x
       Else
         Pixel_x = 0
       End If
       If Pointer_read >= 288 Then
          Pointer_read = 0
       Else
          Pointer_read = Pointer_temp_array + 1             'erhöhe pointer um 1
       End If
       Call Lcd_set_pixel(Temp_array(pointer_read) ,pixel_x  , White)
      '|0----------------------x------------------288|
      '| 2.teil                     1teil


      'DEBUGAUSGABEN
      Print "pointer_read " ; Pointer_read
      Print "pixel_x" ; Pixel_x
      Print "Array Speicherplatz" ; Pointer_temp_array

End Sub

Die Ausgaberoutine ist Mist (sorry). Die läuft so nicht. Du mußt sie eigentlich nur laufen lassen wenn du nen neuen Wert ins Array geschrieben hast. Dann brauchst du aber ne Schleife für den GESAMTEN Inhalt des Arrays damit
der auch aufs Display wandert. Also Display löschen und dann deinen Graph
neu aufbauen (bis zum aktuellen Wert).

Ach ja ... und mach dein Array genauso groß wie deine X-Achse. Das erspart
ne Menge rechnerei und Denkarbeit.

' Display X-Achse 0...280
' Array 0...280
x = 0
read_pointer=write_pointer+1
if read_pointer >280 then read_pointer=0
y = array(read_pointer)
last_x = x
last_y = y
do    
   incr x
   incr read_pointer
   if read_pointer >280 then read_pointer=0
   y = array(read_pointer)
   line last_x, lasty, x, y    
loop until (read_pointer = write_pointer)

ist das denn so kompliziert ...
Das ist jetzt nur nen Beispiel was ich in nem Editor "zusammengepfuscht" habe.
Das soll nur den Ablauf erläutern.

Gruß
Dino

 

[Bonze]

ne is garnich kompliziert, man sollte nur dran denken, das es noch do-loop gibt

irgendwie is aber doch noch der wurm drin habs mal angepasst,.

      x = 0
      Pointer_read = Pointer_write_array + 1
      If Pointer_read > 288 Then
         Pointer_read = 0
      Else
         Y = temp_array(pointer_read)
         Last_x = X
         Last_y = Y
      End If
      Do
         Incr X                                             'zähl x 1 hoch
         Incr Pointer_read                                  'zähl pointer_read 1 hoch
            If Pointer_read > 280 Then
               Pointer_read = 0
            End If
         Y = Temp_array(pointer_read)
         'Line Last_x , Lasty , X , Y
         Call Lcd_set_pixel(Y ,x  , White)
      Loop Until Pointer_read = Pointer_write_array

 

[dino03]

Hi,

hab jetzt meine ausgabeschleife auf

For Pointer_read = 0 To Pointer_temp_array

         Call Lcd_set_pixel(temp_array(pointer_read) , Pointer_read , White)
      Next

geändert, und sie wird nur aufgerufen wenn es einen wert in mein array schreibt,.
hab jetzt nur das problem das es auf pixel_x = 0 jeden vorkommende Y wert schreibt, und somit nach mehreren ausgegebenen werten ne weisse linie entsteht.. sehr seltsam,.

Das ist nicht seltsam. Das ist so weil wohl in deiner Ausgaberoutine immer noch
die Schleife für die KOMPLETTE Ausgabe des GESAMTEN Graphen fehlt. Du
mußt schon den X-Wert hochzählen wenn du ne komplette Kennlinie haben
willst.

Sie dir mal mein zusammengestückeltes Beispiel an. Das muß bei dir in die
"Lcd_set_pixel"-Routine rein. Dann ist das keine Set-Pixel-Routine mehr
sondern ne Graph-Zeichen-Routine.

Gruß
Dino

 

[HinterBlauenAugen]

versteh nur nich wo ich da noch ne schleife hinpacken sll, bzw welchen wert ich hochzählen soll den pointer_temp_array?

Nein. Wenn ich mich richtig erinnere ist pointer_temp_array dein Zeiger auf das zuletzt geschriebene Element.

oder den pointer_read?

Ja. Dies ist ein Zeiger den du hochzählen lässt, wenn du die 288 (?) Werte ausgeben lässt. Die Schleife dafür kannst du direkt hinter das Schreiben des neuen Wertes setzen.

un ich dachte bei bascom sind alle Arrays 0 basiert, pointer_temp_array gibt ja den ersten wert des temp_arrays an ,.
und das ist doch null,.
das array enthält "elemente" von 0-288
?

Grundsätzlich sind Arrays in Bascom 1-basiert. D.h., wenn du so definierst
Dim Temp_array(288) As Byte
dann kannst du die Elemente Temp_array(1) bis Temp_array(288) ansprechen.
Seit neuestem kannst du über
Config Base=0
diese Verhalten auch ändern. Dann gibt es die Elemente 0 bis 287.
Laut MCS gibt es damit aber wohl noch Probleme.
Du musst hier schon genau sein. Während der Laufzeit überprüft niemand, ob du nicht evtl. das Element 500 ansprichst. Dort steht dann aber eine ganz andere Variable, die dann lustig überschrieben wird.
Ich kann mich an keine Definition der Variablen erinnern, zeig die doch mal.

//schleife welche mein array ausgibt? von 0 bis pointer_array_temp-1 , und dann von pointer_array_temp+1 bis 288 ?
//oder ist das jetzt totaler blödsinn ?

Sinnvoller wäre es das Array zuerst von pointer_array_temp+1 bis 288 auszugeben und dann von 1 - pointer_array_temp.
Dies, weil in pointer_array_temp+1 der älteste Wert steht und in pointer_array_temp der neueste.
Vor der Ausgabe musst du die alten Werte natürlich erst löschen. Das kannst du über CLS machen. Dann musst du aber alle anderen Daten auf dem Display auch wieder neu generieren. Z.B. das Koordinatenkreuz, die Skalen und sonstige Sachen. Das sieht dann aufgrund der Verzögerung auch nicht wie nach links schieben aus.
Die Verschiebung wird deutlicher, wenn du nur die alten Werte löschst und dann den nächsten hinzeichnest. Dies wird aber schwieriger zu programmieren. Und da du nur alle 5 Minuten aufzeichnest auch nicht so wirklich wichtig.

HBA

 

[HinterBlauenAugen]

Ich glaube ich halte mich jetzt mal raus. Das scheint bonze nur noch mehr durcheinander zu bringen, wenn wir ihm beide unsere Ratschläge geben.

HBA

 

[dino03]

Ich glaube ich halte mich jetzt mal raus. Das scheint bonze nur noch mehr durcheinander zu bringen, wenn wir ihm beide unsere Ratschläge geben.

ne ... mach man ruhig weiter Du hast dich da schon weiter reingearbeitet.
Ich hab nur ein wenig "Senf" dazugegeben.

Irgendwie kommt er da bei seinem "Ringpuffer" ein wenig ins trudeln.
Wenn er die Tips von dir und mein "Minibeispiel" mal in Ruhe durchsieht und
mal ein wenig durch den Kopf gehen läßt sollte das doch zum laufen zu bringen
sein.

Also mach mal schön weiter. Du hast ja mit dem helfen angefangen
Jetzt mußt du es auch auslöffeln Ich zieh mich zurück

Gruß
Dino

 

[Bonze]

So, obwol ich wirklich sehr verwirrt bin, bzw ich ein bisschen durchblick bekomme, hier mal dein code, . und ein beispiel bild,. dieser code funktioniert nur weil ich immer den bildschirminhalt nach jedem pixel lösche,
und immernoch drüber nachdenke, ob das irgendwie schneller geht, denn das sieht man....

also es wird am anfang ne NuUlllinie gezeichnet, und dann ist ein scrollen von rechts nach links,.
der neue punkt wird rechts daneben gezeichnet,.

Jetzt muss ich nurnoch den Bresenheim algorythmus reinpfuschen,.
BTW bin am überlegen ob ich die Scrollfunktion drinlasse, wenn ich das Bild nicht schneller löschen kann ..-

 

[HinterBlauenAugen]

Hallo Bonze,
zeig doch mal, wie dein Programm jetzt aussieht.
Es ist mit deinen Posts etwas schwierig nachzuvollzuziehen, was du gerade machst.
Es ist klar, dass du ein CLS siehst und das der Scrolleffekt dabei verlorengeht. Dass hatte ich dir schon angekündigt.
Auf der anderen Seite erzeugst du nur alle 5 Minuten einen neuen Wert. D.h. es wird auch nur alle 5 Minuten gescrollt. Dabei ist es meiner Meinung nach ziemlich gleichgültig, ob da ein CLS kommt oder nicht. Du starrst ja nicht die ganze Zeit auf das Display, oder?
Wenn du es schöner habe willst, hatte ich dir aufgezeigt, wie dies gehen könnte. Denk noch mal drüber nach und vielleicht willst du es ja mal versuchen.

Wofür willst du den Bresenheim Algo benutzen? Der ist doch für deinen Fall viel zu aufwändig. Das ist so als wolltest du einen Algo benutzen, der dir Punkte im 3D Raum berechnen kann, obwohl deine Linie auf der XY-Ebene liegt. Wenn dein letzter Punkt z.B. bei x=30 Y=10 lag und der neue bei X=31 und Y=15 dann ist doch nur die Frage, ob für Y=11 der Punkt bei X=30 oder X=31 kommt. Das gleiche für Y=12, Y=13 und Y=14. Daher mein vereinfachtes Verfahren von ganz oben.

HBA

 

[Bonze]

mh das seh ich aber anders,
1) es gibt noch keine Sub welche Linien zeichnen kann
2) muss man die differenz zwischen altem und neuem Wert ermitteln und das vorzeichen für die y-auf oder ab Bewegung.
3)
diff = wert_alt -wert_neu
diff= round (diff)
if diff<0 then
steigung negativ
else
steigung positiv
endif

dann muss man ne schleife haben welche einem pro Y wert mehrere X werte zeichnet, irgendwo auf seite 2 oder3 hatten wir dadrüber schon gesprochen und auch ne fast lösung gehabt,.


aber ich hab mir überlegt, das scrollen werd ich lassen, sieht nich so gut aus, werd einfach von links nach rechts schreiben ,. wenn pointer_x = 320, das display 1 mal löschen und dann wieder bei 0 anfangen,.
repräsentiert dann 24h,

bekomme vielleicht noch ne linien sub, von dem der die 4 anderen subs geschrieben hat, mit der wäre es sehr viel einfacher,.

mein code sieht aktuell jetzt so aus, ich muss noch den liniencode einfügen wenn ich ihn bekomme, ansonsten muss ich den wohl selbst schreiben, allerdings hätt ichs gerne so wies vorher war, eine 0 an der stelle noch kein wert angezeigt worden ist, und dann wenn in Y richtung ein anderer (richtiger wert vorgelegen hat), diesen an dieser stelle anzeigen,. ,.

Sub Lcd_draw_time_dia()
    'Lcd_set_pixel(byval X1 As Word , Y1 As Word , Color As Word)
      'pointer_write_array = pos des letzten schreibens
      Local Pointer_read As Word                            'arry element+1
      Local Pointer_read_end As Word                        'array-element-1
      Local Y_alt As Word
      Local X_alt As Word
      'Pointer_x As Word                               'x anzeige pos auf display
      Local Diff_x As Word
      Local Diff_y As Word
      Local Temp As Word
      'Skala koordinatenkreuz
      Call Lcd_h_line(20 , 240 , 20 , White)
      Call Lcd_v_line(20 , 320 , 20 , White)
      '      pointer_write_array|pointer_read
      '|0----------------------x|x+1-----------------320|
      '|       2.teil          |          1teil      |
      If Pointer_write_array >= 320 Then
         Pointer_read = 0
         Call Lcd_clear(blue)
      Elseif Pointer_write_array = 0 Then
         Pointer_read = 0
      Else
         Pointer_read = Pointer_write_array - 1
      End If

      If Pointer_x >= 320 Then
         Pointer_x = 0
      Else
         Incr Pointer_x
      End If

      Temp = Temp_array(pointer_read) + 30
      Call Lcd_set_pixel(temp , Pointer_x , Red)
         'DEBUGAUSGABEN
            Print "lese " ; Temp_array(pointer_read) ; "von array-speicherplatz" ; Pointer_read
            Print "male pixel_x " ; Pointer_x
            Print "male WErt " ; Temp_array(pointer_read)

End Sub