Konfigurationsmenü erstellen- aber wie?

    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!

    • Konfigurationsmenü erstellen- aber wie?

      Hallo,

      ich verwende dieses Display mit einem Arduino Uno:
      Display
      Da sind gleich 6 Taster mit drauf, die eine Widerstandskaskade schalten,
      die am AD Wandler des UNO angeschlossen ist.
      Mit der Taste ganz links rufe ich das Konfigurationsmemü auf,
      das klappt schon mal.
      Jetzt möchte ich mit den Tasten "hoch" und "runter" eine von
      8 Variablen auswählen und den Wert dieser Variablen mit den
      Tasten "rechts" und "links" verändern.
      Wie gehe ich da am besten ran, ich hab erst mal keine gute Idee.
      Hat Jemand so etwas schon mal programmiert?

      Gruß Ralf
    • Um das etwas zu untermauern, wie ich das meine hier der folgende Code-Schnipsel:

      BASCOM-Quellcode

      1. ' kleine Demo mit Parametern
      2. ' Funktionsweise
      3. ' Mit der Taste Select wird der 1. Parameter angezeigt.
      4. ' Mit Tasten Up / Down kann der jeweils nächste / vorherige Parameter gewählt werden.
      5. ' Das kannst du ausbauen!
      6. ' Mit Abfrage der Taste (z.B. KEY_OK) kannst du dann
      7. ' beispielsweise in einen Editier-Zustand eines Parameters wechseln.
      8. ' Das habe ich bei ST_PARAM_01 gemacht, da wird in den Zustand ST_EDIT_PARAM_01 gewechselt.
      9. ' Beim Editieren kann mit Up/Down der Wert geändert werden.
      10. ' Mit OK kehrt man wieder zur Anzeige des Parameters zurück.
      11. ' Nach diesem Schema kannst du das völlig nach eigenem Geschmack ausbauen.
      12. ' Das Programm ist aber so nicht fertig. Du sollst ja auch was lernen dabei.
      13. ' Und irgendwie muss das Programm ja auch wieder in den Normal-Betrieb gehen.
      14. ' Mit welcher Taste?
      15. ' Ach ja die Abfrage-Routine für die Tasten musst du auch noch anpassen.
      16. ' Die liefert derzeit nur KEY_NONE zurück, also keine Tasteb gedrückt.
      17. Const TRUE = 1
      18. Const FALSE = 0
      19. ' Rückgabewerte von getKey()
      20. Const KEY_NONE = 0 ' keine Taste degrückt
      21. Const KEY_SELECT = 1 ' Taste Select
      22. Const KEY_UP = 2 ' Taste Up
      23. Const KEY_DOWN = 3 ' Taste Down
      24. Const KEY_OK = 4 ' Taste OK
      25. Declare Function getKey() as Byte ' Taste ermitteln
      26. ' --------------------------------------------------------
      27. ' Routinen, Konstanten und Variablen für die Statemachine
      28. Declare Sub setState(Byval newState as Byte)
      29. Declare Function getState() as Byte
      30. Declare Function stateChanged() as Byte
      31. Const ST_IDLE = 0 ' Normalzustand
      32. Const ST_PARAM_01 = 1 ' Parameter 1 anzeigen
      33. Const ST_PARAM_02 = 2 ' Parameter 2 anzeigen
      34. Const ST_PARAM_03 = 3 ' Parameter 3 anzeigen
      35. Const ST_EDIT_PARAM_01 = 4 ' Parameter 1 editieren
      36. Dim _state as Byte ' Speichert den aktuellen Zustand
      37. Dim _stateChanged as Bit ' Speichert, ob der Zustand geändert wurde
      38. ' --------------------------------------------------------
      39. ' Programm-Variablen für Parameter
      40. Dim Parameter1 as Byte
      41. Dim Parameter2 as Word
      42. Dim Parameter3 as Integer
      43. ' etc.
      44. ' --------------------------------------------------------
      45. ' Bevor man in die Hauptschleife geht, sollte man den Zustand festlegen:
      46. Call setState(ST_IDLE)
      47. ' Hauptschleife
      48. Do
      49. Select Case getState() ' aktueller Zustand abfragen
      50. Case ST_IDLE ' Normalzustand von deinem Programm
      51. If stateChanged() = TRUE then
      52. Cls
      53. Lcd "Normalbetrieb"
      54. End If
      55. ' hier zulässige Tasten abfragen
      56. ' Mit Taste Select zum 1. Parameter wechseln
      57. If getKey() = KEY_SELECT then ' Wenn Taste Select gedrückt wurde, dann ins Menü wechseln
      58. Call setState(ST_PARAM_01) ' Neuer Zustand setzen (Parameter 1 anzeigen)
      59. End If
      60. Case ST_PARAM_01 ' Patrameter 1 anzeigen
      61. If stateChanged() = TRUE then
      62. Cls
      63. Lcd "Parameter 1"
      64. Lowerline
      65. Lcd "Wert: " ; Parameter1
      66. End If
      67. ' Hier zulässge Tasten abfragen
      68. ' Mit Down zum nächsten Parameter wechseln
      69. If getKey() = KEY_DOWN then ' wenn Taste Down betätigt wird,
      70. Call setState(ST_PARAM_02) ' zum nächsten Parameter wechseln
      71. ElseIf getKey() = KEY_OK then ' Taste OK wechselt zum Editiermode
      72. Call setState(ST_EDIT_PARAM_01) ' Parameter 1 bearbeiten
      73. End If
      74. Case ST_PARAM_02
      75. If stateChanged() = TRUE then ' Parameter 2 anzeigen
      76. Cls
      77. Lcd "Parameter 2"
      78. Lowerline
      79. Lcd "Wert: " ; Parameter2
      80. End If
      81. ' Hier zulässige Tasten abfragen
      82. ' Mit Taste Up und Down zum vorherigen/nächsten Parameter wechseln
      83. If getKey() = KEY_DOWN then ' wenn Taste Down betätigt wird,
      84. Call setState(ST_PARAM_03) ' zum nächsten Parameter wechseln
      85. ElseIf getKey() = KEY_UP then ' wenn Taste Up betätigt wird,
      86. Call setState(ST_PARAM_02) ' zum vorherigen Parameter wechseln
      87. End If
      88. Case ST_PARAM_03
      89. If stateChanged() = TRUE then ' Parameter 3 anzeigen
      90. Cls
      91. Lcd "Parameter 3"
      92. Lowerline
      93. Lcd "Wert: " ; Parameter3
      94. End If
      95. Case ST_EDIT_PARAM_01 ' Parameter1 bearbeiten
      96. If stateChanged() = TRUE then
      97. Cls
      98. Lcd "Berarbeiten P1"
      99. LowerLine
      100. Lcd "Wert: " ; Parameter1
      101. While getKey() <> KEY_NONE : Wend
      102. End If
      103. ' Taste Up/Down ändert den Wert und zeigt diesen erneut an
      104. If getKey() = KEY_UP then ' Taste Up, Wert erhöhen
      105. Incr Parameter1
      106. Call setState(ST_EDIT_PARAM_01) ' Änderung anzeigen
      107. ElseIf getKey() = KEY_DOWN then ' Taste Down, Wert verringern
      108. Decr Parameter1
      109. Call setState(ST_EDIT_PARAM_01) ' Änderung anzeigen
      110. ElseIf getKey() = KEY_OK then ' Taste OK
      111. Call setState(ST_PARAM_01) ' zurück zur Anzeige
      112. End If
      113. End Select
      114. Loop
      115. ' --------------------------------------------------------
      116. ' getKey()
      117. ' --------------------------------------------------------
      118. Function getKey() as Byte
      119. ' hier musst du den AD-Wert ermitteln und den Wert einer der Tasten zuordnen
      120. ' Den Wert gibst du dann zurück
      121. ' Das geht am besten mit Select Case,
      122. ' dann kannst du Bereiche für die AD-Werte angeben
      123. ' etas so:
      124. ' Case 100 to 250: getKEY=KEY_OK
      125. getKey = KEY_NONE ' keine Taste gedrückt
      126. End Function
      127. ' --------------------------------------------------------
      128. ' Hilfroutinen für Statemachine
      129. ' --------------------------------------------------------
      130. ' Neuer Zustand für Statemachine setzen
      131. Sub setState(Byval newState as Byte)
      132. _state = newState
      133. _stateChanged = 1
      134. End Sub
      135. ' Zustand der Statemachine abfragen
      136. Function getState() as Byte
      137. getState = _state
      138. End Function
      139. ' Prüft, ob Zustand seit letzter Abfrage geändert wurde
      140. Function stateChanged() as Byte
      141. If _stateChanged = 1 then ' Flag gesetzt?
      142. _stateChanged = 0 ' dann löschen und
      143. stateChanged = TRUE ' True zurück geben!
      144. Else ' Flag nicht gesetzt?
      145. stateChanged = FALSE ' False zurück geben
      146. End If
      147. End Function
      Alles anzeigen
      Wenn du den Code durchkaust und verstanden hast, werden dir künftige Aufgaben viel leichter von der Hand gehen.
      Ergänzend gibt es im Lexikon noch das "Statemachine Tutorial".

      Viel Erfolg!