Jyers
3 years ago
committed by
Scott Lahteine
Scott Lahteine
29 changed files with 6575 additions and 40 deletions
@ -0,0 +1,7 @@ |
|||
# DWIN for Creality Ender 3 v2 |
|||
|
|||
Marlin's Ender 3 v2 support requires the `DWIN_SET` included with the Ender 3 V2 [example configuration](https://github.com/MarlinFirmware/Configurations/tree/bugfix-2.0.x/config/examples/Creality/Ender-3%20V2). |
|||
|
|||
## Easy Install |
|||
|
|||
Copy the `DWIN_SET` folder onto a Micro-SD card and insert the card into the slot on the DWIN screen. Cycle the machine and wait for the screen to go from blue to orange. Turn the machine off and remove the SD card. When you turn on the machine the screen will display a "Creality" loading screen. |
|||
File diff suppressed because it is too large
@ -0,0 +1,364 @@ |
|||
/**
|
|||
* 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 <https://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/**
|
|||
* lcd/e3v2/jyersui/dwin.h |
|||
*/ |
|||
|
|||
#include "dwin_lcd.h" |
|||
#include "rotary_encoder.h" |
|||
#include "../../../libs/BL24CXX.h" |
|||
#include "../../../inc/MarlinConfigPre.h" |
|||
|
|||
enum processID : uint8_t { |
|||
Main, Print, Menu, Value, Option, File, Popup, Confirm, Wait |
|||
}; |
|||
|
|||
enum PopupID : uint8_t { |
|||
Pause, Stop, Resume, SaveLevel, ETemp, ConfFilChange, PurgeMore, MeshSlot, |
|||
Level, Home, MoveWait, Heating, FilLoad, FilChange, TempWarn, Runout, PIDWait, Resuming, ManualProbing, |
|||
FilInsert, HeaterTime, UserInput, LevelError, InvalidMesh, UI, Complete |
|||
}; |
|||
|
|||
enum menuID : uint8_t { |
|||
MainMenu, |
|||
Prepare, |
|||
Move, |
|||
HomeMenu, |
|||
ManualLevel, |
|||
ZOffset, |
|||
Preheat, |
|||
ChangeFilament, |
|||
Control, |
|||
TempMenu, |
|||
PID, |
|||
HotendPID, |
|||
BedPID, |
|||
Preheat1, |
|||
Preheat2, |
|||
Preheat3, |
|||
Preheat4, |
|||
Preheat5, |
|||
Motion, |
|||
HomeOffsets, |
|||
MaxSpeed, |
|||
MaxAcceleration, |
|||
MaxJerk, |
|||
Steps, |
|||
Visual, |
|||
ColorSettings, |
|||
Advanced, |
|||
ProbeMenu, |
|||
Info, |
|||
Leveling, |
|||
LevelManual, |
|||
LevelView, |
|||
MeshViewer, |
|||
LevelSettings, |
|||
ManualMesh, |
|||
UBLMesh, |
|||
InfoMain, |
|||
Tune, |
|||
PreheatHotend |
|||
}; |
|||
|
|||
#define Start_Process 0 |
|||
#define Language_English 1 |
|||
#define Language_Chinese 2 |
|||
|
|||
#define ICON 7 // Icon set file 7.ICO
|
|||
|
|||
#define ICON_LOGO 0 |
|||
#define ICON_Print_0 1 |
|||
#define ICON_Print_1 2 |
|||
#define ICON_Prepare_0 3 |
|||
#define ICON_Prepare_1 4 |
|||
#define ICON_Control_0 5 |
|||
#define ICON_Control_1 6 |
|||
#define ICON_Leveling_0 7 |
|||
#define ICON_Leveling_1 8 |
|||
#define ICON_HotendTemp 9 |
|||
#define ICON_BedTemp 10 |
|||
#define ICON_Speed 11 |
|||
#define ICON_Zoffset 12 |
|||
#define ICON_Back 13 |
|||
#define ICON_File 14 |
|||
#define ICON_PrintTime 15 |
|||
#define ICON_RemainTime 16 |
|||
#define ICON_Setup_0 17 |
|||
#define ICON_Setup_1 18 |
|||
#define ICON_Pause_0 19 |
|||
#define ICON_Pause_1 20 |
|||
#define ICON_Continue_0 21 |
|||
#define ICON_Continue_1 22 |
|||
#define ICON_Stop_0 23 |
|||
#define ICON_Stop_1 24 |
|||
#define ICON_Bar 25 |
|||
#define ICON_More 26 |
|||
|
|||
#define ICON_Axis 27 |
|||
#define ICON_CloseMotor 28 |
|||
#define ICON_Homing 29 |
|||
#define ICON_SetHome 30 |
|||
#define ICON_PLAPreheat 31 |
|||
#define ICON_ABSPreheat 32 |
|||
#define ICON_Cool 33 |
|||
#define ICON_Language 34 |
|||
|
|||
#define ICON_MoveX 35 |
|||
#define ICON_MoveY 36 |
|||
#define ICON_MoveZ 37 |
|||
#define ICON_Extruder 38 |
|||
|
|||
#define ICON_Temperature 40 |
|||
#define ICON_Motion 41 |
|||
#define ICON_WriteEEPROM 42 |
|||
#define ICON_ReadEEPROM 43 |
|||
#define ICON_ResumeEEPROM 44 |
|||
#define ICON_Info 45 |
|||
|
|||
#define ICON_SetEndTemp 46 |
|||
#define ICON_SetBedTemp 47 |
|||
#define ICON_FanSpeed 48 |
|||
#define ICON_SetPLAPreheat 49 |
|||
#define ICON_SetABSPreheat 50 |
|||
|
|||
#define ICON_MaxSpeed 51 |
|||
#define ICON_MaxAccelerated 52 |
|||
#define ICON_MaxJerk 53 |
|||
#define ICON_Step 54 |
|||
#define ICON_PrintSize 55 |
|||
#define ICON_Version 56 |
|||
#define ICON_Contact 57 |
|||
#define ICON_StockConfiguraton 58 |
|||
#define ICON_MaxSpeedX 59 |
|||
#define ICON_MaxSpeedY 60 |
|||
#define ICON_MaxSpeedZ 61 |
|||
#define ICON_MaxSpeedE 62 |
|||
#define ICON_MaxAccX 63 |
|||
#define ICON_MaxAccY 64 |
|||
#define ICON_MaxAccZ 65 |
|||
#define ICON_MaxAccE 66 |
|||
#define ICON_MaxSpeedJerkX 67 |
|||
#define ICON_MaxSpeedJerkY 68 |
|||
#define ICON_MaxSpeedJerkZ 69 |
|||
#define ICON_MaxSpeedJerkE 70 |
|||
#define ICON_StepX 71 |
|||
#define ICON_StepY 72 |
|||
#define ICON_StepZ 73 |
|||
#define ICON_StepE 74 |
|||
#define ICON_Setspeed 75 |
|||
#define ICON_SetZOffset 76 |
|||
#define ICON_Rectangle 77 |
|||
#define ICON_BLTouch 78 |
|||
#define ICON_TempTooLow 79 |
|||
#define ICON_AutoLeveling 80 |
|||
#define ICON_TempTooHigh 81 |
|||
#define ICON_NoTips_C 82 |
|||
#define ICON_NoTips_E 83 |
|||
#define ICON_Continue_C 84 |
|||
#define ICON_Continue_E 85 |
|||
#define ICON_Cancel_C 86 |
|||
#define ICON_Cancel_E 87 |
|||
#define ICON_Confirm_C 88 |
|||
#define ICON_Confirm_E 89 |
|||
#define ICON_Info_0 90 |
|||
#define ICON_Info_1 91 |
|||
|
|||
// Custom icons
|
|||
#if ENABLED(DWIN_CREALITY_LCD_CUSTOM_ICONS) |
|||
// index of every custom icon should be >= CUSTOM_ICON_START
|
|||
#define CUSTOM_ICON_START ICON_Checkbox_F |
|||
#define ICON_Checkbox_F 200 |
|||
#define ICON_Checkbox_T 201 |
|||
#define ICON_Fade 202 |
|||
#define ICON_Mesh 203 |
|||
#define ICON_Tilt 204 |
|||
#define ICON_Brightness 205 |
|||
#define ICON_AxisD 249 |
|||
#define ICON_AxisBR 250 |
|||
#define ICON_AxisTR 251 |
|||
#define ICON_AxisBL 252 |
|||
#define ICON_AxisTL 253 |
|||
#define ICON_AxisC 254 |
|||
#else |
|||
#define ICON_Fade ICON_Version |
|||
#define ICON_Mesh ICON_Version |
|||
#define ICON_Tilt ICON_Version |
|||
#define ICON_Brightness ICON_Version |
|||
#define ICON_AxisD ICON_Axis |
|||
#define ICON_AxisBR ICON_Axis |
|||
#define ICON_AxisTR ICON_Axis |
|||
#define ICON_AxisBL ICON_Axis |
|||
#define ICON_AxisTL ICON_Axis |
|||
#define ICON_AxisC ICON_Axis |
|||
#endif |
|||
|
|||
#define font6x12 0x00 |
|||
#define font8x16 0x01 |
|||
#define font10x20 0x02 |
|||
#define font12x24 0x03 |
|||
#define font14x28 0x04 |
|||
#define font16x32 0x05 |
|||
#define font20x40 0x06 |
|||
#define font24x48 0x07 |
|||
#define font28x56 0x08 |
|||
#define font32x64 0x09 |
|||
|
|||
enum colorID : uint8_t { |
|||
Default, White, Green, Cyan, Blue, Magenta, Red, Orange, Yellow, Brown, Black |
|||
}; |
|||
|
|||
#define Custom_Colors 10 |
|||
#define Color_White 0xFFFF |
|||
#define Color_Light_White 0xBDD7 |
|||
#define Color_Green 0x07E0 |
|||
#define Color_Light_Green 0x3460 |
|||
#define Color_Cyan 0x07FF |
|||
#define Color_Light_Cyan 0x04F3 |
|||
#define Color_Blue 0x015F |
|||
#define Color_Light_Blue 0x3A6A |
|||
#define Color_Magenta 0xF81F |
|||
#define Color_Light_Magenta 0x9813 |
|||
#define Color_Red 0xF800 |
|||
#define Color_Light_Red 0x8800 |
|||
#define Color_Orange 0xFA20 |
|||
#define Color_Light_Orange 0xFBC0 |
|||
#define Color_Yellow 0xFF0F |
|||
#define Color_Light_Yellow 0x8BE0 |
|||
#define Color_Brown 0xCC27 |
|||
#define Color_Light_Brown 0x6204 |
|||
#define Color_Black 0x0000 |
|||
#define Color_Grey 0x18E3 |
|||
#define Color_Bg_Window 0x31E8 // Popup background color
|
|||
#define Color_Bg_Blue 0x1125 // Dark blue background color
|
|||
#define Color_Bg_Black 0x0841 // Black background color
|
|||
#define Color_Bg_Red 0xF00F // Red background color
|
|||
#define Popup_Text_Color 0xD6BA // Popup font background color
|
|||
#define Line_Color 0x3A6A // Split line color
|
|||
#define Rectangle_Color 0xEE2F // Blue square cursor color
|
|||
#define Percent_Color 0xFE29 // Percentage color
|
|||
#define BarFill_Color 0x10E4 // Fill color of progress bar
|
|||
#define Select_Color 0x33BB // Selected color
|
|||
#define Check_Color 0x4E5C // Check-box check color
|
|||
#define Confirm_Color 0x34B9 |
|||
#define Cancel_Color 0x3186 |
|||
|
|||
class CrealityDWINClass { |
|||
public: |
|||
static constexpr size_t eeprom_data_size = 48; |
|||
static struct EEPROM_Settings { // use bit fields to save space, max 48 bytes
|
|||
bool time_format_textual : 1; |
|||
bool beeperenable : 1; |
|||
#if ENABLED(AUTO_BED_LEVELING_UBL) |
|||
uint8_t tilt_grid_size : 3; |
|||
#endif |
|||
uint16_t corner_pos : 10; |
|||
uint8_t cursor_color : 4; |
|||
uint8_t menu_split_line : 4; |
|||
uint8_t menu_top_bg : 4; |
|||
uint8_t menu_top_txt : 4; |
|||
uint8_t highlight_box : 4; |
|||
uint8_t progress_percent : 4; |
|||
uint8_t progress_time : 4; |
|||
uint8_t status_bar_text : 4; |
|||
uint8_t status_area_text : 4; |
|||
uint8_t coordinates_text : 4; |
|||
uint8_t coordinates_split_line : 4; |
|||
} eeprom_settings; |
|||
|
|||
static constexpr const char * const color_names[11] = { "Default", "White", "Green", "Cyan", "Blue", "Magenta", "Red", "Orange", "Yellow", "Brown", "Black" }; |
|||
static constexpr const char * const preheat_modes[3] = { "Both", "Hotend", "Bed" }; |
|||
|
|||
static void Clear_Screen(uint8_t e=3); |
|||
static void Draw_Float(float value, uint8_t row, bool selected=false, uint8_t minunit=10); |
|||
static void Draw_Option(uint8_t value, const char * const * options, uint8_t row, bool selected=false, bool color=false); |
|||
static uint16_t GetColor(uint8_t color, uint16_t original, bool light=false); |
|||
static void Draw_Checkbox(uint8_t row, bool value); |
|||
static void Draw_Title(const char * title); |
|||
static void Draw_Menu_Item(uint8_t row, uint8_t icon=0, const char * const label1=nullptr, const char * const label2=nullptr, bool more=false, bool centered=false); |
|||
static void Draw_Menu(uint8_t menu, uint8_t select=0, uint8_t scroll=0); |
|||
static void Redraw_Menu(bool lastprocess=true, bool lastselection=false, bool lastmenu=false); |
|||
static void Redraw_Screen(); |
|||
|
|||
static void Main_Menu_Icons(); |
|||
static void Draw_Main_Menu(uint8_t select=0); |
|||
static void Print_Screen_Icons(); |
|||
static void Draw_Print_Screen(); |
|||
static void Draw_Print_Filename(const bool reset=false); |
|||
static void Draw_Print_ProgressBar(); |
|||
#if ENABLED(USE_M73_REMAINING_TIME) |
|||
static void Draw_Print_ProgressRemain(); |
|||
#endif |
|||
static void Draw_Print_ProgressElapsed(); |
|||
static void Draw_Print_confirm(); |
|||
static void Draw_SD_Item(uint8_t item, uint8_t row); |
|||
static void Draw_SD_List(bool removed=false); |
|||
static void Draw_Status_Area(bool icons=false); |
|||
static void Draw_Popup(PGM_P const line1, PGM_P const line2, PGM_P const line3, uint8_t mode, uint8_t icon=0); |
|||
static void Popup_Select(); |
|||
static void Update_Status_Bar(bool refresh=false); |
|||
|
|||
#if ENABLED(AUTO_BED_LEVELING_UBL) |
|||
static void Draw_Bed_Mesh(int16_t selected = -1, uint8_t gridline_width = 1, uint16_t padding_x = 8, uint16_t padding_y_top = 40 + 53 - 7); |
|||
static void Set_Mesh_Viewer_Status(); |
|||
#endif |
|||
|
|||
static const char * Get_Menu_Title(uint8_t menu); |
|||
static uint8_t Get_Menu_Size(uint8_t menu); |
|||
static void Menu_Item_Handler(uint8_t menu, uint8_t item, bool draw=true); |
|||
|
|||
static void Popup_Handler(PopupID popupid, bool option = false); |
|||
static void Confirm_Handler(PopupID popupid); |
|||
|
|||
static void Main_Menu_Control(); |
|||
static void Menu_Control(); |
|||
static void Value_Control(); |
|||
static void Option_Control(); |
|||
static void File_Control(); |
|||
static void Print_Screen_Control(); |
|||
static void Popup_Control(); |
|||
static void Confirm_Control(); |
|||
|
|||
static void Setup_Value(float value, float min, float max, float unit, uint8_t type); |
|||
static void Modify_Value(float &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Value(uint8_t &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Value(uint16_t &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Value(int16_t &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Value(uint32_t &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Value(int8_t &value, float min, float max, float unit, void (*f)()=nullptr); |
|||
static void Modify_Option(uint8_t value, const char * const * options, uint8_t max); |
|||
|
|||
static void Update_Status(const char * const text); |
|||
static void Start_Print(bool sd); |
|||
static void Stop_Print(); |
|||
static void Update(); |
|||
static void State_Update(); |
|||
static void Screen_Update(); |
|||
static void AudioFeedback(const bool success=true); |
|||
static void Save_Settings(char *buff); |
|||
static void Load_Settings(const char *buff); |
|||
static void Reset_Settings(); |
|||
}; |
|||
|
|||
extern CrealityDWINClass CrealityDWIN; |
|||
@ -0,0 +1,474 @@ |
|||
/**
|
|||
* 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 <https://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
/********************************************************************************
|
|||
* @file lcd/e3v2/jyersui/dwin_lcd.cpp |
|||
* @brief DWIN screen control functions |
|||
********************************************************************************/ |
|||
|
|||
#include "../../../inc/MarlinConfigPre.h" |
|||
|
|||
#if ENABLED(DWIN_CREALITY_LCD_JYERSUI) |
|||
|
|||
#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_WIDTH / 6 * 2] = { 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) { |
|||
const size_t len = _MIN(sizeof(DWIN_SendBuf) - i, strlen(string)); |
|||
memcpy(&DWIN_SendBuf[i + 1], string, len); |
|||
i += len; |
|||
} |
|||
|
|||
inline void DWIN_String(size_t &i, const __FlashStringHelper * string) { |
|||
if (!string) return; |
|||
const size_t len = 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 && 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 the backlight luminance
|
|||
// luminance: (0x00-0xFF)
|
|||
void DWIN_Backlight_SetLuminance(const uint8_t luminance) { |
|||
size_t i = 0; |
|||
DWIN_Byte(i, 0x30); |
|||
DWIN_Byte(i, luminance); |
|||
DWIN_Send(i); |
|||
} |
|||
|
|||
// 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: Pixel segment 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); |
|||
} |
|||
|
|||
//Color: color
|
|||
//x/y: Upper-left coordinate of the first pixel
|
|||
void DWIN_Draw_DegreeSymbol(uint16_t Color, uint16_t x, uint16_t y) { |
|||
DWIN_Draw_Point(Color, 1, 1, x + 1, y); |
|||
DWIN_Draw_Point(Color, 1, 1, x + 2, y); |
|||
DWIN_Draw_Point(Color, 1, 1, x, y + 1); |
|||
DWIN_Draw_Point(Color, 1, 1, x + 3, y + 1); |
|||
DWIN_Draw_Point(Color, 1, 1, x, y + 2); |
|||
DWIN_Draw_Point(Color, 1, 1, x + 3, y + 2); |
|||
DWIN_Draw_Point(Color, 1, 1, x + 1, y + 3); |
|||
DWIN_Draw_Point(Color, 1, 1, x + 2, y + 3); |
|||
} |
|||
|
|||
// 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
|
|||
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 * string) { |
|||
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); |
|||
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, uint16_t 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 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: 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) { |
|||
//uint8_t *fvalue = (uint8_t*)&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_Byte(i, fvalue[3]); |
|||
DWIN_Byte(i, fvalue[2]); |
|||
DWIN_Byte(i, fvalue[1]); |
|||
DWIN_Byte(i, fvalue[0]); |
|||
*/ |
|||
DWIN_Send(i); |
|||
} |
|||
|
|||
/*---------------------------------------- Picture related functions ----------------------------------------*/ |
|||
|
|||
// 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); // AA 23 00 00 00 00 08 00 01 02 03 CC 33 C3 3C
|
|||
} |
|||
|
|||
// Draw an Icon
|
|||
// libID: Icon library ID
|
|||
// picID: Icon ID
|
|||
// x/y: Upper-left point
|
|||
void DWIN_ICON_Show(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, 0x80 | libID); |
|||
DWIN_Byte(i, picID); |
|||
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 virtual display area to current screen
|
|||
// 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 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, 0x80 | 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, 0x28); |
|||
DWIN_Word(i, state); |
|||
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_JYERSUI
|
|||
@ -0,0 +1,218 @@ |
|||
/**
|
|||
* 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 <https://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/********************************************************************************
|
|||
* @file lcd/e3v2/jyersui/dwin_lcd.h |
|||
* @brief DWIN screen control functions |
|||
********************************************************************************/ |
|||
|
|||
#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 |
|||
|
|||
/*-------------------------------------- System variable function --------------------------------------*/ |
|||
|
|||
// Handshake (1: Success, 0: Fail)
|
|||
bool DWIN_Handshake(void); |
|||
|
|||
// Common DWIN startup
|
|||
void DWIN_Startup(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: Line segment 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); |
|||
} |
|||
|
|||
//Color: color
|
|||
//x: upper left point
|
|||
//y: bottom right point
|
|||
void DWIN_Draw_DegreeSymbol(uint16_t Color, uint16_t x, uint16_t y); |
|||
|
|||
// 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
|
|||
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 * string); |
|||
|
|||
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) { |
|||
// Note that this won't work on AVR. This is for 32-bit systems only!
|
|||
// Are __FlashStringHelper versions worth keeping?
|
|||
DWIN_Draw_String(widthAdjust, bShow, size, color, bColor, x, y, reinterpret_cast<const 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, uint16_t value); |
|||
|
|||
// Draw a 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: 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); |
|||
|
|||
/*---------------------------------------- Picture related functions ----------------------------------------*/ |
|||
|
|||
// Draw JPG and cached in #0 virtual display area
|
|||
// id: Picture ID
|
|||
void DWIN_JPG_ShowAndCache(const uint8_t id); |
|||
|
|||
// Draw an Icon
|
|||
// libID: Icon library ID
|
|||
// picID: Icon ID
|
|||
// x/y: Upper-left point
|
|||
void DWIN_ICON_Show(uint8_t libID, uint8_t picID, uint16_t x, uint16_t y); |
|||
|
|||
// 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 virtual display area to current screen
|
|||
// 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 cacheID, uint16_t xStart, uint16_t yStart, |
|||
uint16_t xEnd, uint16_t yEnd, uint16_t x, uint16_t 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); |
|||
@ -0,0 +1,261 @@ |
|||
/**
|
|||
* 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 <https://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
/*****************************************************************************
|
|||
* @file lcd/e3v2/jyersui/rotary_encoder.cpp |
|||
* @brief Rotary encoder functions |
|||
*****************************************************************************/ |
|||
|
|||
#include "../../../inc/MarlinConfigPre.h" |
|||
|
|||
#if ENABLED(DWIN_CREALITY_LCD_JYERSUI) |
|||
|
|||
#include "rotary_encoder.h" |
|||
#include "../../buttons.h" |
|||
|
|||
#include "../../../MarlinCore.h" |
|||
#include "../../marlinui.h" |
|||
#include "../../../HAL/shared/Delay.h" |
|||
|
|||
#if HAS_BUZZER |
|||
#include "../../../libs/buzzer.h" |
|||
#include "dwin.h" |
|||
#endif |
|||
|
|||
#include <stdlib.h> |
|||
|
|||
#ifndef ENCODER_PULSES_PER_STEP |
|||
#define ENCODER_PULSES_PER_STEP 4 |
|||
#endif |
|||
|
|||
ENCODER_Rate EncoderRate; |
|||
|
|||
// Buzzer
|
|||
void Encoder_tick() { |
|||
#if PIN_EXISTS(BEEPER) |
|||
if (CrealityDWIN.eeprom_settings.beeperenable) { |
|||
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 |
|||
if (ui.backlight) return ENCODER_DIFF_ENTER; |
|||
ui.refresh_brightness(); |
|||
} |
|||
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 ENABLED(REVERSE_ENCODER_DIRECTION) |
|||
if (temp_diff > 0) temp_diffState = ENCODER_DIFF_CCW; |
|||
else temp_diffState = ENCODER_DIFF_CW; |
|||
#else |
|||
if (temp_diff > 0) temp_diffState = ENCODER_DIFF_CW; |
|||
else temp_diffState = ENCODER_DIFF_CCW; |
|||
#endif |
|||
|
|||
#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_JYERSUI
|
|||
@ -0,0 +1,91 @@ |
|||
/**
|
|||
* 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 <https://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/*****************************************************************************
|
|||
* @file lcd/e3v2/jyersui/rotary_encoder.h |
|||
* @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