SSD1963 Grafikfunktionen

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • SSD1963 Grafikfunktionen

      Hallo

      bin mal wieder am Grafikdisplay 7" mit SSD1963 am Programmieren und versuche, suche eine Funktion zu schreiben mit dem man Dreiecke und gefüllte Dreiecke Zeichnen kann. Mir fehlt aber leider der gedankliche Ansatz wie man es machen kann.

      Ja mit drei Lienien bekomme ich auch ein Dreieck erstellt. Aber verstehe noch nicht ganz wie die Funktionen von Hkipnik und Six1 richtig funktionieren womit zB ein Kreis oder eine Box gefüllt werden.

      Bräuchte ein bischen Hilfe zum verstehen der Funktionen.


      Quellcode

      1. '-------------------------------------------------------------------------------
      2. 'LCD Fill Circle
      3. '-------------------------------------------------------------------------------
      4. Sub Lcd_fill_circle(byval X As Word , Byval Y As Word , Byval Radius As Word , Byval Color1 As Word)
      5. Local Xy_radius As Integer
      6. Local Zahly As Integer
      7. Local Zahlx As Integer
      8. Local Y1 As Integer
      9. Local X1 As Integer
      10. Local Y11 As Integer
      11. Local X11 As Integer
      12. Local Xy As Integer
      13. Local X2 As Word , Y2 As Word
      14. Xy_radius = Radius * Radius
      15. Y1 = -radius
      16. X1 = -radius
      17. For Zahly = Y1 To Radius
      18. Y11 = Zahly * Zahly
      19. For Zahlx = X1 To Radius
      20. X11 = Zahlx * Zahlx
      21. Xy = X11 + Y11
      22. If Xy <= Xy_radius Then
      23. X2 = X + Zahlx
      24. Y2 = Y + Zahly
      25. Call Lcd_set_pixel(x2 , Y2 , Color1)
      26. End If
      27. Next
      28. Next
      29. End Sub
      Alles anzeigen

      Gruß Jörg
    • Es sollte ähnlich gehen wie eine Box zu zeichnen. Ein Kreis verhält sich da anders da es einen Mittelpunkt gibt von dem aus alles berechnet werden kann.

      JOJO150272 schrieb:

      Ja mit drei Linien bekomme ich auch ein Dreieck erstellt.
      Ein schönes? Bei mir wurden spitze Winkel häßlich. Entweder eine gepunktete Linie oder zu oft setzen des selben Punktes.
      Verbinde die drei Aufrufe (diagonal_linie) zu einer Funktion.
      In deiner Funktion (Dreieck(x1,y1,x2,y2,x3.y3) könnte man die darin vorhandenen Punkte zeilenweise verbinden.
    • Hallo Jörg,
      ich sehe hauptsächlich zwei Anforderungen beim Füllen von Flächen:
      • Sicherzustellen, dass tatsächlich alle relevanten Punkte erfasst werden und
      • Möglichst keinen Punkt doppelt berechnenoder doppelt zu setzen, weil das unnötig Zeit kostet.
      Für den ersten Punkt ist es wichtig, eine einfach zu programmierende Entscheidung zu finden, welche Punkte dazugehören und welche nicht.
      Obwohl ein Kreis zunächst einmal recht kompliziert erscheint, ist diese Entscheidung sehr leicht umzusetzen.
      Die Punkte auf dem Kreis haben alle genau die Entfernung Radius zum Mittelpunkt, die Punkte innerhalb des Kreises haben die Entfernung <Radius.
      Und die Entfernung ergibt sich einfach aus den x- und y- Abständen (Pythagoras).
      Wenn man also vom Mittelpunkt ausgeht setzt man solange Punkte, bis der Radius größer ist und bricht dann ab.
      Dann geht man eine Zeile weiter und macht dort das Gleiche.
      Das braucht man übrigens nur für ein Viertel des Kreises zu machen, weil die anderen 3 identisch sind.
      Von daher geht das mit noch viel weniger Berechnungsaufwand, als in deiner geposteten Routine.

      Auch bei einer rechteckigen Box mit Kanten in x- und y- Richtung des Displays ist das einfach umzusetzen.
      Bei Dreiecken oder allgemein bei beliebigen Vielecken sieht das schon ganz anders aus. Besonders wenn du keine Seite hast, die genau in x- oder y-Richtung liegt.
      Ich würde horizontale oder vertikale Linien generieren, angefangen an einer der Linien zu diesem Punkt bis zur anderen.
      Die Berechnung wird jedenfalls wesentlich aufwändiger als die bei Kreisen, weil du immer die Anfangs- und Endpunkte auf den Kanten erzeugen musst.
      Du siehst, ich habe leider auch keinen einfachen Ansatz für Dreiecke, es sei denn, eine Linie liegt genau auf der x- bzw. y-Achse.
      Aber vielleicht hat ja noch jemand anderer eine zündende Idee.
    • Ich habe auch noch etwas weitergemacht und nun eine Sub, die ein Polygon mit beliebig vielen Kanten zeichnen kann. Es muss nicht konvex sein, aber wenn konkav, dann keine parallele Kante zur x-Achse oder eine Hinterschneidung. Das ganz Haus ohne Fenster und Tür ist dabei ein Polygon.
      Ist schon etwas getestet, aber noch nicht so intensiv, also vielleicht gibt es noch den einen oder anderen Fehler.

      BASCOM-Quellcode

      1. Dim Off_x(11) , Off_y(11) As Byte
      2. Lcd_init
      3. Lcd_clear &B00_00_00_00
      4. Off_x(0) = 10 : Off_y(0) = 30 'dach
      5. Off_x(1) = 40 : Off_y(1) = 18 'kamin
      6. Off_x(2) = 41 : Off_y(2) = 3 'kamin
      7. Off_x(3) = 49 : Off_y(3) = 3 'kamin
      8. Off_x(4) = 50 : Off_y(4) = 13 'kamin
      9. Off_x(5) = 80 : Off_y(5) = 0 'dach
      10. Off_x(6) = 150 : Off_y(6) = 30 'dach
      11. Off_x(7) = 130 : Off_y(7) = 30 'mauern
      12. Off_x(8) = 129 : Off_y(8) = 60 'mauern
      13. Off_x(9) = 31 : Off_y(9) = 60 'mauern
      14. Off_x(10) = 30 : Off_y(10) = 30 'mauern
      15. Lcd_fill_polygon Off_x() , Off_y() , 10 , 2
      16. Off_x(0) = 50 : Off_y(0) = 30
      17. Off_x(1) = 59 : Off_y(1) = 30
      18. Off_x(2) = 59 : Off_y(2) = 39
      19. Off_x(3) = 50 : Off_y(3) = 39
      20. Lcd_fill_polygon Off_x() , Off_y() , 3 , 2
      21. Off_x(0) = 61 : Off_y(0) = 30
      22. Off_x(1) = 70 : Off_y(1) = 30
      23. Off_x(2) = 70 : Off_y(2) = 39
      24. Off_x(3) = 61 : Off_y(3) = 39
      25. Lcd_fill_polygon Off_x() , Off_y() , 3 , 2
      26. Off_x(0) = 50 : Off_y(0) = 41
      27. Off_x(1) = 59 : Off_y(1) = 41
      28. Off_x(2) = 59 : Off_y(2) = 50
      29. Off_x(3) = 50 : Off_y(3) = 50
      30. Lcd_fill_polygon Off_x() , Off_y() , 3 , 2
      31. Off_x(0) = 61 : Off_y(0) = 41
      32. Off_x(1) = 70 : Off_y(1) = 41
      33. Off_x(2) = 70 : Off_y(2) = 50
      34. Off_x(3) = 61 : Off_y(3) = 50
      35. Lcd_fill_polygon Off_x() , Off_y() , 3 , 2
      36. Off_x(0) = 90 : Off_y(0) = 30
      37. Off_x(1) = 110 : Off_y(1) = 30
      38. Off_x(2) = 110 : Off_y(2) = 59
      39. Off_x(3) = 90 : Off_y(3) = 59
      40. Lcd_fill_polygon Off_x() , Off_y() , 3 , 2
      41. Off_x(0) = 70 : Off_y(0) = 10
      42. Off_x(1) = 90 : Off_y(1) = 10
      43. Off_x(2) = 90 : Off_y(2) = 22
      44. Off_x(3) = 70 : Off_y(3) = 22
      45. Lcd_fill_polygon Off_x() , Off_y() , 3 , 1
      46. Lcd_fill_circle 180 , 15 , 15 , 2
      47. Off_x(0) = 176 : Off_y(0) = 30
      48. Off_x(1) = 184 : Off_y(1) = 30
      49. Off_x(2) = 185 : Off_y(2) = 55
      50. Off_x(3) = 187 : Off_y(3) = 60
      51. Off_x(4) = 173 : Off_y(4) = 60
      52. Off_x(5) = 175 : Off_y(5) = 55
      53. Lcd_fill_polygon Off_x() , Off_y() , 5 , 1
      54. Sub Lcd_fill_polygon(array_x()as Byte , Array_y()as Byte , Byval Max_index As Byte , Byval Pixval As Byte) 'Sub zur Erzeugung von konvexen Polygonen mit beliebiger Anzahl an Punkten
      55. 'mit Einschränkungen gehen auch konkave (es dürfen in x-Richtung keine Hinterschneidungen oder parallel Kanten sein
      56. Local Temp As Byte
      57. Local Min_x As Byte
      58. Local Index_dir As Integer
      59. Local Start_index As Byte
      60. Local End_index As Byte
      61. Local Next_index As Byte
      62. Local Prev_index As Byte
      63. Local Next_gradient As Single
      64. Local Prev_gradient As Single
      65. Local Line_1_x As Single
      66. Local Line_1_y As Single
      67. Local Line_2_x As Single
      68. Local Line_2_y As Single
      69. Local L_1_x As Byte
      70. Local L_1_y As Byte
      71. Local L_2_x As Byte
      72. Local L_2_y As Byte
      73. Min_x = 255
      74. For Temp = 0 To Max_index 'finde den kleinsten x_wert
      75. 'Print Array_x(temp) ; ":" ; Array_y(temp)
      76. If Array_x(temp) < Min_x Then
      77. Start_index = Temp
      78. Min_x = Array_x(temp)
      79. End If
      80. Next Temp
      81. If Start_index < Max_index Then Next_index = Start_index + 1 Else Next_index = 0 'nächster Punkt
      82. If Start_index > 0 Then Prev_index = Start_index - 1 Else Prev_index = Max_index 'vorhergehender Punkt
      83. If Array_x(start_index) = Array_x(next_index) Then 'feststellen, ob bei min_x eine vertikale Linie zum nächsten Punkt ist
      84. Lcd_line Array_x(start_index) , Array_y(start_index) , Array_x(next_index) , Array_y(next_index) , Pixval
      85. End_index = Next_index
      86. Index_dir = -1
      87. Elseif Array_x(start_index) = Array_x(prev_index) Then 'feststellen, ob bei min_x eine vertikale Linie zum nächsten Punkt ist
      88. Lcd_line Array_x(start_index) , Array_y(start_index) , Array_x(prev_index) , Array_y(prev_index) , Pixval
      89. End_index = Prev_index
      90. Index_dir = 1
      91. Else
      92. Lcd_pset Array_x(start_index) , Array_y(start_index) , Pixval
      93. End_index = Start_index
      94. Index_dir = 0
      95. End If
      96. Next_index = Start_index
      97. Prev_index = End_index
      98. Do
      99. If Start_index = Next_index Then 'falls wir den nachfolgenden Punkt erreicht haben, den nächsten danach finden
      100. If Index_dir = 1 Then
      101. If Start_index < Max_index Then Next_index = Start_index + 1 Else Next_index = 0
      102. Else
      103. If Start_index > 0 Then Next_index = Start_index - 1 Else Next_index = Max_index
      104. End If
      105. Next_gradient = Calc_gradient(array_x(start_index) , Array_y(start_index) , Array_x(next_index) , Array_y(next_index)) 'Steigung zum nächsten Startpunkt
      106. Line_1_x = Array_x(start_index)
      107. Line_1_y = Array_y(start_index)
      108. End If
      109. If End_index = Prev_index Then 'falls wir den vorhergehenden Punkt erreicht haben, den nächsten davor finden
      110. If Index_dir = 1 Then
      111. If End_index > 0 Then Prev_index = End_index - 1 Else Prev_index = max_index
      112. Else
      113. If End_index < max_index Then Prev_index = End_index + 1 Else Prev_index = 0
      114. End If
      115. Prev_gradient = Calc_gradient(array_x(end_index) , Array_y(end_index) , Array_x(prev_index) , Array_y(prev_index)) 'Steigung zum nächsten Endpunkt finden
      116. Line_2_x = Array_x(end_index)
      117. Line_2_y = Array_y(end_index)
      118. End If
      119. Do
      120. Line_1_x = Line_1_x + 1 'startpunkt der nächsten linie
      121. Line_1_y = Line_1_y + Next_gradient
      122. Line_2_x = Line_2_x + 1 'endpunkt de nächsten Linie
      123. Line_2_y = Line_2_y + Prev_gradient
      124. L_1_x = Line_1_x
      125. L_1_y = Round(line_1_y)
      126. L_2_x = Line_2_x
      127. L_2_y = Round(line_2_y)
      128. Lcd_line L_1_x , L_1_y , L_2_x , L_2_y , Pixval
      129. 'Waitms 10
      130. Loop Until L_1_x = Array_x(next_index) Or L_2_x = Array_x(prev_index) 'abbrechen, wenn an einer Seite der nächste Punkt erreicht wurde
      131. If Index_dir = 1 Then
      132. If Prev_index > 0 Then Temp = Prev_index - 1 Else Temp = Max_index
      133. Else
      134. If Prev_index < Max_index Then Temp = Prev_index + 1 Else Temp = 0
      135. End If
      136. If Array_x(next_index) = Array_x(prev_index) And Temp = Next_index Or Next_index = Prev_index Then Exit Do 'wir sind fertig
      137. If L_1_x = Array_x(next_index) Then Start_index = Next_index
      138. If L_2_x = Array_x(prev_index) Then End_index = Prev_index
      139. Loop
      140. End Sub
      141. Function Calc_gradient(x1 , Y1 , X2 , Y2) As Single
      142. Local X As Single
      143. Local Y As Single
      144. X = X2 - X1
      145. Y = Y2 - Y1
      146. Calc_gradient = Y / X
      147. End Function
      Alles anzeigen
      Polygon.jpg
    • Hallo,

      erstmal Danke für die vielen Beiträge.

      Bin gerade am durchschauuen und versuchen die Funktionen von Franz zu verstehen.

      @Franz

      Beim übernehmen des Codes ist mir aufgefallen das der Error 263, Array index out of range auftrat. Ok bei deinen Arrays beginnst du bei 0, komisch bei mir Version 2.0.8.3 geht es mit 1 los. Welche Version verwendest Du Franz ?

      In der Sub Lcd_fill_polygon(array_x()as Byte , Array_y()as Byte , Byval Max_index As Byte , Byval Pixval As Byte) verwendest Du Pixval, für was ist dise Variable ?

      Auch fehlen mir zum probieren die Funktionen:
      - Lcd_line Array_x(start_index) , Array_y(start_index) , Array_x(next_index) , Array_y(next_index) , Pixval
      - Lcd_pset Array_x(start_index) , Array_y(start_index) , Pixval

      Könntest Du Sie mir zur Verfügung stellen?

      @Pluto25
      Ja so habe ich mir bis jetzt geholfen indem ich im Dreieck Linie für Linie gezeichnet habe, sah nicht immer so gut aus hat aber seinen Zweck so leidlich erfüllt.

      @'hkipnik'

      Sieht recht gut aus, auch dir währe ich sehr dankbar für einige Grafikfunktionen.



      Auch wäre ich für weitere Grafikfunktionen sehr dankbar, bin ständig am Versuchen diese zu verstehen und Verbesserungen an meinen Programmen durchzuführen.

      Gruß Jörg
    • BASCOM-Quellcode

      1. Declare Sub Lcd_triangle(byval X_a As Word , Byval Y_a As Word , Byval X_b As Word , Byval Y_b As Word , Byval X_c As Word , Byval Y_c As Word , Byval Color As Word )
      2. Declare Sub Lcd_fill_triangle(byval X_a As Word , Byval Y_a As Word , Byval X_b As Word , Byval Y_b As Word , Byval X_c As Word , Byval Y_c As Word , Byval Color As Word )
      3. Lcd_fill_triangle 70 , 120 , 130 , 150 , 130 , 90 , Green
      4. Lcd_fill_triangle 130 , 90 , 190 , 90 , 160 , 30 , Red
      5. Lcd_fill_triangle 190 , 150 , 250 , 120 , 190 , 90 , Yellow
      6. Lcd_fill_triangle 130 , 150 , 190 , 150 , 160 , 210 , Blue
      7. Lcd_triangle 70 , 120 , 130 , 150 , 130 , 90 , Green
      8. Lcd_triangle 130 , 90 , 190 , 90 , 160 , 30 , Red
      9. Lcd_triangle 190 , 150 , 250 , 120 , 190 , 90 , Yellow
      10. Lcd_triangle 130 , 150 , 190 , 150 , 160 , 210 , Blue
      11. '*******************************************************************************
      12. 'Draw Triangle
      13. '*******************************************************************************
      14. '
      15. ' Xa-Ya Xb-Yb
      16. ' ________ Xc-Yc
      17. ' \ / /\
      18. ' \ / / \
      19. ' \ / / \
      20. ' Xc-Yc ------
      21. ' Xa-Ya Xb-Yb
      22. '*******************************************************************************
      23. Sub Lcd_triangle(byval X_a As Word , Byval Y_a As Word , Byval X_b As Word , Byval Y_b As Word , Byval X_c As Word , Byval Y_c As Word , Byval Color As Word)
      24. Lcd_line X_a , Y_a , X_b , Y_b , 1 , Color
      25. Lcd_line X_b , Y_b , X_c , Y_c , 1 , Color
      26. Lcd_line X_c , Y_c , X_a , Y_a , 1 , Color
      27. End Sub
      28. '*******************************************************************************
      29. 'Draw Fill Triangle
      30. '*******************************************************************************
      31. '
      32. ' Xa-Ya Xb-Yb
      33. ' ________ Xc-Yc
      34. ' \ / /\
      35. ' \ / / \
      36. ' \ / / \
      37. ' Xc-Yc ------
      38. ' Xa-Ya Xb-Yb
      39. '*******************************************************************************
      40. Sub Lcd_fill_triangle(byval X_a As Word , Byval Y_a As Word , Byval X_b As Word , Byval Y_b As Word , Byval X_c As Word , Byval Y_c As Word , Byval Color As Word )
      41. Local X As Word , X_diff As Single , Y_diff As Single , Pos As Word
      42. Local X_factor As Single , Y_pos As Word , Pen_count As Word
      43. Local Zx_diff As Single , Zx_factor As Single
      44. Local Zy_diff As Single , Zy_factor As Single , Zy As Word , Xyz As Word
      45. Local Zy1_diff As Single , Zy1_factor As Single , Zy1 As Word , Xyz1 As Word
      46. Pen_count = 0
      47. Pos = 0
      48. Y_diff = Y_b - Y_a
      49. X_diff = X_b - X_a
      50. If Y_a < Y_c Then 'Yc greater Ya YC down
      51. Zx_diff = X_c - X_a 'Xdiff left side
      52. Xyz = Abs(zx_diff)
      53. Zy_diff = Y_a - Y_c 'Ydiff Ya Yc
      54. Zy_factor = Zy_diff / Zx_diff
      55. Zy_factor = Abs(zy_factor)
      56. Zx_diff = X_b - X_c
      57. Zy1_diff = Y_b - Y_c
      58. Zy1 = Abs(zy1_diff)
      59. Zy1_factor = Zy1_diff / Zx_diff
      60. Zy1_factor = Abs(zy1_factor)
      61. Xyz1 = 1
      62. X_factor = Y_diff / X_diff 'Xfactor Base line
      63. For X = X_a To X_b
      64. Y_diff = Pos * X_factor 'find Y Start Pos
      65. Y_pos = Y_diff
      66. Y_pos = Y_pos + Y_a ' + Y Base
      67. If Pen_count <= Xyz Then 'Left side
      68. Zy_diff = Pos * Zy_factor
      69. Zy = Y_pos + Zy_diff
      70. Zy1_diff = Y_a - Y_pos
      71. Zy = Zy + Zy1_diff
      72. Lcd_line X , Y_pos , X , Zy , 1 , Color 'muß auf das Programm abgestimmt werden
      73. Incr Pen_count
      74. Else 'Right side
      75. Zy_diff = Xyz1 * Zy1_factor
      76. Zy = Zy1 - Zy_diff
      77. Zy = Y_pos + Zy
      78. Zy1_diff = Y_b - Y_pos
      79. Zy = Zy + Zy1_diff
      80. Lcd_line X , Y_pos , X , Zy , 1 , Color
      81. Incr Xyz1
      82. End If
      83. Incr Pos
      84. Next X
      85. Else 'Yc smaller Ya YC up
      86. Zx_diff = X_c - X_a
      87. Xyz = Abs(zx_diff)
      88. Zy_diff = Y_c - Y_a
      89. Zy_factor = Zy_diff / Zx_diff
      90. Zy_factor = Abs(zy_factor)
      91. Zx_diff = X_b - X_c
      92. Zy1_diff = Y_b - Y_c
      93. Zy1 = Abs(zy1_diff)
      94. Zy1_factor = Zy1_diff / Zx_diff
      95. Zy1_factor = Abs(zy1_factor)
      96. Xyz1 = 1
      97. X_factor = Y_diff / X_diff
      98. For X = X_a To X_b
      99. Y_diff = Pos * X_factor 'find Y Start Pos
      100. Y_pos = Y_diff
      101. Y_pos = Y_pos + Y_a 'Base
      102. If Pen_count <= Xyz Then 'Left side
      103. Zy_diff = Pos * Zy_factor
      104. Zy = Y_pos - Zy_diff
      105. Zy1_diff = Y_a - Y_pos
      106. Zy = Zy + Zy1_diff
      107. Lcd_line X , Y_pos , X , Zy , 1 , Color
      108. Incr Pen_count
      109. Else 'Right side
      110. Zy_diff = Xyz1 * Zy1_factor
      111. Zy = Zy1 - Zy_diff
      112. Zy = Y_pos - Zy
      113. Zy1_diff = Y_b - Y_pos
      114. Zy = Zy + Zy1_diff
      115. Lcd_line X , Y_pos , X , Zy , 1 , Color
      116. Incr Xyz1
      117. End If
      118. Incr Pos
      119. Next X
      120. End If
      121. End Sub
      Alles anzeigen
    • Hallo,

      kann erst jetzt antworten da ich das ganze WE beschäftigt war.

      @'hkipnik

      Habe mit deiner Funktion versucht Dreiecke zu zeichnen in der Anordnung von 3h, 6h, 9, und 12h.
      6h und 12h funktionieren gut. Bei 3h und 9h wird nur die Umrandung gezeichnet, aber nicht das gefüllte Dreieck in Rot oder Grün. Woran liegt das ?


      Quellcode

      1. Sub MYD_xW_Ventil(byval Lcd_text As String , byval _X As Word , Byval _Y As Word , Byval _Version As Word , Byval _Zustand As Byte , Byval Fontset As Byte , Byval Forecolor As Word , Byval Backcolor As Word)
      2. If _Version.0 = 1 then
      3. ' 3Uhr
      4. X1 = _X + 20
      5. X2 = _X + 20
      6. X3 = _X + 10
      7. Y1 = _Y + 15
      8. Y2 = _Y + 5
      9. Y3 = _Y + 10
      10. If _Zustand.0 = 0 then
      11. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Red
      12. else
      13. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Yellowgreen
      14. End IF
      15. Lcd_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Beige
      16. End If
      17. If _Version.1 = 1 then
      18. ' 6Uhr
      19. X1 = _X + 5
      20. X2 = _X + 15
      21. X3 = _X + 10
      22. Y1 = _Y + 20
      23. Y2 = _Y + 20
      24. Y3 = _Y + 10
      25. If _Zustand.1 = 0 then
      26. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Red
      27. else
      28. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Yellowgreen
      29. End IF
      30. Lcd_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Beige
      31. End If
      32. If _Version.2 = 1 then
      33. ' 9Uhr
      34. X1 = _X + 0
      35. X2 = _X + 0
      36. X3 = _X + 10
      37. Y1 = _Y + 5
      38. Y2 = _Y + 15
      39. Y3 = _Y + 10
      40. If _Zustand.2 = 0 then
      41. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Red
      42. else
      43. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Yellowgreen
      44. End IF
      45. Lcd_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Beige
      46. End If
      47. If _Version.3 = 1 then
      48. ' 12Uhr
      49. X1 = _X + 5
      50. X2 = _X + 15
      51. X3 = _X + 10
      52. Y1 = _Y + 0
      53. Y2 = _Y + 0
      54. Y3 = _Y + 10
      55. If _Zustand.3 = 0 then
      56. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Red
      57. else
      58. Lcd_fill_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Yellowgreen
      59. End IF
      60. Lcd_triangle X1 , Y1 , X2 , Y2 , X3 , Y3 , Beige
      61. End If
      62. End Sub
      Alles anzeigen



      @Franz

      Versuche deine Funktionen an das SSD1963 anzupassen, aber das dauert wohl noch ein bischen da ja alle Funktionen angepast werden müssen. Habe inzwischen wenigstens das Haus in der Farbe Grün hinbekommen. Werde mal berichten wenn ich weitergekommen bin und neue Fragen habe.

      Gruß Jörg
    • Hallo Leute,

      da ich gerade mal wieder Zeit habe an meinem Display weiter zu arbeiten und ich einige weitere Werte anzeigen wollte kam ich auf die Idee ob ich es nicht als Symbole mit Touch Auswertung machen könnte.

      Ich Würde gerne ein Symbol von einer Pumpe auf dem Display mit Call plazzieren und würde dann gerne auch automatisch eine Touch Funktion für das Symbol haben. Der Code für das Pumpensymbol:

      Quellcode

      1. Sub MYD_Pumpe (byval _Text As String , byval _X As Word , Byval _Y As Word , Byval _Version As Word , Byval _Zustand As Byte , Byval _Fontset As Byte , Byval _Forecolor As Word , Byval _Backcolor As Word)
      2. Local tmp_X as Word
      3. Local tmp_Y as Word
      4. tmp_X = _X + 10
      5. tmp_Y = _Y - 30
      6. Call Lcd_circle(_X , _Y , 10 , Black )
      7. Call Lcd_text(_Text , tmp_X , tmp_Y , _Fontset , Yellow , Blue , 1 )
      8. Select Case _Zustand
      9. case 0
      10. Call Lcd_fill_triangle(_X - 5 , _Y + 8 , _X + 10 , _Y , _X - 5 , _Y - 8 , Red )
      11. case 1
      12. Call Lcd_fill_triangle(_X - 5 , _Y + 8 , _X + 10 , _Y , _X - 5 , _Y - 8 , Green )
      13. End Select
      14. End Sub
      Alles anzeigen


      Bis Jetzt nehme ich die X/Y Werte mit der Größe des Symbols und rufe dann da was auf.

      Quellcode

      1. Select Case Touchx
      2. case 100 to 119
      3. If Touchy > 99 And Touchy < 120 Then
      4. Call MYD_Pumpe ("M1" , 530 , 460 , 2 , 1 , 3 , Black , Burlywood)
      5. End If
      6. Case 680 To 760 :
      7. If Touchy > 400 And Touchy < 460 Then
      8. Ende = 1
      9. End If
      10. End Select
      Alles anzeigen
      Hat jemand mal ne Idee wie man die Touch Auswertung an die Symbole binden kann, oder es zu vereinfachen.

      Gruß Jörg
    • Liebe Bascom Unterstützer,

      ich habe mir ebenfalls mal ein 7"-SSD1963 zugelegt sowie auch ein zum Arduino2560 Board passendes Adapter-Shield. Da ich mir trotz aller Euphorie nicht ganz sicher war, ob dieses Adapter-Shield das 7"-SSD1963 korrekt versorgt, habe ich mal die Spannungen auf dem Shield nachgemessen, bevor ich das SSD1963 stecken werde.

      Dabei ist mir eine Unstimmigkeit aufgefallen, die mich nun wieder unsicher macht, ob das Shield das passende ist! Denn an dem Shield-Pin, der offenbar 3,3V zum Display schicken soll, liegen 5,0V !! an.

      Auch der AMS1117-3,3 des Shields sollte doch 3,3V liefern, es werden jedoch auf dem Oskar 4,3V angezeigt.

      Wie gesagt, alles ohne dass das SSD1963 überhaupt gesteckt ist oder wurde.

      Im Bild unten habe ich mal das Shield und die Display-Stecker nebeneinander gelegt, damit die Bezeichnungen zu sehen sind.

      Kann mir jemand meine Bedenken ausräumen, oder ist meine Interpretation nicht korrekt?

      Gruß
      Ulrich
      Dateien
    • Hallo Ulrich,

      ich kenne und habe nix von der Hardware.
      Aber wenn z.B. die 3,3V das Panel versorgen soll, müsste es auch locker mehrere Hundert mA liefern können.
      Ein 100 Ohm Widerstand z.B. nach Masse überlastet die Quelle nicht und könnte Restladung oder Geisterspannungen abbauen, wenn das Messgerät sehr hochohmig im Eingang ist.


      MfG
      port
    • Prüfe doch bitte mal ob die 5 V vom Steckerpin zum Spannungsregler U3 auf dem Display korrespondieren. Ist U3 ein Spannungsregler für 3,3 Volt, dann passt das, werden die 3,3 Volt darüber generiert. Laut Display Notiz wird 3,3 V für die Display-CPU benötigt und 5 Volt für die Hintergrundbeleuchtung. Folglich bleibt zu prüfen woher die Hintergrundbeleuchtung diese 5 V bezieht.
    • @bitlogger

      danke schon mal für den Hinweis; wenn ich das richtig verstanden habe, ist zu prüfen, woher U3 auf dem Display-Board seine Spannung erhält.
      Im Bild habe ich eingetragen, gelber Pfeil, womit dieser Pin von U3 verbunden ist.

      Wenn dieser Pin von U3 der In-Pin von U3 ist, dann wäre die Versorgung wohl korrekt, jedoch die Steckerbeschreibung falsch.
      Sehe ich das so richtig?

      Gruß
      Ulrich

      P.S. U3 hat keine Verbindung zum mit 5V bezeichnetem Stecker-Pin
      Dateien

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Ulrich ()

    • @Ulrich

      Vielleicht ist das ja nur ein weiterer Spannungsregler für den Controller-Chip? selbst (z.B. MCP1700 xxx? ), welcher wiederum die 3,3V am Eingang benötigt.
      Kann man was erkennen/ erahnen mit dem IC-Aufdruck?
      Die 3,3V - > rein müssen aber dann auf den richtigen PIN ! des Spannungsregler (U3).
      Der Pfeil wäre hier dann auf den falschen PIN bei dem Regler (als Beispiel)


      MfG
      port
      Dateien
      • Bild3.jpg

        (22,91 kB, 8 mal heruntergeladen, zuletzt: )