Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>x301
Miguel Risco-Castillo
3 years ago
committed by
Scott Lahteine
parent
54416f780d
commit
6cf2cf7bd4
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,265 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include "../../../inc/MarlinConfigPre.h"
|
||||
#include "dwinui.h"
|
||||
#include "rotary_encoder.h"
|
||||
#include "../../../libs/BL24CXX.h"
|
||||
|
||||
#if ANY(HAS_HOTEND, HAS_HEATED_BED, HAS_FAN) && PREHEAT_COUNT
|
||||
#define HAS_PREHEAT 1
|
||||
#if PREHEAT_COUNT < 2
|
||||
#error "Creality DWIN requires two material preheat presets."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if ANY(AUTO_BED_LEVELING_BILINEAR, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT) && DISABLED(PROBE_MANUALLY)
|
||||
#define HAS_ONESTEP_LEVELING 1
|
||||
#endif
|
||||
|
||||
#if !HAS_BED_PROBE && ENABLED(BABYSTEPPING)
|
||||
#define JUST_BABYSTEP 1
|
||||
#endif
|
||||
|
||||
#if ANY(BABYSTEPPING, HAS_BED_PROBE, HAS_WORKSPACE_OFFSET)
|
||||
#define HAS_ZOFFSET_ITEM 1
|
||||
#endif
|
||||
|
||||
static constexpr size_t eeprom_data_size = 64;
|
||||
|
||||
enum processID : uint8_t {
|
||||
// Process ID
|
||||
MainMenu,
|
||||
Menu,
|
||||
SetInt,
|
||||
SetPInt,
|
||||
SetIntNoDraw,
|
||||
SetFloat,
|
||||
SetPFloat,
|
||||
SelectFile,
|
||||
PrintProcess,
|
||||
PrintDone,
|
||||
Info,
|
||||
|
||||
// Popup Windows
|
||||
Homing,
|
||||
Leveling,
|
||||
PauseOrStop,
|
||||
FilamentPurge,
|
||||
WaitResponse,
|
||||
Locked,
|
||||
NothingToDo,
|
||||
};
|
||||
|
||||
enum pidresult_t : uint8_t {
|
||||
PID_BAD_EXTRUDER_NUM,
|
||||
PID_TEMP_TOO_HIGH,
|
||||
PID_TUNING_TIMEOUT,
|
||||
PID_EXTR_START,
|
||||
PID_BED_START,
|
||||
PID_DONE
|
||||
};
|
||||
|
||||
// Picture ID
|
||||
#define Start_Process 0
|
||||
#define Language_English 1
|
||||
#define Language_Chinese 2
|
||||
|
||||
#define DWIN_CHINESE 123
|
||||
#define DWIN_ENGLISH 0
|
||||
|
||||
typedef struct {
|
||||
int8_t Color[3]; // Color components
|
||||
int8_t Preheat = 0; // Material Select 0: PLA, 1: ABS, 2: Custom
|
||||
AxisEnum axis = X_AXIS; // Axis Select
|
||||
int32_t MaxValue = 0; // Auxiliar max integer/scaled float value
|
||||
int32_t MinValue = 0; // Auxiliar min integer/scaled float value
|
||||
int8_t dp = 0; // Auxiliar decimal places
|
||||
int32_t Value = 0; // Auxiliar integer / scaled float value
|
||||
int16_t *P_Int = nullptr; // Auxiliar pointer to 16 bit integer variable
|
||||
float *P_Float = nullptr; // Auxiliar pointer to float variable
|
||||
void (*Apply)() = nullptr; // Auxiliar apply function
|
||||
void (*LiveUpdate)() = nullptr; // Auxiliar live update function
|
||||
} HMI_value_t;
|
||||
|
||||
typedef struct {
|
||||
uint16_t Background_Color = Def_Background_Color;
|
||||
uint16_t Cursor_color = Def_Cursor_color;
|
||||
uint16_t TitleBg_color = Def_TitleBg_color;
|
||||
uint16_t TitleTxt_color = Def_TitleTxt_color;
|
||||
uint16_t Text_Color = Def_Text_Color;
|
||||
uint16_t Selected_Color = Def_Selected_Color;
|
||||
uint16_t SplitLine_Color = Def_SplitLine_Color;
|
||||
uint16_t Highlight_Color = Def_Highlight_Color;
|
||||
uint16_t StatusBg_Color = Def_StatusBg_Color;
|
||||
uint16_t StatusTxt_Color = Def_StatusTxt_Color;
|
||||
uint16_t PopupBg_color = Def_PopupBg_color;
|
||||
uint16_t PopupTxt_Color = Def_PopupTxt_Color;
|
||||
uint16_t AlertBg_Color = Def_AlertBg_Color;
|
||||
uint16_t AlertTxt_Color = Def_AlertTxt_Color;
|
||||
uint16_t PercentTxt_Color = Def_PercentTxt_Color;
|
||||
uint16_t Barfill_Color = Def_Barfill_Color;
|
||||
uint16_t Indicator_Color = Def_Indicator_Color;
|
||||
uint16_t Coordinate_Color = Def_Coordinate_Color;
|
||||
TERN_(HAS_HOTEND, int16_t HotendPidT = PREHEAT_1_TEMP_HOTEND);
|
||||
TERN_(HAS_HOTEND, int16_t PidCycles = 10);
|
||||
#ifdef PREHEAT_1_TEMP_BED
|
||||
int16_t BedPidT = PREHEAT_1_TEMP_BED;
|
||||
#endif
|
||||
TERN_(PREVENT_COLD_EXTRUSION, int16_t ExtMinT = EXTRUDE_MINTEMP);
|
||||
} HMI_data_t;
|
||||
|
||||
typedef struct {
|
||||
uint8_t language;
|
||||
bool pause_flag:1; // printing is paused
|
||||
bool pause_action:1; // flag a pause action
|
||||
bool print_finish:1; // print was finished
|
||||
bool select_flag:1; // Popup button selected
|
||||
bool home_flag:1; // homing in course
|
||||
bool heat_flag:1; // 0: heating done 1: during heating
|
||||
bool lock_flag:1; // 0: lock called from AdvSet 1: lock called from Tune
|
||||
} HMI_flag_t;
|
||||
|
||||
extern HMI_value_t HMI_value;
|
||||
extern HMI_flag_t HMI_flag;
|
||||
extern HMI_data_t HMI_data;
|
||||
extern uint8_t checkkey;
|
||||
extern millis_t dwin_heat_time;
|
||||
|
||||
// Popup windows
|
||||
void DWIN_Popup_Confirm(uint8_t icon, const char * const msg1, const char * const msg2);
|
||||
#if HAS_HOTEND || HAS_HEATED_BED
|
||||
void DWIN_Popup_Temperature(const bool toohigh);
|
||||
#endif
|
||||
TERN_(HAS_HOTEND, void Popup_Window_ETempTooLow());
|
||||
void Popup_Window_Resume();
|
||||
|
||||
// SD Card
|
||||
void HMI_SDCardInit();
|
||||
void HMI_SDCardUpdate();
|
||||
|
||||
// Main Process
|
||||
//void Icon_print();
|
||||
//void Icon_control();
|
||||
//void Icon_leveling(bool value);
|
||||
|
||||
// Other
|
||||
void Goto_PrintProcess();
|
||||
void Goto_Main_Menu();
|
||||
void update_variable();
|
||||
void Draw_Select_Highlight(const bool sel);
|
||||
void Draw_Status_Area(const bool with_update); // Status Area
|
||||
void Draw_Main_Area(); // Redraw main area;
|
||||
void DWIN_Redraw_screen(); // Redraw all screen elements
|
||||
void HMI_StartFrame(const bool with_update); // Prepare the menu view
|
||||
void HMI_MainMenu(); // Main process screen
|
||||
void HMI_SelectFile(); // File page
|
||||
void HMI_Printing(); // Print page
|
||||
void HMI_ReturnScreen(); // Return to previous screen before popups
|
||||
void ApplyExtMinT();
|
||||
void HMI_SetLanguageCache(); // Set the languaje image cache
|
||||
|
||||
//void HMI_Leveling(); // Level the page
|
||||
//void HMI_LevBedCorners(); // Tramming menu
|
||||
//void HMI_Info(); // Information menu
|
||||
|
||||
|
||||
void HMI_Init();
|
||||
void HMI_Popup();
|
||||
void HMI_SaveProcessID(const uint8_t id);
|
||||
void HMI_AudioFeedback(const bool success=true);
|
||||
void DWIN_Startup();
|
||||
void DWIN_Update();
|
||||
void EachMomentUpdate();
|
||||
void DWIN_HandleScreen();
|
||||
void DWIN_DrawStatusLine(const uint16_t color, const uint16_t bgcolor, const char *text);
|
||||
void DWIN_StatusChanged(const char * const text);
|
||||
void DWIN_StatusChanged_P(PGM_P const text);
|
||||
void DWIN_StartHoming();
|
||||
void DWIN_CompletedHoming();
|
||||
#if HAS_MESH
|
||||
void DWIN_MeshUpdate(const int8_t xpos, const int8_t ypos, const float zval);
|
||||
#endif
|
||||
void DWIN_MeshLevelingStart();
|
||||
void DWIN_CompletedLeveling();
|
||||
void DWIN_PidTuning(pidresult_t result);
|
||||
void DWIN_Print_Started(const bool sd = false);
|
||||
void DWIN_Print_Finished();
|
||||
#if HAS_FILAMENT_SENSOR
|
||||
void DWIN_FilamentRunout(const uint8_t extruder);
|
||||
#endif
|
||||
void DWIN_Progress_Update();
|
||||
void DWIN_Print_Header(const char *text);
|
||||
void DWIN_SetColorDefaults();
|
||||
void DWIN_StoreSettings(char *buff);
|
||||
void DWIN_LoadSettings(const char *buff);
|
||||
void DWIN_SetDataDefaults();
|
||||
void DWIN_RebootScreen();
|
||||
|
||||
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
||||
void Draw_Popup_FilamentPurge();
|
||||
void DWIN_Popup_FilamentPurge();
|
||||
void HMI_FilamentPurge();
|
||||
#endif
|
||||
|
||||
// Utility and extensions
|
||||
void HMI_LockScreen();
|
||||
void DWIN_LockScreen(const bool flag = true);
|
||||
|
||||
// HMI user control functions
|
||||
void HMI_Menu();
|
||||
void HMI_SetInt();
|
||||
void HMI_SetPInt();
|
||||
void HMI_SetIntNoDraw();
|
||||
void HMI_SetFloat();
|
||||
void HMI_SetPFloat();
|
||||
|
||||
// Menu drawing functions
|
||||
void Draw_Control_Menu();
|
||||
void Draw_AdvancedSettings_Menu();
|
||||
void Draw_Prepare_Menu();
|
||||
void Draw_Move_Menu();
|
||||
void Draw_LevBedCorners_Menu();
|
||||
TERN_(HAS_HOME_OFFSET, void Draw_HomeOffset_Menu());
|
||||
TERN_(HAS_BED_PROBE, void Draw_ProbeSet_Menu());
|
||||
TERN_(HAS_FILAMENT_SENSOR, void Draw_FilSet_Menu());
|
||||
void Draw_SelectColors_Menu();
|
||||
void Draw_GetColor_Menu();
|
||||
void Draw_Tune_Menu();
|
||||
void Draw_Motion_Menu();
|
||||
TERN_(ADVANCED_PAUSE_FEATURE, void Draw_FilamentMan_Menu());
|
||||
TERN_(MESH_BED_LEVELING, void Draw_ManualMesh_Menu());
|
||||
#if HAS_HOTEND
|
||||
void Draw_Preheat1_Menu();
|
||||
void Draw_Preheat2_Menu();
|
||||
void Draw_Preheat3_Menu();
|
||||
#endif
|
||||
void Draw_Temperature_Menu();
|
||||
void Draw_MaxSpeed_Menu();
|
||||
void Draw_MaxAccel_Menu();
|
||||
TERN_(HAS_CLASSIC_JERK, void Draw_MaxJerk_Menu());
|
||||
void Draw_Steps_Menu();
|
||||
TERN_(HAS_HOTEND, void Draw_HotendPID_Menu());
|
||||
TERN_(HAS_HEATED_BED, void Draw_BedPID_Menu());
|
||||
#if EITHER(HAS_BED_PROBE, BABYSTEPPING)
|
||||
void Draw_ZOffsetWiz_Menu();
|
||||
#endif
|
||||
@ -0,0 +1,570 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
/********************************************************************************
|
||||
* @file lcd/e3v2/enhanced/dwin_lcd.cpp
|
||||
* @author LEO / Creality3D - Enhanced by Miguel A. Risco-Castillo
|
||||
* @date 2021/09/08
|
||||
* @version 2.2.1
|
||||
* @brief DWIN screen control functions
|
||||
********************************************************************************/
|
||||
|
||||
#include "../../../inc/MarlinConfigPre.h"
|
||||
|
||||
#if ENABLED(DWIN_CREALITY_LCD_ENHANCED)
|
||||
|
||||
#include "../../../inc/MarlinConfig.h"
|
||||
|
||||
#include "dwin_lcd.h"
|
||||
#include <string.h> // for memset
|
||||
|
||||
//#define DEBUG_OUT 1
|
||||
#include "../../../core/debug_out.h"
|
||||
|
||||
// Make sure DWIN_SendBuf is large enough to hold the largest string plus draw command and tail.
|
||||
// Assume the narrowest (6 pixel) font and 2-byte gb2312-encoded characters.
|
||||
uint8_t DWIN_SendBuf[11 + DWIN_DataLength] = { 0xAA };
|
||||
uint8_t DWIN_BufTail[4] = { 0xCC, 0x33, 0xC3, 0x3C };
|
||||
uint8_t databuf[26] = { 0 };
|
||||
uint8_t receivedType;
|
||||
|
||||
int recnum = 0;
|
||||
|
||||
inline void DWIN_Byte(size_t &i, const uint16_t bval) {
|
||||
DWIN_SendBuf[++i] = bval;
|
||||
}
|
||||
|
||||
inline void DWIN_Word(size_t &i, const uint16_t wval) {
|
||||
DWIN_SendBuf[++i] = wval >> 8;
|
||||
DWIN_SendBuf[++i] = wval & 0xFF;
|
||||
}
|
||||
|
||||
inline void DWIN_Long(size_t &i, const uint32_t lval) {
|
||||
DWIN_SendBuf[++i] = (lval >> 24) & 0xFF;
|
||||
DWIN_SendBuf[++i] = (lval >> 16) & 0xFF;
|
||||
DWIN_SendBuf[++i] = (lval >> 8) & 0xFF;
|
||||
DWIN_SendBuf[++i] = lval & 0xFF;
|
||||
}
|
||||
|
||||
inline void DWIN_String(size_t &i, const char * const string, uint16_t rlimit = 0xFFFF) {
|
||||
if (!string) return;
|
||||
const size_t len = _MIN(sizeof(DWIN_SendBuf) - i, _MIN(strlen(string), rlimit));
|
||||
if (len == 0) return;
|
||||
memcpy(&DWIN_SendBuf[i+1], string, len);
|
||||
i += len;
|
||||
}
|
||||
|
||||
inline void DWIN_String(size_t &i, const __FlashStringHelper * string, uint16_t rlimit = 0xFFFF) {
|
||||
if (!string) return;
|
||||
const size_t len = _MIN(sizeof(DWIN_SendBuf) - i, _MIN(rlimit, strlen_P((PGM_P)string))); // cast it to PGM_P, which is basically const char *, and measure it using the _P version of strlen.
|
||||
if (len == 0) return;
|
||||
memcpy(&DWIN_SendBuf[i+1], string, len);
|
||||
i += len;
|
||||
}
|
||||
|
||||
// Send the data in the buffer and the packet end
|
||||
inline void DWIN_Send(size_t &i) {
|
||||
++i;
|
||||
LOOP_L_N(n, i) { LCD_SERIAL.write(DWIN_SendBuf[n]); delayMicroseconds(1); }
|
||||
LOOP_L_N(n, 4) { LCD_SERIAL.write(DWIN_BufTail[n]); delayMicroseconds(1); }
|
||||
}
|
||||
|
||||
/*-------------------------------------- System variable function --------------------------------------*/
|
||||
|
||||
// Handshake (1: Success, 0: Fail)
|
||||
bool DWIN_Handshake(void) {
|
||||
#ifndef LCD_BAUDRATE
|
||||
#define LCD_BAUDRATE 115200
|
||||
#endif
|
||||
LCD_SERIAL.begin(LCD_BAUDRATE);
|
||||
const millis_t serial_connect_timeout = millis() + 1000UL;
|
||||
while (!LCD_SERIAL.connected() && PENDING(millis(), serial_connect_timeout)) { /*nada*/ }
|
||||
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x00);
|
||||
DWIN_Send(i);
|
||||
|
||||
while (LCD_SERIAL.available() > 0 && recnum < (signed)sizeof(databuf)) {
|
||||
databuf[recnum] = LCD_SERIAL.read();
|
||||
// ignore the invalid data
|
||||
if (databuf[0] != FHONE) { // prevent the program from running.
|
||||
if (recnum > 0) {
|
||||
recnum = 0;
|
||||
ZERO(databuf);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
delay(10);
|
||||
recnum++;
|
||||
}
|
||||
|
||||
return ( recnum >= 3
|
||||
&& databuf[0] == FHONE
|
||||
&& databuf[1] == '\0'
|
||||
&& databuf[2] == 'O'
|
||||
&& databuf[3] == 'K' );
|
||||
}
|
||||
|
||||
// Set screen display direction
|
||||
// dir: 0=0°, 1=90°, 2=180°, 3=270°
|
||||
void DWIN_Frame_SetDir(uint8_t dir) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x34);
|
||||
DWIN_Byte(i, 0x5A);
|
||||
DWIN_Byte(i, 0xA5);
|
||||
DWIN_Byte(i, dir);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Update display
|
||||
void DWIN_UpdateLCD(void) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x3D);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
/*---------------------------------------- Drawing functions ----------------------------------------*/
|
||||
|
||||
// Clear screen
|
||||
// color: Clear screen color
|
||||
void DWIN_Frame_Clear(const uint16_t color) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x01);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw a point
|
||||
// color: point color
|
||||
// width: point width 0x01-0x0F
|
||||
// height: point height 0x01-0x0F
|
||||
// x,y: upper left point
|
||||
void DWIN_Draw_Point(uint16_t color, uint8_t width, uint8_t height, uint16_t x, uint16_t y) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x02);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Byte(i, width);
|
||||
DWIN_Byte(i, height);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw a line
|
||||
// color: Line segment color
|
||||
// xStart/yStart: Start point
|
||||
// xEnd/yEnd: End point
|
||||
void DWIN_Draw_Line(uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x03);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, xStart);
|
||||
DWIN_Word(i, yStart);
|
||||
DWIN_Word(i, xEnd);
|
||||
DWIN_Word(i, yEnd);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw a rectangle
|
||||
// mode: 0=frame, 1=fill, 2=XOR fill
|
||||
// color: Rectangle color
|
||||
// xStart/yStart: upper left point
|
||||
// xEnd/yEnd: lower right point
|
||||
void DWIN_Draw_Rectangle(uint8_t mode, uint16_t color,
|
||||
uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x05);
|
||||
DWIN_Byte(i, mode);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, xStart);
|
||||
DWIN_Word(i, yStart);
|
||||
DWIN_Word(i, xEnd);
|
||||
DWIN_Word(i, yEnd);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Move a screen area
|
||||
// mode: 0, circle shift; 1, translation
|
||||
// dir: 0=left, 1=right, 2=up, 3=down
|
||||
// dis: Distance
|
||||
// color: Fill color
|
||||
// xStart/yStart: upper left point
|
||||
// xEnd/yEnd: bottom right point
|
||||
void DWIN_Frame_AreaMove(uint8_t mode, uint8_t dir, uint16_t dis,
|
||||
uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x09);
|
||||
DWIN_Byte(i, (mode << 7) | dir);
|
||||
DWIN_Word(i, dis);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, xStart);
|
||||
DWIN_Word(i, yStart);
|
||||
DWIN_Word(i, xEnd);
|
||||
DWIN_Word(i, yEnd);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
/*---------------------------------------- Text related functions ----------------------------------------*/
|
||||
|
||||
// Draw a string
|
||||
// widthAdjust: true=self-adjust character width; false=no adjustment
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// x/y: Upper-left coordinate of the string
|
||||
// *string: The string
|
||||
// rlimit: For draw less chars than string length use rlimit
|
||||
void DWIN_Draw_String(bool widthAdjust, bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x, uint16_t y, const char * const string, uint16_t rlimit) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x11);
|
||||
// Bit 7: widthAdjust
|
||||
// Bit 6: bShow
|
||||
// Bit 5-4: Unused (0)
|
||||
// Bit 3-0: size
|
||||
DWIN_Byte(i, (widthAdjust * 0x80) | (bShow * 0x40) | size);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, bColor);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_String(i, string, rlimit);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw a positive integer
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// zeroFill: true=zero fill; false=no zero fill
|
||||
// zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// iNum: Number of digits
|
||||
// x/y: Upper-left coordinate
|
||||
// value: Integer value
|
||||
void DWIN_Draw_IntValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x14);
|
||||
// Bit 7: bshow
|
||||
// Bit 6: 1 = signed; 0 = unsigned number;
|
||||
// Bit 5: zeroFill
|
||||
// Bit 4: zeroMode
|
||||
// Bit 3-0: size
|
||||
DWIN_Byte(i, (bShow * 0x80) | (zeroFill * 0x20) | (zeroMode * 0x10) | size);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, bColor);
|
||||
DWIN_Byte(i, iNum);
|
||||
DWIN_Byte(i, 0); // fNum
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
#if 0
|
||||
for (char count = 0; count < 8; count++) {
|
||||
DWIN_Byte(i, value);
|
||||
value >>= 8;
|
||||
if (!(value & 0xFF)) break;
|
||||
}
|
||||
#else
|
||||
// Write a big-endian 64 bit integer
|
||||
const size_t p = i + 1;
|
||||
for (char count = 8; count--;) { // 7..0
|
||||
++i;
|
||||
DWIN_SendBuf[p + count] = value;
|
||||
value >>= 8;
|
||||
}
|
||||
#endif
|
||||
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw a positive floating point number
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// zeroFill: true=zero fill; false=no zero fill
|
||||
// zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// iNum: Number of whole digits
|
||||
// fNum: Number of decimal digits
|
||||
// x/y: Upper-left point
|
||||
// value: Scaled positive float value
|
||||
void DWIN_Draw_FloatValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, long value) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x14);
|
||||
DWIN_Byte(i, (bShow * 0x80) | (zeroFill * 0x20) | (zeroMode * 0x10) | size);
|
||||
DWIN_Word(i, color);
|
||||
DWIN_Word(i, bColor);
|
||||
DWIN_Byte(i, iNum);
|
||||
DWIN_Byte(i, fNum);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Long(i, value);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
// value: positive float value
|
||||
void DWIN_Draw_FloatValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
|
||||
const long val = round(value * POW(10, fNum));
|
||||
DWIN_Draw_FloatValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, val);
|
||||
}
|
||||
|
||||
/*---------------------------------------- Picture related functions ----------------------------------------*/
|
||||
|
||||
// Display QR code
|
||||
// The size of the QR code is (46*QR_Pixel)*(46*QR_Pixel) dot matrix
|
||||
// QR_Pixel: The pixel size occupied by each point of the QR code: 0x01-0x0F (1-16)
|
||||
// (Nx, Ny): The coordinates of the upper left corner displayed by the QR code
|
||||
// str: multi-bit data
|
||||
void DWIN_Draw_QR(uint8_t QR_Pixel, uint16_t x, uint16_t y, char *string) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x21);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Byte(i, QR_Pixel);
|
||||
DWIN_String(i, string);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw JPG and cached in #0 virtual display area
|
||||
// id: Picture ID
|
||||
void DWIN_JPG_ShowAndCache(const uint8_t id) {
|
||||
size_t i = 0;
|
||||
DWIN_Word(i, 0x2200);
|
||||
DWIN_Byte(i, id);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw an Icon
|
||||
// IBD: The icon background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// libID: Icon library ID
|
||||
// picID: Icon ID
|
||||
// x/y: Upper-left point
|
||||
void DWIN_ICON_Show(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint8_t libID, uint8_t picID, uint16_t x, uint16_t y) {
|
||||
NOMORE(x, DWIN_WIDTH - 1);
|
||||
NOMORE(y, DWIN_HEIGHT - 1); // -- ozy -- srl
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x23);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Byte(i, IBD%2<<7 | BIR%2<<6 | BFI%2<<5 | libID);
|
||||
DWIN_Byte(i, picID);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Draw an Icon from SRAM
|
||||
// IBD: The icon background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// x/y: Upper-left point
|
||||
// addr: SRAM address
|
||||
void DWIN_ICON_Show(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint16_t x, uint16_t y, uint16_t addr) {
|
||||
NOMORE(x, DWIN_WIDTH - 1);
|
||||
NOMORE(y, DWIN_HEIGHT - 1); // -- ozy -- srl
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x24);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Byte(i, IBD%2<<7 | BIR%2<<6 | BFI%2<<5 | 0x00);
|
||||
DWIN_Word(i, addr);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Unzip the JPG picture to a virtual display area
|
||||
// n: Cache index
|
||||
// id: Picture ID
|
||||
void DWIN_JPG_CacheToN(uint8_t n, uint8_t id) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x25);
|
||||
DWIN_Byte(i, n);
|
||||
DWIN_Byte(i, id);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Copy area from current virtual display area to current screen
|
||||
// xStart/yStart: Upper-left of virtual area
|
||||
// xEnd/yEnd: Lower-right of virtual area
|
||||
// x/y: Screen paste point
|
||||
void DWIN_Frame_AreaCopy(uint16_t xStart, uint16_t yStart,
|
||||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t y) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x26);
|
||||
DWIN_Word(i, xStart);
|
||||
DWIN_Word(i, yStart);
|
||||
DWIN_Word(i, xEnd);
|
||||
DWIN_Word(i, yEnd);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Copy area from virtual display area to current screen
|
||||
// IBD: background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// cacheID: virtual area number
|
||||
// xStart/yStart: Upper-left of virtual area
|
||||
// xEnd/yEnd: Lower-right of virtual area
|
||||
// x/y: Screen paste point
|
||||
void DWIN_Frame_AreaCopy(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint8_t cacheID, uint16_t xStart, uint16_t yStart,
|
||||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t y) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x27);
|
||||
DWIN_Byte(i, IBD%2<<7 | BIR%2<<6 | BFI%2<<5 | cacheID);
|
||||
DWIN_Word(i, xStart);
|
||||
DWIN_Word(i, yStart);
|
||||
DWIN_Word(i, xEnd);
|
||||
DWIN_Word(i, yEnd);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Animate a series of icons
|
||||
// animID: Animation ID; 0x00-0x0F
|
||||
// animate: true on; false off;
|
||||
// libID: Icon library ID
|
||||
// picIDs: Icon starting ID
|
||||
// picIDe: Icon ending ID
|
||||
// x/y: Upper-left point
|
||||
// interval: Display time interval, unit 10mS
|
||||
void DWIN_ICON_Animation(uint8_t animID, bool animate, uint8_t libID, uint8_t picIDs, uint8_t picIDe, uint16_t x, uint16_t y, uint16_t interval) {
|
||||
NOMORE(x, DWIN_WIDTH - 1);
|
||||
NOMORE(y, DWIN_HEIGHT - 1); // -- ozy -- srl
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x28);
|
||||
DWIN_Word(i, x);
|
||||
DWIN_Word(i, y);
|
||||
// Bit 7: animation on or off
|
||||
// Bit 6: start from begin or end
|
||||
// Bit 5-4: unused (0)
|
||||
// Bit 3-0: animID
|
||||
DWIN_Byte(i, (animate * 0x80) | 0x40 | animID);
|
||||
DWIN_Byte(i, libID);
|
||||
DWIN_Byte(i, picIDs);
|
||||
DWIN_Byte(i, picIDe);
|
||||
DWIN_Byte(i, interval);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Animation Control
|
||||
// state: 16 bits, each bit is the state of an animation id
|
||||
void DWIN_ICON_AnimationControl(uint16_t state) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x29);
|
||||
DWIN_Word(i, state);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Set LCD Brightness 0x00-0xFF
|
||||
void DWIN_LCD_Brightness(const uint8_t brightness) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x30);
|
||||
DWIN_Byte(i, brightness);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
// Write buffer data to the SRAM or Flash
|
||||
// mem: 0x5A=32KB SRAM, 0xA5=16KB Flash
|
||||
// addr: start address
|
||||
// length: Bytes to write
|
||||
// data: address of the buffer with data
|
||||
void DWIN_WriteToMem(uint8_t mem, uint16_t addr, uint16_t length, uint8_t *data) {
|
||||
const uint8_t max_size = 128;
|
||||
uint16_t pending = length;
|
||||
uint16_t to_send;
|
||||
uint16_t indx;
|
||||
uint8_t block = 0;
|
||||
|
||||
while (pending > 0) {
|
||||
indx = block * max_size;
|
||||
to_send = _MIN(pending, max_size);
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x31);
|
||||
DWIN_Byte(i, mem);
|
||||
DWIN_Word(i, addr + indx); // start address of the data block
|
||||
++i;
|
||||
LOOP_L_N(j, i) { LCD_SERIAL.write(DWIN_SendBuf[j]); delayMicroseconds(1); } // Buf header
|
||||
for (uint16_t j = indx; j <= indx + to_send - 1; j++) LCD_SERIAL.write(*(data + j)); delayMicroseconds(1); // write block of data
|
||||
LOOP_L_N(j, 4) { LCD_SERIAL.write(DWIN_BufTail[j]); delayMicroseconds(1); }
|
||||
block++;
|
||||
pending -= to_send;
|
||||
}
|
||||
}
|
||||
|
||||
// Write the contents of the 32KB SRAM data memory into the designated image memory space.
|
||||
// picID: Picture memory space location, 0x00-0x0F, each space is 32Kbytes
|
||||
void DWIN_SRAMToPic(uint8_t picID) {
|
||||
size_t i = 0;
|
||||
DWIN_Byte(i, 0x33);
|
||||
DWIN_Byte(i, 0x5A);
|
||||
DWIN_Byte(i, 0xA5);
|
||||
DWIN_Byte(i, picID);
|
||||
DWIN_Send(i);
|
||||
}
|
||||
|
||||
//--------------------------Test area -------------------------
|
||||
|
||||
// void DWIN_ReadSRAM(uint16_t addr, uint8_t length, const char * const data) {
|
||||
// size_t i = 0;
|
||||
// DWIN_Byte(i, 0x32);
|
||||
// DWIN_Byte(i, 0x5A); // 0x5A Read from SRAM - 0xA5 Read from Flash
|
||||
// DWIN_Word(i, addr); // 0x0000 to 0x7FFF
|
||||
// const size_t len = _MIN(0xF0, length);
|
||||
// DWIN_Byte(i, len);
|
||||
// DWIN_Send(i);
|
||||
// }
|
||||
|
||||
/*---------------------------------------- Memory functions ----------------------------------------*/
|
||||
// The LCD has an additional 32KB SRAM and 16KB Flash
|
||||
|
||||
// Data can be written to the sram and save to one of the jpeg page files
|
||||
|
||||
// Write Data Memory
|
||||
// command 0x31
|
||||
// Type: Write memory selection; 0x5A=SRAM; 0xA5=Flash
|
||||
// Address: Write data memory address; 0x000-0x7FFF for SRAM; 0x000-0x3FFF for Flash
|
||||
// Data: data
|
||||
//
|
||||
// Flash writing returns 0xA5 0x4F 0x4B
|
||||
|
||||
// Read Data Memory
|
||||
// command 0x32
|
||||
// Type: Read memory selection; 0x5A=SRAM; 0xA5=Flash
|
||||
// Address: Read data memory address; 0x000-0x7FFF for SRAM; 0x000-0x3FFF for Flash
|
||||
// Length: leangth of data to read; 0x01-0xF0
|
||||
//
|
||||
// Response:
|
||||
// Type, Address, Length, Data
|
||||
|
||||
// Write Picture Memory
|
||||
// Write the contents of the 32KB SRAM data memory into the designated image memory space
|
||||
// Issued: 0x5A, 0xA5, PIC_ID
|
||||
// Response: 0xA5 0x4F 0x4B
|
||||
//
|
||||
// command 0x33
|
||||
// 0x5A, 0xA5
|
||||
// PicId: Picture Memory location, 0x00-0x0F
|
||||
//
|
||||
// Flash writing returns 0xA5 0x4F 0x4B
|
||||
|
||||
#endif // DWIN_CREALITY_LCD_ENHANCED
|
||||
@ -0,0 +1,285 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
/********************************************************************************
|
||||
* @file lcd/e3v2/enhanced/dwin_lcd.h
|
||||
* @author LEO / Creality3D - Enhanced by Miguel A. Risco-Castillo
|
||||
* @date 2021/08/09
|
||||
* @version 2.2.1
|
||||
* @brief DWIN screen control functions
|
||||
********************************************************************************/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define RECEIVED_NO_DATA 0x00
|
||||
#define RECEIVED_SHAKE_HAND_ACK 0x01
|
||||
|
||||
#define FHONE 0xAA
|
||||
|
||||
#define DWIN_SCROLL_UP 2
|
||||
#define DWIN_SCROLL_DOWN 3
|
||||
|
||||
#define DWIN_WIDTH 272
|
||||
#define DWIN_HEIGHT 480
|
||||
|
||||
#define DWIN_DataLength (DWIN_WIDTH / 6 * 2)
|
||||
|
||||
/*-------------------------------------- System variable function --------------------------------------*/
|
||||
|
||||
// Handshake (1: Success, 0: Fail)
|
||||
bool DWIN_Handshake(void);
|
||||
|
||||
// Set the backlight luminance
|
||||
// luminance: (0x00-0xFF)
|
||||
void DWIN_Backlight_SetLuminance(const uint8_t luminance);
|
||||
|
||||
// Set screen display direction
|
||||
// dir: 0=0°, 1=90°, 2=180°, 3=270°
|
||||
void DWIN_Frame_SetDir(uint8_t dir);
|
||||
|
||||
// Update display
|
||||
void DWIN_UpdateLCD(void);
|
||||
|
||||
/*---------------------------------------- Drawing functions ----------------------------------------*/
|
||||
|
||||
// Clear screen
|
||||
// color: Clear screen color
|
||||
void DWIN_Frame_Clear(const uint16_t color);
|
||||
|
||||
// Draw a point
|
||||
// color: point color
|
||||
// width: point width 0x01-0x0F
|
||||
// height: point height 0x01-0x0F
|
||||
// x,y: upper left point
|
||||
void DWIN_Draw_Point(uint16_t color, uint8_t width, uint8_t height, uint16_t x, uint16_t y);
|
||||
|
||||
// Draw a line
|
||||
// color: Line segment color
|
||||
// xStart/yStart: Start point
|
||||
// xEnd/yEnd: End point
|
||||
void DWIN_Draw_Line(uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd);
|
||||
|
||||
// Draw a Horizontal line
|
||||
// color: Line segment color
|
||||
// xStart/yStart: Start point
|
||||
// xLength: Line Length
|
||||
inline void DWIN_Draw_HLine(uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xLength) {
|
||||
DWIN_Draw_Line(color, xStart, yStart, xStart + xLength - 1, yStart);
|
||||
}
|
||||
|
||||
// Draw a Vertical line
|
||||
// color: Line segment color
|
||||
// xStart/yStart: Start point
|
||||
// yLength: Line Length
|
||||
inline void DWIN_Draw_VLine(uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t yLength) {
|
||||
DWIN_Draw_Line(color, xStart, yStart, xStart, yStart + yLength - 1);
|
||||
}
|
||||
|
||||
// Draw a rectangle
|
||||
// mode: 0=frame, 1=fill, 2=XOR fill
|
||||
// color: Rectangle color
|
||||
// xStart/yStart: upper left point
|
||||
// xEnd/yEnd: lower right point
|
||||
void DWIN_Draw_Rectangle(uint8_t mode, uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd);
|
||||
|
||||
// Draw a box
|
||||
// mode: 0=frame, 1=fill, 2=XOR fill
|
||||
// color: Rectangle color
|
||||
// xStart/yStart: upper left point
|
||||
// xSize/ySize: box size
|
||||
inline void DWIN_Draw_Box(uint8_t mode, uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xSize, uint16_t ySize) {
|
||||
DWIN_Draw_Rectangle(mode, color, xStart, yStart, xStart + xSize - 1, yStart + ySize - 1);
|
||||
}
|
||||
|
||||
// Move a screen area
|
||||
// mode: 0, circle shift; 1, translation
|
||||
// dir: 0=left, 1=right, 2=up, 3=down
|
||||
// dis: Distance
|
||||
// color: Fill color
|
||||
// xStart/yStart: upper left point
|
||||
// xEnd/yEnd: bottom right point
|
||||
void DWIN_Frame_AreaMove(uint8_t mode, uint8_t dir, uint16_t dis,
|
||||
uint16_t color, uint16_t xStart, uint16_t yStart, uint16_t xEnd, uint16_t yEnd);
|
||||
|
||||
/*---------------------------------------- Text related functions ----------------------------------------*/
|
||||
|
||||
// Draw a string
|
||||
// widthAdjust: true=self-adjust character width; false=no adjustment
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// x/y: Upper-left coordinate of the string
|
||||
// *string: The string
|
||||
// rlimit: For draw less chars than string length use rlimit
|
||||
void DWIN_Draw_String(bool widthAdjust, bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x, uint16_t y, const char * const string, uint16_t rlimit = 0xFFFF);
|
||||
inline void DWIN_Draw_String(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x, uint16_t y, const char * const string, uint16_t rlimit = 0xFFFF) {
|
||||
DWIN_Draw_String(0, bShow, size, color, bColor, x, y, string, rlimit);
|
||||
}
|
||||
|
||||
class __FlashStringHelper;
|
||||
|
||||
inline void DWIN_Draw_String(bool widthAdjust, bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x, uint16_t y, const __FlashStringHelper *title) {
|
||||
DWIN_Draw_String(widthAdjust, bShow, size, color, bColor, x, y, (char *)title);
|
||||
}
|
||||
inline void DWIN_Draw_String(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t x, uint16_t y, const __FlashStringHelper *title) {
|
||||
DWIN_Draw_String(0, bShow, size, color, bColor, x, y, (char *)title);
|
||||
}
|
||||
|
||||
// Draw a positive integer
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// zeroFill: true=zero fill; false=no zero fill
|
||||
// zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// iNum: Number of digits
|
||||
// x/y: Upper-left coordinate
|
||||
// value: Integer value
|
||||
void DWIN_Draw_IntValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint16_t x, uint16_t y, long value);
|
||||
|
||||
// Draw a positive floating point number
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// zeroFill: true=zero fill; false=no zero fill
|
||||
// zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
|
||||
// size: Font size
|
||||
// color: Character color
|
||||
// bColor: Background color
|
||||
// iNum: Number of whole digits
|
||||
// fNum: Number of decimal digits
|
||||
// x/y: Upper-left point
|
||||
// value: Scaled positive float value
|
||||
void DWIN_Draw_FloatValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, long value);
|
||||
// value: positive float value
|
||||
void DWIN_Draw_FloatValue(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color,
|
||||
uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value);
|
||||
|
||||
/*---------------------------------------- Picture related functions ----------------------------------------*/
|
||||
|
||||
// Display QR code
|
||||
// The size of the QR code is (46*QR_Pixel)*(46*QR_Pixel) dot matrix
|
||||
// QR_Pixel: The pixel size occupied by each point of the QR code: 0x01-0x0F (1-16)
|
||||
// (Nx, Ny): The coordinates of the upper left corner displayed by the QR code
|
||||
// str: multi-bit data
|
||||
void DWIN_Draw_QR(uint8_t QR_Pixel, uint16_t x, uint16_t y, char *string);
|
||||
|
||||
inline void DWIN_Draw_QR(uint8_t QR_Pixel, uint16_t x, uint16_t y, const __FlashStringHelper *title) {
|
||||
DWIN_Draw_QR(QR_Pixel, x, y, (char *)title);
|
||||
}
|
||||
|
||||
// Draw JPG and cached in #0 virtual display area
|
||||
// id: Picture ID
|
||||
void DWIN_JPG_ShowAndCache(const uint8_t id);
|
||||
|
||||
// Draw an Icon
|
||||
// IBD: The icon background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// libID: Icon library ID
|
||||
// picID: Icon ID
|
||||
// x/y: Upper-left point
|
||||
void DWIN_ICON_Show(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint8_t libID, uint8_t picID, uint16_t x, uint16_t y);
|
||||
|
||||
// Draw an Icon with transparent background
|
||||
// libID: Icon library ID
|
||||
// picID: Icon ID
|
||||
// x/y: Upper-left point
|
||||
inline void DWIN_ICON_Show(uint8_t libID, uint8_t picID, uint16_t x, uint16_t y) {
|
||||
DWIN_ICON_Show(0, 0, 1, libID, picID, x, y);
|
||||
}
|
||||
|
||||
// Draw an Icon from SRAM
|
||||
// IBD: The icon background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// x/y: Upper-left point
|
||||
// addr: SRAM address
|
||||
void DWIN_ICON_Show(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint16_t x, uint16_t y, uint16_t addr);
|
||||
|
||||
// Unzip the JPG picture to a virtual display area
|
||||
// n: Cache index
|
||||
// id: Picture ID
|
||||
void DWIN_JPG_CacheToN(uint8_t n, uint8_t id);
|
||||
|
||||
// Unzip the JPG picture to virtual display area #1
|
||||
// id: Picture ID
|
||||
inline void DWIN_JPG_CacheTo1(uint8_t id) { DWIN_JPG_CacheToN(1, id); }
|
||||
|
||||
// Copy area from current virtual display area to current screen
|
||||
// xStart/yStart: Upper-left of virtual area
|
||||
// xEnd/yEnd: Lower-right of virtual area
|
||||
// x/y: Screen paste point
|
||||
void DWIN_Frame_AreaCopy(uint16_t xStart, uint16_t yStart,
|
||||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t y);
|
||||
|
||||
// Copy area from virtual display area to current screen
|
||||
// IBD: background display: 0=Background filtering is not displayed, 1=Background display \\When setting the background filtering not to display, the background must be pure black
|
||||
// BIR: Background image restoration: 0=Background image is not restored, 1=Automatically use virtual display area image for background restoration
|
||||
// BFI: Background filtering strength: 0=normal, 1=enhanced, (only valid when the icon background display=0)
|
||||
// cacheID: virtual area number
|
||||
// xStart/yStart: Upper-left of virtual area
|
||||
// xEnd/yEnd: Lower-right of virtual area
|
||||
// x/y: Screen paste point
|
||||
void DWIN_Frame_AreaCopy(uint8_t IBD, uint8_t BIR, uint8_t BFI, uint8_t cacheID, uint16_t xStart, uint16_t yStart,
|
||||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t y);
|
||||
|
||||
// Copy area from virtual display area to current screen with transparent background
|
||||
// cacheID: virtual area number
|
||||
// xStart/yStart: Upper-left of virtual area
|
||||
// xEnd/yEnd: Lower-right of virtual area
|
||||
// x/y: Screen paste point
|
||||
inline void DWIN_Frame_AreaCopy(uint8_t cacheID, uint16_t xStart, uint16_t yStart,
|
||||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t y) {
|
||||
DWIN_Frame_AreaCopy(0, 0, 1, cacheID, xStart, yStart, xEnd, yEnd, x, y);
|
||||
}
|
||||
|
||||
// Animate a series of icons
|
||||
// animID: Animation ID up to 16
|
||||
// animate: animation on or off
|
||||
// libID: Icon library ID
|
||||
// picIDs: Icon starting ID
|
||||
// picIDe: Icon ending ID
|
||||
// x/y: Upper-left point
|
||||
// interval: Display time interval, unit 10mS
|
||||
void DWIN_ICON_Animation(uint8_t animID, bool animate, uint8_t libID, uint8_t picIDs,
|
||||
uint8_t picIDe, uint16_t x, uint16_t y, uint16_t interval);
|
||||
|
||||
// Animation Control
|
||||
// state: 16 bits, each bit is the state of an animation id
|
||||
void DWIN_ICON_AnimationControl(uint16_t state);
|
||||
|
||||
// Set LCD Brightness 0x00-0x0F
|
||||
void DWIN_LCD_Brightness(const uint8_t brightness);
|
||||
|
||||
// Write buffer data to the SRAM or Flash
|
||||
// mem: 0x5A=32KB SRAM, 0xA5=16KB Flash
|
||||
// addr: start address
|
||||
// length: Bytes to write
|
||||
// data: address of the buffer with data
|
||||
void DWIN_WriteToMem(uint8_t mem, uint16_t addr, uint16_t length, uint8_t *data);
|
||||
|
||||
// Write the contents of the 32KB SRAM data memory into the designated image memory space.
|
||||
// picID: Picture memory space location, 0x00-0x0F, each space is 32Kbytes
|
||||
void DWIN_SRAMToPic(uint8_t picID);
|
||||
@ -0,0 +1,452 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.3
|
||||
* Date: 2021/08/09
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "../../../inc/MarlinConfigPre.h"
|
||||
|
||||
#if ENABLED(DWIN_CREALITY_LCD_ENHANCED)
|
||||
|
||||
#include "../../../inc/MarlinConfig.h"
|
||||
#include "../../../core/macros.h"
|
||||
#include "dwin_lcd.h"
|
||||
#include "dwinui.h"
|
||||
|
||||
//#define DEBUG_OUT 1
|
||||
#include "../../../core/debug_out.h"
|
||||
|
||||
uint8_t MenuItemTotal = 0;
|
||||
uint8_t MenuItemCount = 0;
|
||||
MenuItemClass** MenuItems = nullptr;
|
||||
MenuClass *CurrentMenu = nullptr;
|
||||
MenuClass *PreviousMenu = nullptr;
|
||||
|
||||
xy_int_t DWINUI::cursor = { 0 };
|
||||
uint16_t DWINUI::pencolor = Color_White;
|
||||
uint16_t DWINUI::textcolor = Def_Text_Color;
|
||||
uint16_t DWINUI::backcolor = Def_Background_Color;
|
||||
uint8_t DWINUI::font = font8x16;
|
||||
|
||||
void (*DWINUI::onCursorErase)(uint8_t line)=nullptr;
|
||||
void (*DWINUI::onCursorDraw)(uint8_t line)=nullptr;
|
||||
void (*DWINUI::onTitleDraw)(TitleClass* title)=nullptr;
|
||||
void (*DWINUI::onMenuDraw)(MenuClass* menu)=nullptr;
|
||||
|
||||
void DWINUI::Init(void) {
|
||||
DEBUG_ECHOPGM("\r\nDWIN handshake ");
|
||||
delay(750); // Delay here or init later in the boot process
|
||||
const bool success = DWIN_Handshake();
|
||||
if (success) DEBUG_ECHOLNPGM("ok."); else DEBUG_ECHOLNPGM("error.");
|
||||
DWIN_Frame_SetDir(1);
|
||||
TERN(SHOW_BOOTSCREEN,,DWIN_Frame_Clear(Color_Bg_Black));
|
||||
DWIN_UpdateLCD();
|
||||
cursor.x = 0;
|
||||
cursor.y = 0;
|
||||
pencolor = Color_White;
|
||||
textcolor = Def_Text_Color;
|
||||
backcolor = Def_Background_Color;
|
||||
font = font8x16;
|
||||
}
|
||||
|
||||
// Set text/number font
|
||||
void DWINUI::SetFont(uint8_t cfont) {
|
||||
font = cfont;
|
||||
}
|
||||
|
||||
// Get font character width
|
||||
uint8_t DWINUI::Get_font_width(uint8_t cfont) {
|
||||
switch (cfont) {
|
||||
case font6x12 : return 6;
|
||||
case font8x16 : return 8;
|
||||
case font10x20: return 10;
|
||||
case font12x24: return 12;
|
||||
case font14x28: return 14;
|
||||
case font16x32: return 16;
|
||||
case font20x40: return 20;
|
||||
case font24x48: return 24;
|
||||
case font28x56: return 28;
|
||||
case font32x64: return 32;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Get font character heigh
|
||||
uint8_t DWINUI::Get_font_height(uint8_t cfont) {
|
||||
switch (cfont) {
|
||||
case font6x12 : return 12;
|
||||
case font8x16 : return 16;
|
||||
case font10x20: return 20;
|
||||
case font12x24: return 24;
|
||||
case font14x28: return 28;
|
||||
case font16x32: return 32;
|
||||
case font20x40: return 40;
|
||||
case font24x48: return 48;
|
||||
case font28x56: return 56;
|
||||
case font32x64: return 64;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Get screen x coodinates from text column
|
||||
uint16_t DWINUI::ColToX(uint8_t col) {
|
||||
return col * Get_font_width(font);
|
||||
}
|
||||
|
||||
// Get screen y coodinates from text row
|
||||
uint16_t DWINUI::RowToY(uint8_t row) {
|
||||
return row * Get_font_height(font);
|
||||
}
|
||||
|
||||
// Set text/number color
|
||||
void DWINUI::SetColors(uint16_t fgcolor, uint16_t bgcolor) {
|
||||
textcolor = fgcolor;
|
||||
backcolor = bgcolor;
|
||||
}
|
||||
void DWINUI::SetTextColor(uint16_t fgcolor) {
|
||||
textcolor = fgcolor;
|
||||
}
|
||||
void DWINUI::SetBackgroundColor(uint16_t bgcolor) {
|
||||
backcolor = bgcolor;
|
||||
}
|
||||
|
||||
// Moves cursor to point
|
||||
// x: abscissa of the display
|
||||
// y: ordinate of the display
|
||||
// point: xy coordinate
|
||||
void DWINUI::MoveTo(int16_t x, int16_t y) {
|
||||
cursor.x = x;
|
||||
cursor.y = y;
|
||||
}
|
||||
void DWINUI::MoveTo(xy_int_t point) {
|
||||
cursor = point;
|
||||
}
|
||||
|
||||
// Moves cursor relative to the actual position
|
||||
// x: abscissa of the display
|
||||
// y: ordinate of the display
|
||||
// point: xy coordinate
|
||||
void DWINUI::MoveBy(int16_t x, int16_t y) {
|
||||
cursor.x += x;
|
||||
cursor.y += y;
|
||||
}
|
||||
void DWINUI::MoveBy(xy_int_t point) {
|
||||
cursor += point;
|
||||
}
|
||||
|
||||
// Draw a Centered string using DWIN_WIDTH
|
||||
void DWINUI::Draw_CenteredString(bool bShow, uint8_t size, uint16_t color, uint16_t bColor, uint16_t y, const char * const string) {
|
||||
const int8_t x = _MAX(0U, DWIN_WIDTH - strlen_P(string) * Get_font_width(size)) / 2 - 1;
|
||||
DWIN_Draw_String(bShow, size, color, bColor, x, y, string);
|
||||
}
|
||||
|
||||
// Draw a char at cursor position
|
||||
void DWINUI::Draw_Char(const char c) {
|
||||
const char string[2] = { c, 0};
|
||||
DWIN_Draw_String(false, font, textcolor, backcolor, cursor.x, cursor.y, string, 1);
|
||||
MoveBy(Get_font_width(font), 0);
|
||||
}
|
||||
|
||||
// Draw a string at cursor position
|
||||
// color: Character color
|
||||
// *string: The string
|
||||
// rlimit: For draw less chars than string length use rlimit
|
||||
void DWINUI::Draw_String(const char * const string, uint16_t rlimit) {
|
||||
DWIN_Draw_String(false, font, textcolor, backcolor, cursor.x, cursor.y, string, rlimit);
|
||||
MoveBy(strlen(string) * Get_font_width(font), 0);
|
||||
}
|
||||
void DWINUI::Draw_String(uint16_t color, const char * const string, uint16_t rlimit) {
|
||||
DWIN_Draw_String(false, font, color, backcolor, cursor.x, cursor.y, string, rlimit);
|
||||
MoveBy(strlen(string) * Get_font_width(font), 0);
|
||||
}
|
||||
|
||||
// Draw a signed floating point number
|
||||
// bShow: true=display background color; false=don't display background color
|
||||
// zeroFill: true=zero fill; false=no zero fill
|
||||
// zeroMode: 1=leading 0 displayed as 0; 0=leading 0 displayed as a space
|
||||
// size: Font size
|
||||
// bColor: Background color
|
||||
// iNum: Number of whole digits
|
||||
// fNum: Number of decimal digits
|
||||
// x/y: Upper-left point
|
||||
// value: Float value
|
||||
void DWINUI::Draw_Signed_Float(uint8_t bShow, bool zeroFill, uint8_t zeroMode, uint8_t size, uint16_t color, uint16_t bColor, uint8_t iNum, uint8_t fNum, uint16_t x, uint16_t y, float value) {
|
||||
if (value < 0) {
|
||||
DWIN_Draw_FloatValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, -value);
|
||||
DWIN_Draw_String(bShow, size, color, bColor, x - 6, y, F("-"));
|
||||
}
|
||||
else {
|
||||
DWIN_Draw_String(bShow, size, color, bColor, x - 6, y, F(" "));
|
||||
DWIN_Draw_FloatValue(bShow, zeroFill, zeroMode, size, color, bColor, iNum, fNum, x, y, value);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw a circle
|
||||
// color: circle color
|
||||
// x: the abscissa of the center of the circle
|
||||
// y: ordinate of the center of the circle
|
||||
// r: circle radius
|
||||
void DWINUI::Draw_Circle(uint16_t color, uint16_t x, uint16_t y, uint8_t r) {
|
||||
int a = 0, b = 0;
|
||||
while (a <= b) {
|
||||
b = SQRT(sq(r) - sq(a));
|
||||
if (a == 0) b--;
|
||||
DWIN_Draw_Point(color, 1, 1, x + a, y + b); // Draw some sector 1
|
||||
DWIN_Draw_Point(color, 1, 1, x + b, y + a); // Draw some sector 2
|
||||
DWIN_Draw_Point(color, 1, 1, x + b, y - a); // Draw some sector 3
|
||||
DWIN_Draw_Point(color, 1, 1, x + a, y - b); // Draw some sector 4
|
||||
DWIN_Draw_Point(color, 1, 1, x - a, y - b); // Draw some sector 5
|
||||
DWIN_Draw_Point(color, 1, 1, x - b, y - a); // Draw some sector 6
|
||||
DWIN_Draw_Point(color, 1, 1, x - b, y + a); // Draw some sector 7
|
||||
DWIN_Draw_Point(color, 1, 1, x - a, y + b); // Draw some sector 8
|
||||
a++;
|
||||
}
|
||||
}
|
||||
|
||||
// Draw a circle filled with color
|
||||
// bcolor: fill color
|
||||
// x: the abscissa of the center of the circle
|
||||
// y: ordinate of the center of the circle
|
||||
// r: circle radius
|
||||
void DWINUI::Draw_FillCircle(uint16_t bcolor, uint16_t x,uint16_t y,uint8_t r) {
|
||||
int a = 0, b = 0;
|
||||
while (a <= b) {
|
||||
b = SQRT(sq(r) - sq(a)); // b=sqrt(r*r-a*a);
|
||||
if (a == 0) b--;
|
||||
DWIN_Draw_Line(bcolor, x-b,y-a,x+b,y-a);
|
||||
DWIN_Draw_Line(bcolor, x-a,y-b,x+a,y-b);
|
||||
DWIN_Draw_Line(bcolor, x-b,y+a,x+b,y+a);
|
||||
DWIN_Draw_Line(bcolor, x-a,y+b,x+a,y+b);
|
||||
a++;
|
||||
}
|
||||
}
|
||||
|
||||
// Color Interpolator
|
||||
// val : Interpolator minv..maxv
|
||||
// minv : Minimum value
|
||||
// maxv : Maximun value
|
||||
// color1 : Start color
|
||||
// color2 : End color
|
||||
uint16_t DWINUI::ColorInt(int16_t val, int16_t minv, int16_t maxv, uint16_t color1, uint16_t color2) {
|
||||
uint8_t B,G,R;
|
||||
float n;
|
||||
n = (float)(val-minv)/(maxv-minv);
|
||||
R = (1-n)*GetRColor(color1) + n*GetRColor(color2);
|
||||
G = (1-n)*GetGColor(color1) + n*GetGColor(color2);
|
||||
B = (1-n)*GetBColor(color1) + n*GetBColor(color2);
|
||||
return RGB(R,G,B);
|
||||
}
|
||||
|
||||
// Color Interpolator through Red->Yellow->Green->Blue
|
||||
// val : Interpolator minv..maxv
|
||||
// minv : Minimum value
|
||||
// maxv : Maximun value
|
||||
uint16_t DWINUI::RainbowInt(int16_t val, int16_t minv, int16_t maxv) {
|
||||
uint8_t B,G,R;
|
||||
const uint8_t maxB = 28;
|
||||
const uint8_t maxR = 28;
|
||||
const uint8_t maxG = 38;
|
||||
const int16_t limv = _MAX(abs(minv), abs(maxv));
|
||||
float n;
|
||||
if (minv>=0) {
|
||||
n = (float)(val-minv)/(maxv-minv);
|
||||
} else {
|
||||
n = (float)val/limv;
|
||||
}
|
||||
n = _MIN(1, n);
|
||||
n = _MAX(-1, n);
|
||||
if (n < 0) {
|
||||
R = 0;
|
||||
G = (1+n)*maxG;
|
||||
B = (-n)*maxB;
|
||||
} else if (n < 0.5) {
|
||||
R = maxR*n*2;
|
||||
G = maxG;
|
||||
B = 0;
|
||||
} else {
|
||||
R = maxR;
|
||||
G = maxG*(1-n);
|
||||
B = 0;
|
||||
}
|
||||
return RGB(R,G,B);
|
||||
}
|
||||
|
||||
// Draw a checkbox
|
||||
// Color: frame color
|
||||
// bColor: Background color
|
||||
// x/y: Upper-left point
|
||||
// mode : 0 : unchecked, 1 : checked
|
||||
void DWINUI::Draw_Checkbox(uint16_t color, uint16_t bcolor, uint16_t x, uint16_t y, bool checked=false) {
|
||||
DWIN_Draw_String(false, true, font8x16, color, bcolor, x + 4, y, checked ? F("x") : F(" "));
|
||||
DWIN_Draw_Rectangle(0, color, x + 2, y + 2, x + 17, y + 17);
|
||||
}
|
||||
|
||||
// Clear Menu by filling the menu area with background color
|
||||
void DWINUI::ClearMenuArea() {
|
||||
DWIN_Draw_Rectangle(1, backcolor, 0, TITLE_HEIGHT, DWIN_WIDTH - 1, STATUS_Y - 1);
|
||||
}
|
||||
|
||||
void DWINUI::MenuItemsClear() {
|
||||
if (MenuItems == nullptr) return;
|
||||
for (uint8_t i = 0; i < MenuItemCount; i++) delete MenuItems[i];
|
||||
delete[] MenuItems;
|
||||
MenuItems = nullptr;
|
||||
MenuItemCount = 0;
|
||||
MenuItemTotal = 0;
|
||||
}
|
||||
|
||||
void DWINUI::MenuItemsPrepare(uint8_t totalitems) {
|
||||
MenuItemsClear();
|
||||
MenuItemTotal = totalitems;
|
||||
MenuItems = new MenuItemClass*[totalitems];
|
||||
}
|
||||
|
||||
MenuItemClass* DWINUI::MenuItemsAdd(MenuItemClass* menuitem) {
|
||||
if (MenuItemCount < MenuItemTotal) {
|
||||
MenuItems[MenuItemCount] = menuitem;
|
||||
menuitem->pos = MenuItemCount++;
|
||||
return menuitem;
|
||||
}
|
||||
else {
|
||||
delete menuitem;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Title Class ==============================================================*/
|
||||
|
||||
TitleClass Title;
|
||||
|
||||
void TitleClass::Draw() {
|
||||
if (DWINUI::onTitleDraw != nullptr) (*DWINUI::onTitleDraw)(this);
|
||||
}
|
||||
|
||||
void TitleClass::SetCaption(const char * const title) {
|
||||
frameid = 0;
|
||||
if ( caption == title ) return;
|
||||
const uint8_t len = _MIN(sizeof(caption) - 1, strlen(title));
|
||||
memcpy(&caption[0], title, len);
|
||||
caption[len] = '\0';
|
||||
}
|
||||
|
||||
void TitleClass::ShowCaption(const char * const title) {
|
||||
SetCaption(title);
|
||||
Draw();
|
||||
}
|
||||
|
||||
void TitleClass::SetFrame(uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
|
||||
caption[0] = '\0';
|
||||
frameid = id;
|
||||
frame = { x1, y1, x2, y2 };
|
||||
}
|
||||
|
||||
void TitleClass::SetFrame(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
|
||||
SetFrame(1, x, y, x + w - 1, y + h - 1);
|
||||
}
|
||||
|
||||
void TitleClass::FrameCopy(uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
|
||||
SetFrame(id, x1, y1, x2, y2);
|
||||
Draw();
|
||||
}
|
||||
|
||||
void TitleClass::FrameCopy(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
|
||||
FrameCopy(1, x, y, x + w - 1, y + h - 1);
|
||||
}
|
||||
|
||||
/* Menu Class ===============================================================*/
|
||||
|
||||
MenuClass::MenuClass() {
|
||||
selected = 0;
|
||||
topline = 0;
|
||||
}
|
||||
|
||||
void MenuClass::Draw() {
|
||||
MenuTitle.Draw();
|
||||
if (DWINUI::onMenuDraw != nullptr) (*DWINUI::onMenuDraw)(this);
|
||||
for (uint8_t i = 0; i < MenuItemCount; i++)
|
||||
MenuItems[i]->Draw(i - topline);
|
||||
if (DWINUI::onCursorDraw != nullptr) DWINUI::onCursorDraw(line());
|
||||
DWIN_UpdateLCD();
|
||||
}
|
||||
|
||||
void MenuClass::onScroll(bool dir) {
|
||||
int8_t sel = selected;
|
||||
if (dir) sel++; else sel--;
|
||||
LIMIT(sel, 0, MenuItemCount - 1);
|
||||
if (sel != selected) {
|
||||
if (DWINUI::onCursorErase != nullptr) DWINUI::onCursorErase(line());
|
||||
if ((sel - topline) == TROWS) {
|
||||
DWIN_Frame_AreaMove(1, DWIN_SCROLL_UP, MLINE, DWINUI::backcolor, 0, TITLE_HEIGHT + 1, DWIN_WIDTH, STATUS_Y - 1);
|
||||
topline++;
|
||||
MenuItems[sel]->Draw(TROWS - 1);
|
||||
}
|
||||
if ((sel < topline)) {
|
||||
DWIN_Frame_AreaMove(1, DWIN_SCROLL_DOWN, MLINE, DWINUI::backcolor, 0, TITLE_HEIGHT + 1, DWIN_WIDTH, STATUS_Y - 1);
|
||||
topline--;
|
||||
MenuItems[sel]->Draw(0);
|
||||
}
|
||||
selected = sel;
|
||||
if (DWINUI::onCursorDraw != nullptr) DWINUI::onCursorDraw(line());
|
||||
DWIN_UpdateLCD();
|
||||
}
|
||||
}
|
||||
|
||||
void MenuClass::onClick() {
|
||||
if (MenuItems[selected]->onClick != nullptr) (*MenuItems[selected]->onClick)();
|
||||
}
|
||||
|
||||
MenuItemClass *MenuClass::SelectedItem() {
|
||||
return MenuItems[selected];
|
||||
}
|
||||
|
||||
/* MenuItem Class ===========================================================*/
|
||||
|
||||
MenuItemClass::MenuItemClass(uint8_t cicon, const char * const text, void (*ondraw)(MenuItemClass* menuitem, int8_t line), void (*onclick)()) {
|
||||
icon = cicon;
|
||||
onClick = onclick;
|
||||
onDraw = ondraw;
|
||||
const uint8_t len = _MIN(sizeof(caption) - 1, strlen(text));
|
||||
memcpy(&caption[0], text, len);
|
||||
caption[len] = '\0';
|
||||
}
|
||||
|
||||
MenuItemClass::MenuItemClass(uint8_t cicon, uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, void (*ondraw)(MenuItemClass* menuitem, int8_t line), void (*onclick)()) {
|
||||
icon = cicon;
|
||||
onClick = onclick;
|
||||
onDraw = ondraw;
|
||||
caption[0] = '\0';
|
||||
frameid = id;
|
||||
frame = { x1, y1, x2, y2 };
|
||||
}
|
||||
|
||||
void MenuItemClass::SetFrame(uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
|
||||
caption[0] = '\0';
|
||||
frameid = id;
|
||||
frame = { x1, y1, x2, y2 };
|
||||
}
|
||||
|
||||
void MenuItemClass::Draw(int8_t line) {
|
||||
if (line < 0 || line >= TROWS) return;
|
||||
if (onDraw != nullptr) (*onDraw)(this, line);
|
||||
};
|
||||
|
||||
MenuItemPtrClass::MenuItemPtrClass(uint8_t cicon, const char * const text, void (*ondraw)(MenuItemClass* menuitem, int8_t line), void (*onclick)(), void* val) : MenuItemClass(cicon, text, ondraw, onclick) {
|
||||
value = val;
|
||||
};
|
||||
|
||||
#endif // DWIN_CREALITY_LCD_ENHANCED
|
||||
@ -0,0 +1,69 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "../../../inc/MarlinConfigPre.h"
|
||||
|
||||
#if ENABLED(DWIN_CREALITY_LCD_ENHANCED)
|
||||
|
||||
#include "../../../core/types.h"
|
||||
#include "dwin_lcd.h"
|
||||
#include "dwinui.h"
|
||||
#include "dwin.h"
|
||||
#include "lockscreen.h"
|
||||
|
||||
LockScreenClass LockScreen;
|
||||
|
||||
void LockScreenClass::Init() {
|
||||
Lock_Pos = 0;
|
||||
unlocked = false;
|
||||
Draw();
|
||||
}
|
||||
|
||||
void LockScreenClass::Draw() {
|
||||
Title.SetCaption(PSTR("Lock Screen"));
|
||||
DWINUI::ClearMenuArea();
|
||||
DWINUI::Draw_Icon(ICON_LOGO, 71, 120); // CREALITY logo
|
||||
DWINUI::Draw_CenteredString(Color_White, 180, F("Printer is Locked,"));
|
||||
DWINUI::Draw_CenteredString(Color_White, 200, F("Scroll to unlock."));
|
||||
DWINUI::Draw_CenteredString(Color_White, 240, F("-> | <-"));
|
||||
DWIN_Draw_Box(1, HMI_data.Barfill_Color, 0, 260, DWIN_WIDTH, 20);
|
||||
DWIN_Draw_VLine(Color_Yellow, Lock_Pos * DWIN_WIDTH / 255, 260, 20);
|
||||
DWIN_UpdateLCD();
|
||||
}
|
||||
|
||||
void LockScreenClass::onEncoderState(ENCODER_DiffState encoder_diffState) {
|
||||
if (encoder_diffState == ENCODER_DIFF_CW) {
|
||||
Lock_Pos += 8;
|
||||
}
|
||||
else if (encoder_diffState == ENCODER_DIFF_CCW) {
|
||||
Lock_Pos -= 8;
|
||||
}
|
||||
else if (encoder_diffState == ENCODER_DIFF_ENTER) {
|
||||
unlocked = (Lock_Pos == 128);
|
||||
}
|
||||
DWIN_Draw_Box(1, HMI_data.Barfill_Color, 0, 260, DWIN_WIDTH, 20);
|
||||
DWIN_Draw_VLine(Color_Yellow, Lock_Pos * DWIN_WIDTH / 255, 260, 20);
|
||||
DWIN_UpdateLCD();
|
||||
}
|
||||
|
||||
bool LockScreenClass::isUnlocked() { return unlocked; }
|
||||
|
||||
#endif // DWIN_CREALITY_LCD_ENHANCED
|
||||
@ -0,0 +1,35 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include "../../../core/types.h"
|
||||
|
||||
class LockScreenClass {
|
||||
private:
|
||||
uint8_t Lock_Pos = 0;
|
||||
bool unlocked = false;
|
||||
public:
|
||||
void Init();
|
||||
void onEncoderState(ENCODER_DiffState encoder_diffState);
|
||||
void Draw();
|
||||
bool isUnlocked();
|
||||
};
|
||||
extern LockScreenClass LockScreen;
|
||||
@ -0,0 +1,261 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
/*****************************************************************************
|
||||
* @file lcd/e3v2/enhanced/rotary_encoder.cpp
|
||||
* @author LEO / Creality3D
|
||||
* @date 2019/07/06
|
||||
* @version 2.0.1
|
||||
* @brief Rotary encoder functions
|
||||
*****************************************************************************/
|
||||
|
||||
#include "../../../inc/MarlinConfigPre.h"
|
||||
|
||||
#if ENABLED(DWIN_CREALITY_LCD_ENHANCED)
|
||||
|
||||
#include "rotary_encoder.h"
|
||||
#include "../../buttons.h"
|
||||
|
||||
#include "../../../MarlinCore.h"
|
||||
#include "../../../HAL/shared/Delay.h"
|
||||
|
||||
#if HAS_BUZZER
|
||||
#include "../../../libs/buzzer.h"
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef ENCODER_PULSES_PER_STEP
|
||||
#define ENCODER_PULSES_PER_STEP 4
|
||||
#endif
|
||||
|
||||
#if ENABLED(SOUND_MENU_ITEM)
|
||||
#include "../../marlinui.h"
|
||||
#endif
|
||||
|
||||
ENCODER_Rate EncoderRate;
|
||||
|
||||
// Buzzer
|
||||
void Encoder_tick() {
|
||||
#if PIN_EXISTS(BEEPER)
|
||||
if (TERN1(SOUND_MENU_ITEM, ui.buzzer_enabled)) {
|
||||
WRITE(BEEPER_PIN, HIGH);
|
||||
delay(10);
|
||||
WRITE(BEEPER_PIN, LOW);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Encoder initialization
|
||||
void Encoder_Configuration() {
|
||||
#if BUTTON_EXISTS(EN1)
|
||||
SET_INPUT_PULLUP(BTN_EN1);
|
||||
#endif
|
||||
#if BUTTON_EXISTS(EN2)
|
||||
SET_INPUT_PULLUP(BTN_EN2);
|
||||
#endif
|
||||
#if BUTTON_EXISTS(ENC)
|
||||
SET_INPUT_PULLUP(BTN_ENC);
|
||||
#endif
|
||||
#if PIN_EXISTS(BEEPER)
|
||||
SET_OUTPUT(BEEPER_PIN);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Analyze encoder value and return state
|
||||
ENCODER_DiffState Encoder_ReceiveAnalyze() {
|
||||
const millis_t now = millis();
|
||||
static uint8_t lastEncoderBits;
|
||||
uint8_t newbutton = 0;
|
||||
static signed char temp_diff = 0;
|
||||
|
||||
ENCODER_DiffState temp_diffState = ENCODER_DIFF_NO;
|
||||
if (BUTTON_PRESSED(EN1)) newbutton |= EN_A;
|
||||
if (BUTTON_PRESSED(EN2)) newbutton |= EN_B;
|
||||
if (BUTTON_PRESSED(ENC)) {
|
||||
static millis_t next_click_update_ms;
|
||||
if (ELAPSED(now, next_click_update_ms)) {
|
||||
next_click_update_ms = millis() + 300;
|
||||
Encoder_tick();
|
||||
#if PIN_EXISTS(LCD_LED)
|
||||
//LED_Action();
|
||||
#endif
|
||||
const bool was_waiting = wait_for_user;
|
||||
wait_for_user = false;
|
||||
return was_waiting ? ENCODER_DIFF_NO : ENCODER_DIFF_ENTER;
|
||||
}
|
||||
else return ENCODER_DIFF_NO;
|
||||
}
|
||||
if (newbutton != lastEncoderBits) {
|
||||
switch (newbutton) {
|
||||
case ENCODER_PHASE_0:
|
||||
if (lastEncoderBits == ENCODER_PHASE_3) temp_diff++;
|
||||
else if (lastEncoderBits == ENCODER_PHASE_1) temp_diff--;
|
||||
break;
|
||||
case ENCODER_PHASE_1:
|
||||
if (lastEncoderBits == ENCODER_PHASE_0) temp_diff++;
|
||||
else if (lastEncoderBits == ENCODER_PHASE_2) temp_diff--;
|
||||
break;
|
||||
case ENCODER_PHASE_2:
|
||||
if (lastEncoderBits == ENCODER_PHASE_1) temp_diff++;
|
||||
else if (lastEncoderBits == ENCODER_PHASE_3) temp_diff--;
|
||||
break;
|
||||
case ENCODER_PHASE_3:
|
||||
if (lastEncoderBits == ENCODER_PHASE_2) temp_diff++;
|
||||
else if (lastEncoderBits == ENCODER_PHASE_0) temp_diff--;
|
||||
break;
|
||||
}
|
||||
lastEncoderBits = newbutton;
|
||||
}
|
||||
|
||||
if (ABS(temp_diff) >= ENCODER_PULSES_PER_STEP) {
|
||||
if (temp_diff > 0) temp_diffState = ENCODER_DIFF_CW;
|
||||
else temp_diffState = ENCODER_DIFF_CCW;
|
||||
|
||||
#if ENABLED(ENCODER_RATE_MULTIPLIER)
|
||||
|
||||
millis_t ms = millis();
|
||||
int32_t encoderMultiplier = 1;
|
||||
|
||||
// if must encoder rati multiplier
|
||||
if (EncoderRate.enabled) {
|
||||
const float abs_diff = ABS(temp_diff),
|
||||
encoderMovementSteps = abs_diff / (ENCODER_PULSES_PER_STEP);
|
||||
if (EncoderRate.lastEncoderTime) {
|
||||
// Note that the rate is always calculated between two passes through the
|
||||
// loop and that the abs of the temp_diff value is tracked.
|
||||
const float encoderStepRate = encoderMovementSteps / float(ms - EncoderRate.lastEncoderTime) * 1000;
|
||||
if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC) encoderMultiplier = 100;
|
||||
else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
|
||||
else if (encoderStepRate >= ENCODER_5X_STEPS_PER_SEC) encoderMultiplier = 5;
|
||||
}
|
||||
EncoderRate.lastEncoderTime = ms;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
constexpr int32_t encoderMultiplier = 1;
|
||||
|
||||
#endif
|
||||
|
||||
// EncoderRate.encoderMoveValue += (temp_diff * encoderMultiplier) / (ENCODER_PULSES_PER_STEP);
|
||||
EncoderRate.encoderMoveValue = (temp_diff * encoderMultiplier) / (ENCODER_PULSES_PER_STEP);
|
||||
if (EncoderRate.encoderMoveValue < 0) EncoderRate.encoderMoveValue = -EncoderRate.encoderMoveValue;
|
||||
|
||||
temp_diff = 0;
|
||||
}
|
||||
return temp_diffState;
|
||||
}
|
||||
|
||||
#if PIN_EXISTS(LCD_LED)
|
||||
|
||||
// Take the low 24 valid bits 24Bit: G7 G6 G5 G4 G3 G2 G1 G0 R7 R6 R5 R4 R3 R2 R1 R0 B7 B6 B5 B4 B3 B2 B1 B0
|
||||
uint16_t LED_DataArray[LED_NUM];
|
||||
|
||||
// LED light operation
|
||||
void LED_Action() {
|
||||
LED_Control(RGB_SCALE_WARM_WHITE,0x0F);
|
||||
delay(30);
|
||||
LED_Control(RGB_SCALE_WARM_WHITE,0x00);
|
||||
}
|
||||
|
||||
// LED initialization
|
||||
void LED_Configuration() {
|
||||
SET_OUTPUT(LCD_LED_PIN);
|
||||
}
|
||||
|
||||
// LED write data
|
||||
void LED_WriteData() {
|
||||
uint8_t tempCounter_LED, tempCounter_Bit;
|
||||
for (tempCounter_LED = 0; tempCounter_LED < LED_NUM; tempCounter_LED++) {
|
||||
for (tempCounter_Bit = 0; tempCounter_Bit < 24; tempCounter_Bit++) {
|
||||
if (LED_DataArray[tempCounter_LED] & (0x800000 >> tempCounter_Bit)) {
|
||||
LED_DATA_HIGH;
|
||||
DELAY_NS(300);
|
||||
LED_DATA_LOW;
|
||||
DELAY_NS(200);
|
||||
}
|
||||
else {
|
||||
LED_DATA_HIGH;
|
||||
LED_DATA_LOW;
|
||||
DELAY_NS(200);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// LED control
|
||||
// RGB_Scale: RGB color ratio
|
||||
// luminance: brightness (0~0xFF)
|
||||
void LED_Control(const uint8_t RGB_Scale, const uint8_t luminance) {
|
||||
for (uint8_t i = 0; i < LED_NUM; i++) {
|
||||
LED_DataArray[i] = 0;
|
||||
switch (RGB_Scale) {
|
||||
case RGB_SCALE_R10_G7_B5: LED_DataArray[i] = (luminance * 10/10) << 8 | (luminance * 7/10) << 16 | luminance * 5/10; break;
|
||||
case RGB_SCALE_R10_G7_B4: LED_DataArray[i] = (luminance * 10/10) << 8 | (luminance * 7/10) << 16 | luminance * 4/10; break;
|
||||
case RGB_SCALE_R10_G8_B7: LED_DataArray[i] = (luminance * 10/10) << 8 | (luminance * 8/10) << 16 | luminance * 7/10; break;
|
||||
}
|
||||
}
|
||||
LED_WriteData();
|
||||
}
|
||||
|
||||
// LED gradient control
|
||||
// RGB_Scale: RGB color ratio
|
||||
// luminance: brightness (0~0xFF)
|
||||
// change_Time: gradient time (ms)
|
||||
void LED_GraduallyControl(const uint8_t RGB_Scale, const uint8_t luminance, const uint16_t change_Interval) {
|
||||
struct { uint8_t g, r, b; } led_data[LED_NUM];
|
||||
for (uint8_t i = 0; i < LED_NUM; i++) {
|
||||
switch (RGB_Scale) {
|
||||
case RGB_SCALE_R10_G7_B5:
|
||||
led_data[i] = { luminance * 7/10, luminance * 10/10, luminance * 5/10 };
|
||||
break;
|
||||
case RGB_SCALE_R10_G7_B4:
|
||||
led_data[i] = { luminance * 7/10, luminance * 10/10, luminance * 4/10 };
|
||||
break;
|
||||
case RGB_SCALE_R10_G8_B7:
|
||||
led_data[i] = { luminance * 8/10, luminance * 10/10, luminance * 7/10 };
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
struct { bool g, r, b; } led_flag = { false, false, false };
|
||||
for (uint8_t i = 0; i < LED_NUM; i++) {
|
||||
while (1) {
|
||||
const uint8_t g = uint8_t(LED_DataArray[i] >> 16),
|
||||
r = uint8_t(LED_DataArray[i] >> 8),
|
||||
b = uint8_t(LED_DataArray[i]);
|
||||
if (g == led_data[i].g) led_flag.g = true;
|
||||
else LED_DataArray[i] += (g > led_data[i].g) ? -0x010000 : 0x010000;
|
||||
if (r == led_data[i].r) led_flag.r = true;
|
||||
else LED_DataArray[i] += (r > led_data[i].r) ? -0x000100 : 0x000100;
|
||||
if (b == led_data[i].b) led_flag.b = true;
|
||||
else LED_DataArray[i] += (b > led_data[i].b) ? -0x000001 : 0x000001;
|
||||
LED_WriteData();
|
||||
if (led_flag.r && led_flag.g && led_flag.b) break;
|
||||
delay(change_Interval);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // LCD_LED
|
||||
|
||||
#endif // DWIN_CREALITY_LCD_ENHANCED
|
||||
@ -0,0 +1,93 @@
|
||||
/**
|
||||
* DWIN UI Enhanced implementation
|
||||
* Author: Miguel A. Risco-Castillo
|
||||
* Version: 3.6.1
|
||||
* Date: 2021/08/29
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser 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 Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
/*****************************************************************************
|
||||
* @file lcd/e3v2/enhanced/rotary_encoder.h
|
||||
* @author LEO / Creality3D
|
||||
* @date 2019/07/06
|
||||
* @version 2.0.1
|
||||
* @brief Rotary encoder functions
|
||||
****************************************************************************/
|
||||
|
||||
#include "../../../inc/MarlinConfig.h"
|
||||
|
||||
/*********************** Encoder Set ***********************/
|
||||
|
||||
typedef struct {
|
||||
bool enabled = false;
|
||||
int encoderMoveValue = 0;
|
||||
millis_t lastEncoderTime = 0;
|
||||
} ENCODER_Rate;
|
||||
|
||||
extern ENCODER_Rate EncoderRate;
|
||||
|
||||
typedef enum {
|
||||
ENCODER_DIFF_NO = 0, // no state
|
||||
ENCODER_DIFF_CW = 1, // clockwise rotation
|
||||
ENCODER_DIFF_CCW = 2, // counterclockwise rotation
|
||||
ENCODER_DIFF_ENTER = 3 // click
|
||||
} ENCODER_DiffState;
|
||||
|
||||
// Encoder initialization
|
||||
void Encoder_Configuration();
|
||||
|
||||
// Analyze encoder value and return state
|
||||
ENCODER_DiffState Encoder_ReceiveAnalyze();
|
||||
|
||||
/*********************** Encoder LED ***********************/
|
||||
|
||||
#if PIN_EXISTS(LCD_LED)
|
||||
|
||||
#define LED_NUM 4
|
||||
#define LED_DATA_HIGH WRITE(LCD_LED_PIN, 1)
|
||||
#define LED_DATA_LOW WRITE(LCD_LED_PIN, 0)
|
||||
|
||||
#define RGB_SCALE_R10_G7_B5 1
|
||||
#define RGB_SCALE_R10_G7_B4 2
|
||||
#define RGB_SCALE_R10_G8_B7 3
|
||||
#define RGB_SCALE_NEUTRAL_WHITE RGB_SCALE_R10_G7_B5
|
||||
#define RGB_SCALE_WARM_WHITE RGB_SCALE_R10_G7_B4
|
||||
#define RGB_SCALE_COOL_WHITE RGB_SCALE_R10_G8_B7
|
||||
|
||||
extern unsigned int LED_DataArray[LED_NUM];
|
||||
|
||||
// LED light operation
|
||||
void LED_Action();
|
||||
|
||||
// LED initialization
|
||||
void LED_Configuration();
|
||||
|
||||
// LED write data
|
||||
void LED_WriteData();
|
||||
|
||||
// LED control
|
||||
// RGB_Scale: RGB color ratio
|
||||
// luminance: brightness (0~0xFF)
|
||||
void LED_Control(const uint8_t RGB_Scale, const uint8_t luminance);
|
||||
|
||||
// LED gradient control
|
||||
// RGB_Scale: RGB color ratio
|
||||
// luminance: brightness (0~0xFF)
|
||||
// change_Time: gradient time (ms)
|
||||
void LED_GraduallyControl(const uint8_t RGB_Scale, const uint8_t luminance, const uint16_t change_Interval);
|
||||
|
||||
#endif // LCD_LED
|
||||
Loading…
Reference in New Issue