update code base to Marlin 2.0.9.2

Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h

@@ -0,0 +1,171 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+/* DGUS implementation written by coldtobi in 2019 for Marlin */
+
+#include "config/DGUS_Screen.h"
+#include "config/DGUS_Control.h"
+#include "definition/DGUS_VP.h"
+
+#include "../../../inc/MarlinConfigPre.h"
+#include "../../../MarlinCore.h"
+
+#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
+#include "../../../core/debug_out.h"
+
+#define Swap16(val) ((uint16_t)(((uint16_t)(val) >> 8) |\
+                                ((uint16_t)(val) << 8)))
+
+// Low-Level access to the display.
+class DGUSDisplay {
+public:
+
+  enum DGUS_ControlType : uint8_t {
+    VARIABLE_DATA_INPUT = 0x00,
+    POPUP_WINDOW = 0x01,
+    INCREMENTAL_ADJUST = 0x02,
+    SLIDER_ADJUST = 0x03,
+    RTC_SETTINGS = 0x04,
+    RETURN_KEY_CODE = 0x05,
+    TEXT_INPUT = 0x06,
+    FIRMWARE_SETTINGS = 0x07
+  };
+
+  DGUSDisplay() = default;
+
+  static void Init();
+
+  static void Read(uint16_t addr, uint8_t size);
+  static void Write(uint16_t addr, const void* data_ptr, uint8_t size);
+
+  static void WriteString(uint16_t addr, const void* data_ptr, uint8_t size, bool left = true, bool right = false, bool use_space = true);
+  static void WriteStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left = true, bool right = false, bool use_space = true);
+
+  template<typename T>
+  static void Write(uint16_t addr, T data) {
+    Write(addr, static_cast<const void*>(&data), sizeof(T));
+  }
+
+  // Until now I did not need to actively read from the display. That's why there is no ReadVariable
+  // (I extensively use the auto upload of the display)
+
+  // Force display into another screen.
+  static void SwitchScreen(DGUS_Screen screen);
+  // Play sounds using the display speaker.
+  //   start: position at which the sound was stored on the display.
+  //   len: how many sounds to play. Sounds will play consecutively from start to start+len-1.
+  //   volume: playback volume. 0 keeps the current volume.
+  static void PlaySound(uint8_t start, uint8_t len = 1, uint8_t volume = 0);
+  // Enable/disable a specific touch control.
+  //   type: control type.
+  //   control: index of the control on the page (set during screen development).
+  static void EnableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control);
+  static void DisableControl(DGUS_Screen screen, DGUS_ControlType type, DGUS_Control control);
+
+  static uint8_t GetBrightness();
+  static uint8_t GetVolume();
+
+  // Set the display brightness/volume, ranging 0 - 100
+  static void SetBrightness(uint8_t brightness);
+  static void SetVolume(uint8_t volume);
+
+  // Periodic tasks, eg. Rx-Queue handling.
+  static void Loop();
+
+  // Helper for users of this class to estimate if an interaction would be blocking.
+  static size_t GetFreeTxBuffer();
+  static void FlushTx();
+
+  // Checks two things: Can we confirm the presence of the display and has we initiliazed it.
+  // (both boils down that the display answered to our chatting)
+  static inline bool IsInitialized() {
+    return initialized;
+  }
+
+  static uint8_t gui_version;
+  static uint8_t os_version;
+
+  template<typename T>
+  static T SwapBytes(const T value) {
+    union {
+      T val;
+      char byte[sizeof(T)];
+    } src, dst;
+
+    src.val = value;
+    LOOP_L_N(i, sizeof(T)) dst.byte[i] = src.byte[sizeof(T) - i - 1];
+    return dst.val;
+  }
+
+  template<typename T_in, typename T_out, uint8_t decimals>
+  T_out FromFixedPoint(const T_in value) {
+    return (T_out)((float)value / POW(10, decimals));
+  }
+
+  template<typename T_in, typename T_out, uint8_t decimals>
+  T_out ToFixedPoint(const T_in value) {
+    return (T_out)LROUND((float)value * POW(10, decimals));
+  }
+
+private:
+  enum dgus_header : uint8_t {
+    DGUS_HEADER1 = 0x5A,
+    DGUS_HEADER2 = 0xA5
+  };
+
+  enum dgus_command : uint8_t {
+    DGUS_WRITEVAR = 0x82,
+    DGUS_READVAR = 0x83
+  };
+
+  enum rx_datagram_state_t : uint8_t {
+    DGUS_IDLE,           //< waiting for DGUS_HEADER1.
+    DGUS_HEADER1_SEEN,   //< DGUS_HEADER1 received
+    DGUS_HEADER2_SEEN,   //< DGUS_HEADER2 received
+    DGUS_WAIT_TELEGRAM,  //< LEN received, Waiting for to receive all bytes.
+  };
+
+  enum dgus_system_addr : uint16_t {
+    DGUS_VERSION = 0x000f // OS/GUI version
+  };
+
+  static void WriteHeader(uint16_t addr, uint8_t command, uint8_t len);
+  static void ProcessRx();
+
+  static uint8_t volume;
+  static uint8_t brightness;
+
+  static rx_datagram_state_t rx_datagram_state;
+  static uint8_t rx_datagram_len;
+
+  static bool initialized;
+};
+
+template<> inline uint16_t DGUSDisplay::SwapBytes(const uint16_t value) {
+  return ((value << 8) | (value >> 8));
+}
+
+extern DGUSDisplay dgus_display;
+
+/// Helper to populate a DGUS_VP for a given VP. Return false if not found.
+extern bool DGUS_PopulateVP(const DGUS_Addr addr, DGUS_VP * const buffer);