diff --git a/Documents/FT800CB_SCH.pdf b/Documents/FT800CB_SCH.pdf new file mode 100644 index 0000000..2128b00 Binary files /dev/null and b/Documents/FT800CB_SCH.pdf differ diff --git a/Documents/FT81X_Series_Programmer_Guide.pdf b/Documents/FT81X_Series_Programmer_Guide.pdf new file mode 100644 index 0000000..8c1597c Binary files /dev/null and b/Documents/FT81X_Series_Programmer_Guide.pdf differ diff --git a/Documents/FT81x_Data_Sheet.pdf b/Documents/FT81x_Data_Sheet.pdf new file mode 100644 index 0000000..031e103 Binary files /dev/null and b/Documents/FT81x_Data_Sheet.pdf differ diff --git a/MicroPython_BUILD/components/micropython/Kconfig.projbuild b/MicroPython_BUILD/components/micropython/Kconfig.projbuild index f96c726..1164ed7 100644 --- a/MicroPython_BUILD/components/micropython/Kconfig.projbuild +++ b/MicroPython_BUILD/components/micropython/Kconfig.projbuild @@ -15,8 +15,9 @@ menu "MicroPython" string "Time zone" default "GMT0BST" help - Set the time zone string used when updating the tome from NTP server - You can use 'zones.csv' file to find the time zone string + Set the default time zone string used when updating the time from NTP server + You can use 'components/micropython/docs/zones.csvzones.csv' + file to find the time zone string. Use the second entry for your Region/city as the value set here config MICROPY_USE_OTA @@ -211,6 +212,20 @@ menu "MicroPython" help Include websockets module into build + config MICROPY_USE_DISPLAY + bool "Use Display module" + default n + help + Include Display module into build + Display module includes support for various SPI TFT displays + + config MICROPY_USE_EVE + bool "Use EVE display module" + default n + help + Include EVE display module into build + Display module includes support for EVE displays (FT80x, FT81x) + config MICROPY_USE_GSM bool "Use GSM module" depends on PPP_SUPPORT diff --git a/MicroPython_BUILD/components/micropython/component.mk b/MicroPython_BUILD/components/micropython/component.mk index f265cea..4866e46 100644 --- a/MicroPython_BUILD/components/micropython/component.mk +++ b/MicroPython_BUILD/components/micropython/component.mk @@ -157,13 +157,16 @@ SRC_C = $(addprefix esp32/,\ mpsleep.c \ machine_rtc.c \ modymodem.c \ - moddisplay.c \ machine_hw_i2c.c \ machine_neopixel.c \ machine_dht.c \ machine_ow.c \ ) +ifdef CONFIG_MICROPY_USE_DISPLAY +SRC_C += esp32/moddisplay.c +endif + ifdef CONFIG_MICROPY_USE_CURL SRC_C += esp32/modcurl.c endif @@ -226,18 +229,6 @@ LIB_SRC_C = $(addprefix lib/,\ LIBS_SRC_C = $(addprefix esp32/libs/,\ espcurl.c \ neopixel.c \ - tft/spi_master_lobo.c \ - tft/tftspi.c \ - tft/tft.c \ - tft/comic24.c \ - tft/DefaultFont.c \ - tft/DejaVuSans18.c \ - tft/DejaVuSans24.c \ - tft/minya24.c \ - tft/SmallFont.c \ - tft/tooney32.c \ - tft/Ubuntu16.c \ - tft/def_small.c \ esp_rmt.c \ telnet.c \ ftp.c \ @@ -248,6 +239,27 @@ LIBS_SRC_C = $(addprefix esp32/libs/,\ ow/ds18b20.c \ ) +ifdef CONFIG_MICROPY_USE_DISPLAY +LIBS_SRC_C += \ + esp32/libs/tft/spi_master_lobo.c \ + esp32/libs/tft/tftspi.c \ + esp32/libs/tft/tft.c \ + esp32/libs/tft/comic24.c \ + esp32/libs/tft/DefaultFont.c \ + esp32/libs/tft/DejaVuSans18.c \ + esp32/libs/tft/DejaVuSans24.c \ + esp32/libs/tft/minya24.c \ + esp32/libs/tft/SmallFont.c \ + esp32/libs/tft/tooney32.c \ + esp32/libs/tft/Ubuntu16.c \ + esp32/libs/tft/def_small.c +endif + +ifdef CONFIG_MICROPY_USE_EVE +LIBS_SRC_C += \ + esp32/libs/eve/FT8_commands.c +endif + ifeq ($(MICROPY_PY_BTREE),1) LIB_SRC_C += \ lib/berkeley-db-1.xx/btree/bt_open.c \ diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8.h b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8.h new file mode 100644 index 0000000..2aed422 --- /dev/null +++ b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8.h @@ -0,0 +1,736 @@ +/* +@file FT8.h +@brief Contains FT80x/FT81x API definitions +@version 3.2 +@date 2017-04-08 +@author Rudolph Riedel + +@section History + +2.1 +- changes to this header + +2.2 +- commented out "#define DISPLAY() ((0UL<<24))" as it collides with a define in the Arduino IDE - the whole section of "macros" needs a rework... + +3.0 +- renamed from FT800.h to FT8.h +- changed FT_ prefixes to FT8_ +- switched to standard-C compliant comment-style +- changed FT81x register definitions from decimal to hex +- verified all FT81x register definitions +- moved FT81x registers marked as "reserved" to an #if 0 block + +3.1 +- moved several undocumented commands to an #if 0 block + +3.2 +- moved CMD_CRC to the block of undocumented commands as well +*/ + +#include "FT8_commands.h" + +#ifndef _FT8_H_ +#define _FT8_H_ + + +#define DL_CLEAR 0x26000000UL /* requires OR'd arguments */ +#define DL_CLEAR_RGB 0x02000000UL /* requires OR'd arguments */ +#define DL_COLOR_RGB 0x04000000UL /* requires OR'd arguments */ +#define DL_POINT_SIZE 0x0D000000UL /* requires OR'd arguments */ +#define DL_END 0x21000000UL +#define DL_BEGIN 0x1F000000UL /* requires OR'd arguments */ +#define DL_DISPLAY 0x00000000UL + +#define CLR_COL 0x4 +#define CLR_STN 0x2 +#define CLR_TAG 0x1 + + +/* Host commands */ +#define FT8_ACTIVE 0x00 /* place FT8xx in active state */ +#define FT8_STANDBY 0x41 /* place FT8xx in Standby (clk running) */ +#define FT8_SLEEP 0x42 /* place FT8xx in Sleep (clk off) */ +#define FT8_PWRDOWN 0x50 /* place FT8xx in Power Down (core off) */ +#define FT8_CLKEXT 0x44 /* select external clock source */ +#define FT8_CLKINT 0x48 /* select internal clock source */ +#define FT8_CORERST 0x68 /* reset core - all registers default and processors reset */ +#define FT8_CLK48M 0x62 /* select 48MHz PLL output */ +#define FT8_CLK36M 0x61 /* select 36MHz PLL output */ + + +/* defines used for graphics commands */ +#define FT8_NEVER 0UL +#define FT8_LESS 1UL +#define FT8_LEQUAL 2UL +#define FT8_GREATER 3UL +#define FT8_GEQUAL 4UL +#define FT8_EQUAL 5UL +#define FT8_NOTEQUAL 6UL +#define FT8_ALWAYS 7UL + + +/* Bitmap formats */ +#define FT8_ARGB1555 0UL +#define FT8_L1 1UL +#define FT8_L4 2UL +#define FT8_L8 3UL +#define FT8_RGB332 4UL +#define FT8_ARGB2 5UL +#define FT8_ARGB4 6UL +#define FT8_RGB565 7UL +#define FT8_PALETTED 8UL +#define FT8_TEXT8X8 9UL +#define FT8_TEXTVGA 10UL +#define FT8_BARGRAPH 11UL + + +/* Bitmap filter types */ +#define FT8_NEAREST 0UL +#define FT8_BILINEAR 1UL + + +/* Bitmap wrap types */ +#define FT8_BORDER 0UL +#define FT8_REPEAT 1UL + + +/* Stencil defines */ +#define FT8_KEEP 1UL +#define FT8_REPLACE 2UL +#define FT8_INCR 3UL +#define FT8_DECR 4UL +#define FT8_INVERT 5UL + + +/* Graphics display list swap defines */ +#define FT8_DLSWAP_DONE 0UL +#define FT8_DLSWAP_LINE 1UL +#define FT8_DLSWAP_FRAME 2UL + + +/* Interrupt bits */ +#define FT8_INT_SWAP 0x01 +#define FT8_INT_TOUCH 0x02 +#define FT8_INT_TAG 0x04 +#define FT8_INT_SOUND 0x08 +#define FT8_INT_PLAYBACK 0x10 +#define FT8_INT_CMDEMPTY 0x20 +#define FT8_INT_CMDFLAG 0x40 +#define FT8_INT_CONVCOMPLETE 0x80 + + +/* Touch mode */ +#define FT8_TMODE_OFF 0 +#define FT8_TMODE_ONESHOT 1 +#define FT8_TMODE_FRAME 2 +#define FT8_TMODE_CONTINUOUS 3 + + +/* Alpha blending */ +#define FT8_ZERO 0UL +#define FT8_ONE 1UL +#define FT8_SRC_ALPHA 2UL +#define FT8_DST_ALPHA 3UL +#define FT8_ONE_MINUS_SRC_ALPHA 4UL +#define FT8_ONE_MINUS_DST_ALPHA 5UL + + +/* Graphics primitives */ +#define FT8_BITMAPS 1UL +#define FT8_POINTS 2UL +#define FT8_LINES 3UL +#define FT8_LINE_STRIP 4UL +#define FT8_EDGE_STRIP_R 5UL +#define FT8_EDGE_STRIP_L 6UL +#define FT8_EDGE_STRIP_A 7UL +#define FT8_EDGE_STRIP_B 8UL +#define FT8_RECTS 9UL + + +/* Widget command */ +#define FT8_OPT_MONO 1 +#define FT8_OPT_NODL 2 +#define FT8_OPT_FLAT 256 +#define FT8_OPT_CENTERX 512 +#define FT8_OPT_CENTERY 1024 +#define FT8_OPT_CENTER (FT8_OPT_CENTERX | FT8_OPT_CENTERY) +#define FT8_OPT_NOBACK 4096 +#define FT8_OPT_NOTICKS 8192 +#define FT8_OPT_NOHM 16384 +#define FT8_OPT_NOPOINTER 16384 +#define FT8_OPT_NOSECS 32768 +#define FT8_OPT_NOHANDS 49152 +#define FT8_OPT_RIGHTX 2048 +#define FT8_OPT_SIGNED 256 + + +/* Defines related to inbuilt font */ +#define FT8_NUMCHAR_PERFONT (128L) /* number of font characters per bitmap handle */ +#define FT8_FONT_TABLE_SIZE (148L) /* size of the font table - utilized for loopup by the graphics engine */ +#define FT8_FONT_TABLE_POINTER (0xFFFFCUL) /* pointer to the inbuilt font tables starting from bitmap handle 16 */ + + +/* Audio sample type defines */ +#define FT8_LINEAR_SAMPLES 0UL /* 8bit signed samples */ +#define FT8_ULAW_SAMPLES 1UL /* 8bit ulaw samples */ +#define FT8_ADPCM_SAMPLES 2UL /* 4bit ima adpcm samples */ + + +/* Synthesized sound */ +#define FT8_SILENCE 0x00 +#define FT8_SQUAREWAVE 0x01 +#define FT8_SINEWAVE 0x02 +#define FT8_SAWTOOTH 0x03 +#define FT8_TRIANGLE 0x04 +#define FT8_BEEPING 0x05 +#define FT8_ALARM 0x06 +#define FT8_WARBLE 0x07 +#define FT8_CAROUSEL 0x08 +#define FT8_PIPS(n) (0x0F + (n)) +#define FT8_HARP 0x40 +#define FT8_XYLOPHONE 0x41 +#define FT8_TUBA 0x42 +#define FT8_GLOCKENSPIEL 0x43 +#define FT8_ORGAN 0x44 +#define FT8_TRUMPET 0x45 +#define FT8_PIANO 0x46 +#define FT8_CHIMES 0x47 +#define FT8_MUSICBOX 0x48 +#define FT8_BELL 0x49 +#define FT8_CLICK 0x50 +#define FT8_SWITCH 0x51 +#define FT8_COWBELL 0x52 +#define FT8_NOTCH 0x53 +#define FT8_HIHAT 0x54 +#define FT8_KICKDRUM 0x55 +#define FT8_POP 0x56 +#define FT8_CLACK 0x57 +#define FT8_CHACK 0x58 +#define FT8_MUTE 0x60 +#define FT8_UNMUTE 0x61 + + +/* Synthesized sound frequencies, midi note */ +#define FT8_MIDI_A0 21 +#define FT8_MIDI_A_0 22 +#define FT8_MIDI_B0 23 +#define FT8_MIDI_C1 24 +#define FT8_MIDI_C_1 25 +#define FT8_MIDI_D1 26 +#define FT8_MIDI_D_1 27 +#define FT8_MIDI_E1 28 +#define FT8_MIDI_F1 29 +#define FT8_MIDI_F_1 30 +#define FT8_MIDI_G1 31 +#define FT8_MIDI_G_1 32 +#define FT8_MIDI_A1 33 +#define FT8_MIDI_A_1 34 +#define FT8_MIDI_B1 35 +#define FT8_MIDI_C2 36 +#define FT8_MIDI_C_2 37 +#define FT8_MIDI_D2 38 +#define FT8_MIDI_D_2 39 +#define FT8_MIDI_E2 40 +#define FT8_MIDI_F2 41 +#define FT8_MIDI_F_2 42 +#define FT8_MIDI_G2 43 +#define FT8_MIDI_G_2 44 +#define FT8_MIDI_A2 45 +#define FT8_MIDI_A_2 46 +#define FT8_MIDI_B2 47 +#define FT8_MIDI_C3 48 +#define FT8_MIDI_C_3 49 +#define FT8_MIDI_D3 50 +#define FT8_MIDI_D_3 51 +#define FT8_MIDI_E3 52 +#define FT8_MIDI_F3 53 +#define FT8_MIDI_F_3 54 +#define FT8_MIDI_G3 55 +#define FT8_MIDI_G_3 56 +#define FT8_MIDI_A3 57 +#define FT8_MIDI_A_3 58 +#define FT8_MIDI_B3 59 +#define FT8_MIDI_C4 60 +#define FT8_MIDI_C_4 61 +#define FT8_MIDI_D4 62 +#define FT8_MIDI_D_4 63 +#define FT8_MIDI_E4 64 +#define FT8_MIDI_F4 65 +#define FT8_MIDI_F_4 66 +#define FT8_MIDI_G4 67 +#define FT8_MIDI_G_4 68 +#define FT8_MIDI_A4 69 +#define FT8_MIDI_A_4 70 +#define FT8_MIDI_B4 71 +#define FT8_MIDI_C5 72 +#define FT8_MIDI_C_5 73 +#define FT8_MIDI_D5 74 +#define FT8_MIDI_D_5 75 +#define FT8_MIDI_E5 76 +#define FT8_MIDI_F5 77 +#define FT8_MIDI_F_5 78 +#define FT8_MIDI_G5 79 +#define FT8_MIDI_G_5 80 +#define FT8_MIDI_A5 81 +#define FT8_MIDI_A_5 82 +#define FT8_MIDI_B5 83 +#define FT8_MIDI_C6 84 +#define FT8_MIDI_C_6 85 +#define FT8_MIDI_D6 86 +#define FT8_MIDI_D_6 87 +#define FT8_MIDI_E6 88 +#define FT8_MIDI_F6 89 +#define FT8_MIDI_F_6 90 +#define FT8_MIDI_G6 91 +#define FT8_MIDI_G_6 92 +#define FT8_MIDI_A6 93 +#define FT8_MIDI_A_6 94 +#define FT8_MIDI_B6 95 +#define FT8_MIDI_C7 96 +#define FT8_MIDI_C_7 97 +#define FT8_MIDI_D7 98 +#define FT8_MIDI_D_7 99 +#define FT8_MIDI_E7 100 +#define FT8_MIDI_F7 101 +#define FT8_MIDI_F_7 102 +#define FT8_MIDI_G7 103 +#define FT8_MIDI_G_7 104 +#define FT8_MIDI_A7 105 +#define FT8_MIDI_A_7 106 +#define FT8_MIDI_B7 107 +#define FT8_MIDI_C8 108 + + +/* GPIO bits */ +#define FT8_GPIO0 0 +#define FT8_GPIO1 1 /* default gpio pin for audio shutdown, 1 - eanble, 0 - disable */ +#define FT8_GPIO7 7 /* default gpio pin for display enable, 1 - enable, 0 - disable */ + + +/* Display rotation */ +#define FT8_DISPLAY_0 0 /* 0 degrees rotation */ +#define FT8_DISPLAY_180 1 /* 180 degrees rotation */ + + +/* Coprocessor related commands */ +#define CMD_APPEND 0xFFFFFF1EUL +#define CMD_BGCOLOR 0xFFFFFF09UL +#define CMD_BUTTON 0xFFFFFF0DUL +#define CMD_CALIBRATE 0xFFFFFF15UL +#define CMD_CLOCK 0xFFFFFF14UL +#define CMD_COLDSTART 0xFFFFFF32UL +#define CMD_DIAL 0xFFFFFF2DUL +#define CMD_DLSTART 0xFFFFFF00UL +#define CMD_FGCOLOR 0xFFFFFF0AUL +#define CMD_GAUGE 0xFFFFFF13UL +#define CMD_GETMATRIX 0xFFFFFF33UL +#define CMD_GETPROPS 0xFFFFFF25UL +#define CMD_GETPTR 0xFFFFFF23UL +#define CMD_GRADCOLOR 0xFFFFFF34UL +#define CMD_GRADIENT 0xFFFFFF0BUL +#define CMD_INFLATE 0xFFFFFF22UL +#define CMD_INTERRUPT 0xFFFFFF02UL +#define CMD_KEYS 0xFFFFFF0EUL +#define CMD_LOADIDENTITY 0xFFFFFF26UL +#define CMD_LOADIMAGE 0xFFFFFF24UL +#define CMD_LOGO 0xFFFFFF31UL +#define CMD_MEMCPY 0xFFFFFF1DUL +#define CMD_MEMCRC 0xFFFFFF18UL +#define CMD_MEMSET 0xFFFFFF1BUL +#define CMD_MEMWRITE 0xFFFFFF1AUL +#define CMD_MEMZERO 0xFFFFFF1CUL +#define CMD_NUMBER 0xFFFFFF2EUL +#define CMD_PROGRESS 0xFFFFFF0FUL +#define CMD_REGREAD 0xFFFFFF19UL +#define CMD_ROTATE 0xFFFFFF29UL +#define CMD_SCALE 0xFFFFFF28UL +#define CMD_SCREENSAVER 0xFFFFFF2FUL +#define CMD_SCROLLBAR 0xFFFFFF11UL +#define CMD_SETFONT 0xFFFFFF2BUL +#define CMD_SETMATRIX 0xFFFFFF2AUL +#define CMD_SKETCH 0xFFFFFF30UL +#define CMD_SLIDER 0xFFFFFF10UL +#define CMD_SNAPSHOT 0xFFFFFF1FUL +#define CMD_SPINNER 0xFFFFFF16UL +#define CMD_STOP 0xFFFFFF17UL +#define CMD_SWAP 0xFFFFFF01UL +#define CMD_TEXT 0xFFFFFF0CUL +#define CMD_TOGGLE 0xFFFFFF12UL +#define CMD_TRACK 0xFFFFFF2CUL +#define CMD_TRANSLATE 0xFFFFFF27UL + + +/* the following are undocumented commands that therefore should not be used */ +#if 0 +#define CMD_CRC 0xFFFFFF03UL +#define CMD_HAMMERAUX 0xFFFFFF04UL +#define CMD_MARCH 0xFFFFFF05UL +#define CMD_IDCT 0xFFFFFF06UL +#define CMD_EXECUTE 0xFFFFFF07UL +#define CMD_GETPOINT 0xFFFFFF08UL +#define CMD_TOUCH_TRANSFORM 0xFFFFFF20UL +#define CMD_BITMAP_TRANSFORM 0xFFFFFF21UL +#endif + + +/* FT8xx graphics engine specific macros useful for static display list generation */ +#define ALPHA_FUNC(func,ref) ((9UL<<24)|(((func)&7UL)<<8)|(((ref)&255UL)<<0)) +#define BEGIN(prim) ((31UL<<24)|(((prim)&15UL)<<0)) +#define BITMAP_HANDLE(handle) ((5UL<<24)|(((handle)&31UL)<<0)) +#define BITMAP_LAYOUT(format,linestride,height) ((7UL<<24)|(((format)&31UL)<<19)|(((linestride)&1023UL)<<9)|(((height)&511UL)<<0)) +#define BITMAP_SIZE(filter,wrapx,wrapy,width,height) ((8UL<<24)|(((filter)&1UL)<<20)|(((wrapx)&1UL)<<19)|(((wrapy)&1UL)<<18)|(((width)&511UL)<<9)|(((height)&511UL)<<0)) +#define BITMAP_TRANSFORM_A(a) ((21UL<<24)|(((a)&131071UL)<<0)) +#define BITMAP_TRANSFORM_B(b) ((22UL<<24)|(((b)&131071UL)<<0)) +#define BITMAP_TRANSFORM_C(c) ((23UL<<24)|(((c)&16777215UL)<<0)) +#define BITMAP_TRANSFORM_D(d) ((24UL<<24)|(((d)&131071UL)<<0)) +#define BITMAP_TRANSFORM_E(e) ((25UL<<24)|(((e)&131071UL)<<0)) +#define BITMAP_TRANSFORM_F(f) ((26UL<<24)|(((f)&16777215UL)<<0)) +#define BLEND_FUNC(src,dst) ((11UL<<24)|(((src)&7UL)<<3)|(((dst)&7UL)<<0)) +#define CALL(dest) ((29UL<<24)|(((dest)&65535UL)<<0)) +#define CELL(cell) ((6UL<<24)|(((cell)&127UL)<<0)) +#define CLEAR(c,s,t) ((38UL<<24)|(((c)&1UL)<<2)|(((s)&1UL)<<1)|(((t)&1UL)<<0)) +#define CLEAR_COLOR_A(alpha) ((15UL<<24)|(((alpha)&255UL)<<0)) +#define CLEAR_COLOR_RGB(red,green,blue) ((2UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0)) +#define CLEAR_STENCIL(s) ((17UL<<24)|(((s)&255UL)<<0)) +#define CLEAR_TAG(s) ((18UL<<24)|(((s)&255UL)<<0)) +#define COLOR_A(alpha) ((16UL<<24)|(((alpha)&255UL)<<0)) +#define COLOR_MASK(r,g,b,a) ((32UL<<24)|(((r)&1UL)<<3)|(((g)&1UL)<<2)|(((b)&1UL)<<1)|(((a)&1UL)<<0)) +#define COLOR_RGB(red,green,blue) ((4UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0)) +/* #define DISPLAY() ((0UL<<24)) */ +#define END() ((33UL<<24)) +#define JUMP(dest) ((30UL<<24)|(((dest)&65535UL)<<0)) +#define LINE_WIDTH(width) ((14UL<<24)|(((width)&4095UL)<<0)) +#define MACRO(m) ((37UL<<24)|(((m)&1UL)<<0)) +#define POINT_SIZE(size) ((13UL<<24)|(((size)&8191UL)<<0)) +#define RESTORE_CONTEXT() ((35UL<<24)) +#define RETURN() ((36UL<<24)) +#define SAVE_CONTEXT() ((34UL<<24)) +#define STENCIL_FUNC(func,ref,mask) ((10UL<<24)|(((func)&7UL)<<16)|(((ref)&255UL)<<8)|(((mask)&255UL)<<0)) +#define STENCIL_MASK(mask) ((19UL<<24)|(((mask)&255UL)<<0)) +#define STENCIL_OP(sfail,spass) ((12UL<<24)|(((sfail)&7UL)<<3)|(((spass)&7UL)<<0)) +#define TAG(s) ((3UL<<24)|(((s)&255UL)<<0)) +#define TAG_MASK(mask) ((20UL<<24)|(((mask)&1UL)<<0)) +#define VERTEX2F(x,y) ((1UL<<30)|(((x)&32767UL)<<15)|(((y)&32767UL)<<0)) +#define VERTEX2II(x,y,handle,cell) ((2UL<<30)|(((x)&511UL)<<21)|(((y)&511UL)<<12)|(((handle)&31UL)<<7)|(((cell)&127UL)<<0)) + + +/* specific for FT80x */ +#ifndef FT8_81X_ENABLE + +#define FT8_CHIPID 0x00010008UL + +/* Coprocessor reset related */ +#define FT8_RESET_HOLD_COPROCESSOR 1 +#define FT8_RESET_RELEASE_COPROCESSOR 0 + +/* Maximum display display resolution supported by graphics engine */ +#define FT8_MAX_DISPLAYWIDTH (512L) +#define FT8_MAX_DISPLAYHEIGHT (512L) + +/* Defines for sound play and stop */ +#define FT8_SOUND_PLAY 1 +#define FT8_AUDIO_PLAY 1 + +/* Defines for audio playback parameters */ +#define FT8_AUDIO_SAMPLINGFREQ_MIN 8*1000L +#define FT8_AUDIO_SAMPLINGFREQ_MAX 48*1000L + +/* coprocessor error */ +#define FT8_COPRO_ERROR 0xfffUL + +/* Memory definitions */ +#define FT8_RAM_G 0x000000UL +#define FT8_ROM_CHIPID 0x0C0000UL +#define FT8_ROM_FONT 0x0BB23CUL +#define FT8_ROM_FONT_ADDR 0x0FFFFCUL +#define FT8_RAM_DL 0x100000UL +#define FT8_RAM_PAL 0x102000UL +#define FT8_RAM_CMD 0x108000UL +#define FT8_RAM_SCREENSHOT 0x1C2000UL + +/* Memory buffer sizes */ +#define FT8_RAM_G_SIZE 256*1024L +#define FT8_CMDFIFO_SIZE 4*1024L +#define FT8_RAM_DL_SIZE 8*1024L +#define FT8_RAM_PAL_SIZE 1*1024L + +/* Register definitions */ +#define REG_ID 0x102400UL +#define REG_FRAMES 0x102404UL +#define REG_CLOCK 0x102408UL +#define REG_FREQUENCY 0x10240CUL +#define REG_SCREENSHOT_EN 0x102410UL +#define REG_SCREENSHOT_Y 0x102414UL +#define REG_SCREENSHOT_START 0x102418UL +#define REG_CPURESET 0x10241CUL +#define REG_TAP_CRC 0x102420UL +#define REG_TAP_MASK 0x102424UL +#define REG_HCYCLE 0x102428UL +#define REG_HOFFSET 0x10242CUL +#define REG_HSIZE 0x102430UL +#define REG_HSYNC0 0x102434UL +#define REG_HSYNC1 0x102438UL +#define REG_VCYCLE 0x10243CUL +#define REG_VOFFSET 0x102440UL +#define REG_VSIZE 0x102444UL +#define REG_VSYNC0 0x102448UL +#define REG_VSYNC1 0x10244CUL +#define REG_DLSWAP 0x102450UL +#define REG_ROTATE 0x102454UL +#define REG_OUTBITS 0x102458UL +#define REG_DITHER 0x10245CUL +#define REG_SWIZZLE 0x102460UL +#define REG_CSPREAD 0x102464UL +#define REG_PCLK_POL 0x102468UL +#define REG_PCLK 0x10246CUL +#define REG_TAG_X 0x102470UL +#define REG_TAG_Y 0x102474UL +#define REG_TAG 0x102478UL +#define REG_VOL_PB 0x10247CUL +#define REG_VOL_SOUND 0x102480UL +#define REG_SOUND 0x102484UL +#define REG_PLAY 0x102488UL +#define REG_GPIO_DIR 0x10248CUL +#define REG_GPIO 0x102490UL +#define REG_INT_FLAGS 0x102498UL +#define REG_INT_EN 0x10249CUL +#define REG_INT_MASK 0x1024A0UL +#define REG_PLAYBACK_START 0x1024A4UL +#define REG_PLAYBACK_LENGTH 0x1024A8UL +#define REG_PLAYBACK_READPTR 0x1024ACUL +#define REG_PLAYBACK_FREQ 0x1024B0UL +#define REG_PLAYBACK_FORMAT 0x1024B4UL +#define REG_PLAYBACK_LOOP 0x1024B8UL +#define REG_PLAYBACK_PLAY 0x1024BCUL +#define REG_PWM_HZ 0x1024C0UL +#define REG_PWM_DUTY 0x1024C4UL +#define REG_MACRO_0 0x1024C8UL +#define REG_MACRO_1 0x1024CCUL +#define REG_SCREENSHOT_BUSY 0x1024D8UL +#define REG_CMD_READ 0x1024E4UL +#define REG_CMD_WRITE 0x1024E8UL +#define REG_CMD_DL 0x1024ECUL +#define REG_TOUCH_MODE 0x1024F0UL +#define REG_TOUCH_ADC_MODE 0x1024F4UL +#define REG_TOUCH_CHARGE 0x1024F8UL +#define REG_TOUCH_SETTLE 0x1024FCUL +#define REG_TOUCH_OVERSAMPLE 0x102500UL +#define REG_TOUCH_RZTHRESH 0x102504UL +#define REG_TOUCH_RAW_XY 0x102508UL +#define REG_TOUCH_RZ 0x10250CUL +#define REG_TOUCH_SCREEN_XY 0x102510UL +#define REG_TOUCH_TAG_XY 0x102514UL +#define REG_TOUCH_TAG 0x102518UL +#define REG_TOUCH_TRANSFORM_A 0x10251CUL +#define REG_TOUCH_TRANSFORM_B 0x102520UL +#define REG_TOUCH_TRANSFORM_C 0x102524UL +#define REG_TOUCH_TRANSFORM_D 0x102528UL +#define REG_TOUCH_TRANSFORM_E 0x10252CUL +#define REG_TOUCH_TRANSFORM_F 0x102530UL +#define REG_SCREENSHOT_READ 0x102554UL +#define REG_TRIM 0x10256CUL +#define REG_TOUCH_DIRECT_XY 0x102574UL +#define REG_TOUCH_DIRECT_Z1Z2 0x102578UL +#define REG_TRACKER 0x109000UL + +/* FT80x graphics engine specific macros useful for static display list generation */ +#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&1048575UL)<<0)) +#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&1023UL)<<10)|(((height)&1023UL)<<0)) +#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&511UL)<<9)|(((y)&511UL)<<0)) + + +/* FT81x */ +#else + +#define LOW_FREQ_BOUND 58800000L /* 98% of 60Mhz */ + +/* Memory definitions */ +#define FT8_RAM_G 0x000000UL +#define FT8_ROM_CHIPID 0x0C0000UL +#define FT8_ROM_FONT 0x1E0000UL +#define FT8_ROM_FONT_ADDR 0x2FFFFCUL +#define FT8_RAM_DL 0x300000UL +#define FT8_RAM_REG 0x302000UL +#define FT8_RAM_CMD 0x308000UL + +/* Memory buffer sizes */ +#define FT8_RAM_G_SIZE 1024*1024L +#define FT8_CMDFIFO_SIZE 4*1024L +#define FT8_RAM_DL_SIZE 8*1024L + + +/* various additional defines for FT81x */ +#define FT8_ADC_DIFFERENTIAL 1UL +#define FT8_ADC_SINGLE_ENDED 0UL + +#define FT8_INT_G8 18UL +#define FT8_INT_L8C 12UL +#define FT8_INT_VGA 13UL + +#define FT8_OPT_MEDIAFIFO 16UL +#define FT8_OPT_FULLSCREEN 8UL +#define FT8_OPT_NOTEAR 4UL +#define FT8_OPT_SOUND 32UL + +#define FT8_PALETTED4444 15UL +#define FT8_PALETTED565 14UL +#define FT8_PALETTED8 16UL +#define FT8_L2 17UL + + +/* additional commands for FT81x */ +#define CMD_MEDIAFIFO 0xFFFFFF39UL +#define CMD_PLAYVIDEO 0xFFFFFF3AUL +#define CMD_ROMFONT 0xFFFFFF3FU +#define CMD_SETBASE 0xFFFFFF38UL +#define CMD_SETBITMAP 0xFFFFFF43UL +#define CMD_SETFONT2 0xFFFFFF3BUL +#define CMD_SETROTATE 0xFFFFFF36UL +#define CMD_SETSCRATCH 0xFFFFFF3CUL +#define CMD_SNAPSHOT2 0xFFFFFF37UL +#define CMD_VIDEOFRAME 0xFFFFFF41UL +#define CMD_VIDEOSTART 0xFFFFFF40UL + + +/* the following are undocumented commands that therefore should not be used */ +#if 0 +#define CMD_CSKETCH 0xFFFFFF35UL +#define CMD_INT_RAMSHARED 0xFFFFFF3DUL +#define CMD_INT_SWLOADIMAGE 0xFFFFFF3EUL +#define CMD_SYNC 0xFFFFFF42UL +#endif + + +/* Register definitions */ +#define REG_ANA_COMP 0x302184UL /* only listed in datasheet */ +#define REG_BIST_EN 0x302174UL /* only listed in datasheet */ +#define REG_CLOCK 0x302008UL +#define REG_CMDB_SPACE 0x302574UL +#define REG_CMDB_WRITE 0x302578UL +#define REG_CMD_DL 0x302100UL +#define REG_CMD_READ 0x3020f8UL +#define REG_CMD_WRITE 0x3020fcUL +#define REG_CPURESET 0x302020UL +#define REG_CSPREAD 0x302068UL +#define REG_CTOUCH_EXTENDED 0x302108UL +#define REG_CTOUCH_TOUCH0_XY 0x302124UL /* only listed in datasheet */ +#define REG_CTOUCH_TOUCH4_X 0x30216cUL +#define REG_CTOUCH_TOUCH4_Y 0x302120UL +#define REG_CTOUCH_TOUCH1_XY 0x30211cUL +#define REG_CTOUCH_TOUCH2_XY 0x30218cUL +#define REG_CTOUCH_TOUCH3_XY 0x302190UL +#define REG_TOUCH_CONFIG 0x302168UL +#define REG_DATESTAMP 0x302564UL /* only listed in datasheet */ +#define REG_DITHER 0x302060UL +#define REG_DLSWAP 0x302054UL +#define REG_FRAMES 0x302004UL +#define REG_FREQUENCY 0x30200cUL +#define REG_GPIO 0x302094UL +#define REG_GPIOX 0x30209cUL +#define REG_GPIOX_DIR 0x302098UL +#define REG_GPIO_DIR 0x302090UL +#define REG_HCYCLE 0x30202cUL +#define REG_HOFFSET 0x302030UL +#define REG_HSIZE 0x302034UL +#define REG_HSYNC0 0x302038UL +#define REG_HSYNC1 0x30203cUL +#define REG_ID 0x302000UL +#define REG_INT_EN 0x3020acUL +#define REG_INT_FLAGS 0x3020a8UL +#define REG_INT_MASK 0x3020b0UL +#define REG_MACRO_0 0x3020d8UL +#define REG_MACRO_1 0x3020dcUL +#define REG_MEDIAFIFO_READ 0x309014UL /* only listed in programmers guide */ +#define REG_MEDIAFIFO_WRITE 0x309018UL /* only listed in programmers guide */ +#define REG_OUTBITS 0x30205cUL +#define REG_PCLK 0x302070UL +#define REG_PCLK_POL 0x30206cUL +#define REG_PLAY 0x30208cUL +#define REG_PLAYBACK_FORMAT 0x3020c4UL +#define REG_PLAYBACK_FREQ 0x3020c0UL +#define REG_PLAYBACK_LENGTH 0x3020b8UL +#define REG_PLAYBACK_LOOP 0x3020c8UL +#define REG_PLAYBACK_PLAY 0x3020ccUL +#define REG_PLAYBACK_READPTR 0x3020bcUL +#define REG_PLAYBACK_START 0x3020b4UL +#define REG_PWM_DUTY 0x3020d4UL +#define REG_PWM_HZ 0x3020d0UL +#define REG_RENDERMODE 0x302010UL /* only listed in datasheet */ +#define REG_ROTATE 0x302058UL +#define REG_SNAPFORMAT 0x30201cUL /* only listed in datasheet */ +#define REG_SNAPSHOT 0x302018UL /* only listed in datasheet */ +#define REG_SNAPY 0x302014UL /* only listed in datasheet */ +#define REG_SOUND 0x302088UL +#define REG_SPI_WIDTH 0x302188UL /* listed with false offset in programmers guide V1.1 */ +#define REG_SWIZZLE 0x302064UL +#define REG_TAG 0x30207cUL +#define REG_TAG_X 0x302074UL +#define REG_TAG_Y 0x302078UL +#define REG_TAP_CRC 0x302024UL /* only listed in datasheet */ +#define REG_TAP_MASK 0x302028UL /* only listed in datasheet */ +#define REG_TOUCH_ADC_MODE 0x302108UL +#define REG_TOUCH_CHARGE 0x30210cUL +#define REG_TOUCH_DIRECT_XY 0x30218cUL +#define REG_TOUCH_DIRECT_Z1Z2 0x302190UL +#define REG_TOUCH_MODE 0x302104UL +#define REG_TOUCH_OVERSAMPLE 0x302114UL +#define REG_TOUCH_RAW_XY 0x30211cUL +#define REG_TOUCH_RZ 0x302120UL +#define REG_TOUCH_RZTHRESH 0x302118UL +#define REG_TOUCH_SCREEN_XY 0x302124UL +#define REG_TOUCH_SETTLE 0x302110UL +#define REG_TOUCH_TAG 0x30212cUL +#define REG_TOUCH_TAG1 0x302134UL /* only listed in datasheet */ +#define REG_TOUCH_TAG1_XY 0x302130UL /* only listed in datasheet */ +#define REG_TOUCH_TAG2 0x30213cUL /* only listed in datasheet */ +#define REG_TOUCH_TAG2_XY 0x302138UL /* only listed in datasheet */ +#define REG_TOUCH_TAG3 0x302144UL /* only listed in datasheet */ +#define REG_TOUCH_TAG3_XY 0x302140UL /* only listed in datasheet */ +#define REG_TOUCH_TAG4 0x30214cUL /* only listed in datasheet */ +#define REG_TOUCH_TAG4_XY 0x302148UL /* only listed in datasheet */ +#define REG_TOUCH_TAG_XY 0x302128UL +#define REG_TOUCH_TRANSFORM_A 0x302150UL +#define REG_TOUCH_TRANSFORM_B 0x302154UL +#define REG_TOUCH_TRANSFORM_C 0x302158UL +#define REG_TOUCH_TRANSFORM_D 0x30215cUL +#define REG_TOUCH_TRANSFORM_E 0x302160UL +#define REG_TOUCH_TRANSFORM_F 0x302164UL +#define REG_TRACKER 0x309000UL /* only listed in programmers guide */ +#define REG_TRACKER_1 0x309004UL /* only listed in programmers guide */ +#define REG_TRACKER_2 0x309008UL /* only listed in programmers guide */ +#define REG_TRACKER_3 0x30900cUL /* only listed in programmers guide */ +#define REG_TRACKER_4 0x309010UL /* only listed in programmers guide */ +#define REG_TRIM 0x302180UL +#define REG_VCYCLE 0x302040UL +#define REG_VOFFSET 0x302044UL +#define REG_VOL_PB 0x302080UL +#define REG_VOL_SOUND 0x302084UL +#define REG_VSIZE 0x302048UL +#define REG_VSYNC0 0x30204cUL +#define REG_VSYNC1 0x302050UL + +#if 0 +#define REG_BUSYBITS 0x3020e8UL /* only listed as "reserved" in datasheet */ +#define REG_CRC 0x302178UL /* only listed as "reserved" in datasheet */ +#define REG_SPI_EARLY_TX 0x30217cUL /* only listed as "reserved" in datasheet */ +#define REG_ROMSUB_SEL 0x3020f0UL /* only listed as "reserved" in datasheet */ +#define REG_TOUCH_FAULT 0x302170UL /* only listed as "reserved" in datasheet */ +#endif + + +/* FT81x graphics engine specific macros useful for static display list generation */ +#define BITMAP_LAYOUT_H(linestride,height) ((40UL<<24)|(((linestride)&3UL)<<2)|(((height)&3UL)<<0)) +#define BITMAP_SIZE_H(width,height) ((41UL<<24)|(((width)&3UL)<<2)|(((height)&3UL)<<0)) +#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&4194303UL)<<0)) +#define NOP() ((45UL<<24)) +#define PALETTE_SOURCE(addr) ((42UL<<24)|(((addr)&4194303UL)<<0)) +#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&4095UL)<<12)|(((height)&4095UL)<<0)) +#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&2047UL)<<11)|(((y)&2047UL)<<0)) +#define VERTEX_FORMAT(frac) ((39UL<<24)|(((frac)&7UL)<<0)) +#define VERTEX_TRANSLATE_X(x) ((43UL<<24)|(((x)&131071UL)<<0)) +#define VERTEX_TRANSLATE_Y(y) ((44UL<<24)|(((y)&131071UL)<<0)) + +#endif + +#endif /* _FT8_H_ */ diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.c b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.c new file mode 100644 index 0000000..8c9989d --- /dev/null +++ b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.c @@ -0,0 +1,1136 @@ +/* + * This file is part of the ESP32 MicroPython project, https://github.com/loboris/MicroPython_ESP32_psRAM_LoBo + * + * Contains Functions for using the FT8xx + * === Ported from https://github.com/RudolphRiedel/FT800-FT813 === + * + * The MIT License (MIT) + * + * Copyright (c) 2017 Rudolph Riedel + * Copyright (c) 2018 LoBo (https://github.com/loboris) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + + +#include "sdkconfig.h" + +#if CONFIG_MICROPY_USE_EVE + +#include + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" + +#include "FT8.h" +#include "tft/spi_master_lobo.h" + + +// FT8xx Memory Commands - use with FT8_memWritexx and FT8_memReadxx +#define MEM_WRITE 0x80 // FT8xx Host Memory Write +#define MEM_READ 0x00 // FT8xx Host Memory Read + +uint16_t eve_cmdOffset = 0x0000; // used to navigate command ring buffer +static uint8_t cmd_burst = 0; // flag to indicate cmd-burst is active + +spi_lobo_device_handle_t eve_spi = NULL; + +//--------------------------------------------------------------------------------------------------- +static void IRAM_ATTR _spi_transfer_start(spi_lobo_device_handle_t spi_dev, int wrbits, int rdbits) { + // Load send buffer + spi_dev->host->hw->user.usr_mosi_highpart = 0; + spi_dev->host->hw->mosi_dlen.usr_mosi_dbitlen = wrbits-1; + spi_dev->host->hw->user.usr_mosi = 1; + if (rdbits) { + spi_dev->host->hw->miso_dlen.usr_miso_dbitlen = rdbits; + spi_dev->host->hw->user.usr_miso = 1; + } + else { + spi_dev->host->hw->miso_dlen.usr_miso_dbitlen = 0; + spi_dev->host->hw->user.usr_miso = 0; + } + // Start transfer + spi_dev->host->hw->cmd.usr = 1; + // Wait for SPI bus ready + while (spi_dev->host->hw->cmd.usr); +} + + +//----------------------------- +void FT8_cmdWrite(uint8_t data) +{ + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = (uint32_t)data; + _spi_transfer_start(eve_spi, 8, 0); + spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------------------------- +uint32_t FT8_address(uint32_t ftAddress, uint8_t mask) +{ + uint32_t wd = (ftAddress >> 16) & 0x3F; // Memory Write plus high address byte + wd |= ftAddress & 0x0000FF00; // middle address byte + wd |= (ftAddress << 16) & 0x00FF0000; // low address byte & dummy byte + return wd; +} + +//-------------------------------------- +uint8_t FT8_memRead8(uint32_t ftAddress) +{ + uint8_t ftData8 = 0; + + if (spi_lobo_device_select(eve_spi, 0)) return 0; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_READ); + eve_spi->host->hw->data_buf[1] = 0; + _spi_transfer_start(eve_spi, 40, 40); + + ftData8 = (uint8_t)eve_spi->host->hw->data_buf[1]; + spi_lobo_device_deselect(eve_spi); + + return ftData8; // return byte read +} + +//---------------------------------------- +uint16_t FT8_memRead16(uint32_t ftAddress) +{ + uint16_t ftData16 = 0; + + if (spi_lobo_device_select(eve_spi, 0)) return 0; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_READ); + eve_spi->host->hw->data_buf[1] = 0; + _spi_transfer_start(eve_spi, 48, 48); + + ftData16 = (uint16_t)eve_spi->host->hw->data_buf[1]; + spi_lobo_device_deselect(eve_spi); + + return ftData16; // return integer read +} + +//---------------------------------------- +uint32_t FT8_memRead32(uint32_t ftAddress) +{ + uint32_t ftData32= 0; + + if (spi_lobo_device_select(eve_spi, 0)) return 0; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_READ); + eve_spi->host->hw->data_buf[1] = 0; + _spi_transfer_start(eve_spi, 56, 56); + + ftData32 = eve_spi->host->hw->data_buf[1]; + spi_lobo_device_deselect(eve_spi); + + return ftData32; // return long read +} + +//----------------------------------------------------- +void FT8_memWrite8(uint32_t ftAddress, uint8_t ftData8) +{ + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE) | (uint32_t)(ftData8 << 24); + _spi_transfer_start(eve_spi, 32, 32); + spi_lobo_device_deselect(eve_spi); +} + +//-------------------------------------------------------- +void FT8_memWrite16(uint32_t ftAddress, uint16_t ftData16) +{ + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE) | (uint32_t)(ftData16 << 24); + eve_spi->host->hw->data_buf[1] = (uint32_t)(ftData16 >> 8); + _spi_transfer_start(eve_spi, 40, 40); + spi_lobo_device_deselect(eve_spi); +} + +//-------------------------------------------------------- +void FT8_memWrite32(uint32_t ftAddress, uint32_t ftData32) +{ + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE) | ftData32 << 24; + uint32_t wd = ((ftData32 >> 8) & 0xFF) | ((ftData32 >> 16) & 0xFF) | ((ftData32 >> 24) & 0xFF); + eve_spi->host->hw->data_buf[1] = wd; + _spi_transfer_start(eve_spi, 56, 56); + spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------------------------- +static void FT8_send_data(uint8_t *data, uint32_t len) +{ + spi_lobo_transaction_t t; + memset(&t, 0, sizeof(t)); //Zero out the transaction + + t.length = len * 8; + t.tx_buffer = data; + t.rxlength = 0; + t.rx_buffer = NULL; + + spi_lobo_transfer_data(eve_spi, &t); // Send using direct mode +} + +//----------------------------------------------------------------------------------- +void FT8_memWrite_flash_buffer(uint32_t ftAddress, const uint8_t *data, uint16_t len) +{ + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE); + _spi_transfer_start(eve_spi, 24, 24); + + len = (len + 3)&(~3); + + FT8_send_data((uint8_t *)data, len); + + spi_lobo_device_deselect(eve_spi); +} + + +// Check if the graphics processor completed executing the current command list. +// This is the case when REG_CMD_READ matches eve_cmdOffset, indicating that all commands have been executed. +//-------------------- +uint8_t FT8_busy(void) +{ + uint16_t cmdBufferRead; + + cmdBufferRead = FT8_memRead16(REG_CMD_READ); // read the graphics processor read pointer + + if (eve_cmdOffset != cmdBufferRead) return 1; + else return 0; +} + +//------------------------------ +uint32_t FT8_get_touch_tag(void) +{ + uint32_t value; + + value = FT8_memRead32(REG_TOUCH_TAG); + return value; +} + + +// Order the command coprocessor to start processing its FIFO queue and do not wait for completion +//---------------------- +void FT8_cmd_start(void) +{ + uint32_t ftAddress = REG_CMD_WRITE; + FT8_memWrite16(ftAddress, eve_cmdOffset); +} + + +/// Order the command coprocessor to start processing its FIFO queue and wait for completion +//------------------------ +void FT8_cmd_execute(void) +{ + FT8_cmd_start(); + while (FT8_busy()); +} + +//-------------------------- +void FT8_get_cmdoffset(void) +{ + eve_cmdOffset = FT8_memRead16(REG_CMD_WRITE); +} + +//---------------------------------------- +void FT8_inc_cmdoffset(uint16_t increment) +{ + eve_cmdOffset += increment; + eve_cmdOffset &= 0x0fff; +} + + +/* +These eliminate the overhead of transmitting the command fifo address with every single command, just wrap a sequence of commands +with these and the address is only transmitted once at the start of the block. +Be careful to not use any functions in the sequence that do not address the command-fifo as for example any FT8_mem...() function. +*/ +//---------------------------- +void FT8_start_cmd_burst(void) +{ + uint32_t ftAddress; + + cmd_burst = 42; + ftAddress = FT8_RAM_CMD + eve_cmdOffset; + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE); + _spi_transfer_start(eve_spi, 24, 24); +} + +//-------------------------- +void FT8_end_cmd_burst(void) +{ + cmd_burst = 0; + spi_lobo_device_deselect(eve_spi); +} + +// Begin a coprocessor command +//---------------------------------- +void FT8_start_cmd(uint32_t command) +{ + uint32_t ftAddress; + + uint32_t wd = command & 0xff; + wd |= (uint32_t)((command >> 8) & 0xff); + wd |= (uint32_t)((command >> 16) & 0xff); + wd |= (uint32_t)((command >> 24) & 0xff); + + if (cmd_burst == 0) { + ftAddress = FT8_RAM_CMD + eve_cmdOffset; + if (spi_lobo_device_select(eve_spi, 0)) return; + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE); + _spi_transfer_start(eve_spi, 24, 24); // send address + } + + eve_spi->host->hw->data_buf[0] = wd; + _spi_transfer_start(eve_spi, 32, 32); + + FT8_inc_cmdoffset(4); // update the command-ram pointer +} + + +/* === generic function for all commands that have no arguments and all display-list specific control words === + * + examples: + FT8_cmd_dl(CMD_DLSTART); + FT8_cmd_dl(CMD_SWAP); + FT8_cmd_dl(CMD_SCREENSAVER); + FT8_cmd_dl(LINE_WIDTH(1*16)); + FT8_cmd_dl(VERTEX2F(0,0)); + FT8_cmd_dl(DL_BEGIN | FT8_RECTS); + */ +//------------------------------- +void FT8_cmd_dl(uint32_t command) +{ + FT8_start_cmd(command); + if (cmd_burst == 0) { + spi_lobo_device_deselect(eve_spi); + } +} + + +// Write a string to coprocessor memory in context of a command +// no chip-select, just plain spi-transfers +//------------------------------------- +void FT8_write_string(const char *text) +{ + uint8_t textlen = strlen(text); + uint8_t padding = 0; + + spi_lobo_transaction_t t; + memset(&t, 0, sizeof(t)); //Zero out the transaction + + t.length = textlen * 8; + t.tx_buffer = text; + t.rxlength = 0; + t.rx_buffer = NULL; + + spi_lobo_transfer_data(eve_spi, &t); // Send using direct mode + + padding = strlen(text) % 4; /* 0, 1, 2 or 3 */ + padding = 4-padding; /* 4, 3, 2, 1 */ + + eve_spi->host->hw->data_buf[0] = 0; + _spi_transfer_start(eve_spi, padding * 8, 0); + + FT8_inc_cmdoffset(textlen + padding); +} + +// ============================================ +// ==== Commands to draw graphics objects: ==== +// ============================================ + +//------------------------------------------------------------------------------------------------------------------------------------------- +static void FT8_send_params(int16_t p1, int16_t p2, int16_t p3, uint16_t p4, uint16_t p5, uint16_t p6, uint16_t p7, uint16_t p8, uint8_t len) +{ + uint32_t wd = (uint32_t)(p1 & 0xFF); + wd |= (uint32_t)(p1 & 0xFF00); + wd |= (uint32_t)((p2 & 0xFF) << 16); + wd |= (uint32_t)((p2 & 0xFF00) << 16); + eve_spi->host->hw->data_buf[0] = wd; + if (len < 4) goto send; + + wd = (uint32_t)(p3 & 0xFF); + wd |= (uint32_t)(p3 & 0xFF00); + wd |= (uint32_t)((p4 & 0xFF) << 16); + wd |= (uint32_t)((p4 & 0xFF00) << 16); + eve_spi->host->hw->data_buf[1] = wd; + if (len < 6) goto send; + + wd = (uint32_t)(p5 & 0xFF); + wd |= (uint32_t)(p5 & 0xFF00); + wd |= (uint32_t)((p6 & 0xFF) << 16); + wd |= (uint32_t)((p6 & 0xFF00) << 16); + eve_spi->host->hw->data_buf[2] = wd; + if (len < 8) goto send; + + wd = (uint32_t)(p7 & 0xFF); + wd |= (uint32_t)(p7 & 0xFF00); + wd |= (uint32_t)((p8 & 0xFF) << 16); + wd |= (uint32_t)((p8 & 0xFF00) << 16); + eve_spi->host->hw->data_buf[2] = wd; + +send: + _spi_transfer_start(eve_spi, len*16, len*16); // send + + FT8_inc_cmdoffset(len * 2); +} + +//--------------------------------------------------------------------------------- +static void FT8_send_long(uint32_t val1, uint32_t val2, uint32_t val3, uint8_t len) +{ + uint32_t wd = (uint32_t)(val1 & 0xFF); + wd |= (uint32_t)((val1 >> 8) & 0xFF); + wd |= (uint32_t)((val1 >> 16) & 0xFF); + wd |= (uint32_t)((val1 >> 24) & 0xFF); + eve_spi->host->hw->data_buf[0] = wd; + if (len < 2) goto send; + + wd = (uint32_t)(val2 & 0xFF); + wd |= (uint32_t)((val2 >> 8) & 0xFF); + wd |= (uint32_t)((val2 >> 16) & 0xFF); + wd |= (uint32_t)((val2 >> 24) & 0xFF); + eve_spi->host->hw->data_buf[1] = wd; + if (len < 3) goto send; + + wd = (uint32_t)(val3 & 0xFF); + wd |= (uint32_t)((val3 >> 8) & 0xFF); + wd |= (uint32_t)((val3 >> 16) & 0xFF); + wd |= (uint32_t)((val3 >> 24) & 0xFF); + eve_spi->host->hw->data_buf[2] = wd; + +send: + _spi_transfer_start(eve_spi, len*32, len*32); // send + + FT8_inc_cmdoffset(len * 4); +} + +// Draw text +//----------------------------------------------------------------------------------------- +void FT8_cmd_text(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text) +{ + FT8_start_cmd(CMD_TEXT); + FT8_send_params(x0, y0, font, options, 0, 0, 0, 0, 4); + FT8_write_string(text); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +// Draw a button with text +//------------------------------------------------------------------------------------------------------------------- +void FT8_cmd_button(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text) +{ + FT8_start_cmd(CMD_BUTTON); + FT8_send_params(x0, y0, w0, h0, font, options, 0, 0, 6); + FT8_write_string(text); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +// Draw a clock +//---------------------------------------------------------------------------------------------------------------------------------------------- +void FT8_cmd_clock(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t hours, uint16_t minutes, uint16_t seconds, uint16_t millisecs) +{ + FT8_start_cmd(CMD_CLOCK); + FT8_send_params(x0, y0, r0, options, hours, minutes, seconds, millisecs, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------- +void FT8_cmd_bgcolor(uint32_t color) +{ + FT8_start_cmd(CMD_BGCOLOR); + FT8_send_long(color, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------- +void FT8_cmd_fgcolor(uint32_t color) +{ + FT8_start_cmd(CMD_FGCOLOR); + FT8_send_long(color, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------------ +void FT8_cmd_gradcolor(uint32_t color) +{ + FT8_start_cmd(CMD_GRADCOLOR); + FT8_send_long(color, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------------------------------------------------------------------------------------------------------------ +void FT8_cmd_gauge(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range) +{ + FT8_start_cmd(CMD_GAUGE); + FT8_send_params(x0, y0, r0, options, major, minor, val, range, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------------------------------------------------------------------------- +void FT8_cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1) +{ + FT8_start_cmd(CMD_GRADIENT); + FT8_send_params(x0, y0, (uint16_t)rgb0, (uint16_t)(rgb0 >> 16), x1, y1, (uint16_t)rgb1, (uint16_t)(rgb1 >> 16), 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//----------------------------------------------------------------------------------------------------------------- +void FT8_cmd_keys(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text) +{ + FT8_start_cmd(CMD_KEYS); + + FT8_send_params(x0, y0, w0, h0, font, options, 0, 0, 6); + FT8_write_string(text); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------------------------------------------------------------------------------------------- +void FT8_cmd_progress(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t range) +{ + FT8_start_cmd(CMD_PROGRESS); + FT8_send_params(x0, y0, w0, h0, options, val, range, 0, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//----------------------------------------------------------------------------------------------------------------------------------- +void FT8_cmd_scrollbar(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t size, uint16_t range) +{ + FT8_start_cmd(CMD_SCROLLBAR); + FT8_send_params(x0, y0, w0, h0, options, val, size, range, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +void FT8_cmd_slider(int16_t x1, int16_t y1, int16_t w1, int16_t h1, uint16_t options, uint16_t val, uint16_t range) +{ + FT8_start_cmd(CMD_SLIDER); + FT8_send_params(x1, y1, w1, h1, options, val, range, 0, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//----------------------------------------------------------------------------------- +void FT8_cmd_dial(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t val) +{ + FT8_start_cmd(CMD_DIAL); + FT8_send_params(x0, y0, r0, options, val, 0, 0, 0, 6); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//----------------------------------------------------------------------------------------------------------------------- +void FT8_cmd_toggle(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text) +{ + FT8_start_cmd(CMD_TOGGLE); + FT8_send_params(x0, y0, w0, font, options, state, 0, 0, 6); + FT8_write_string(text); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +#ifdef FT8_81X_ENABLE +//--------------------------------- +void FT8_cmd_setbase(uint32_t base) +{ + FT8_start_cmd(CMD_SETBASE); + FT8_send_params((uint16_t)base, (uint16_t)(base >> 16), 0, 0, 0, 0, 0, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------------------------------------------------------- +void FT8_cmd_setbitmap(uint32_t addr, uint16_t fmt, uint16_t width, uint16_t height) +{ + FT8_start_cmd(CMD_SETBITMAP); + FT8_send_params((uint16_t)addr, (uint16_t)(addr >> 16), fmt, width, height, 0, 0, 0, 6); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} +#endif + +//----------------------------------------------------------------------------------------- +void FT8_cmd_number(int16_t x0, int16_t y0, int16_t font, uint16_t options, int32_t number) +{ + FT8_start_cmd(CMD_NUMBER); + FT8_send_params(x0, y0, font, options, (uint16_t)number, (uint16_t)(number >> 16), 0, 0, 6); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +// ======================================== +// ==== Commands to operate on memory: ==== +// ======================================== + +void FT8_cmd_memzero(uint32_t ptr, uint32_t num) +{ + FT8_start_cmd(CMD_MEMZERO); + FT8_send_long(ptr, num, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +void FT8_cmd_memset(uint32_t ptr, uint8_t value, uint32_t num) +{ + FT8_start_cmd(CMD_MEMSET); + FT8_send_long(ptr, (uint32_t)value, num, 3); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +/* +void FT8_cmd_memwrite(uint32_t dest, uint32_t num, const uint8_t *data) +{ + FT8_start_cmd(CMD_MEMWRITE); + + spi_transmit((uint8_t)(dest)); + spi_transmit((uint8_t)(dest >> 8)); + spi_transmit((uint8_t)(dest >> 16)); + spi_transmit((uint8_t)(dest >> 24)); + + spi_transmit((uint8_t)(num)); + spi_transmit((uint8_t)(num >> 8)); + spi_transmit((uint8_t)(num >> 16)); + spi_transmit((uint8_t)(num >> 24)); + + num = (num + 3)&(~3); + + for(count=0;count 0) + { + block_len = bytes_left>4000 ? 4000:bytes_left; + + ftAddress = FT8_RAM_CMD + eve_cmdOffset; + spi_lobo_device_select(eve_spi, 0); + + eve_spi->host->hw->data_buf[0] = FT8_address(ftAddress, MEM_WRITE); + _spi_transfer_start(eve_spi, 24, 24); // send address + + spi_flash_write(data, block_len); + spi_lobo_device_deselect(eve_spi); + + data += block_len; + bytes_left -= block_len; + FT8_cmd_execute(); + } + } +} + + +#ifdef FT8_81X_ENABLE +// this is meant to be called outside display-list building, +// does not support cmd-burst +//------------------------------------------------- +void FT8_cmd_mediafifo(uint32_t ptr, uint32_t size) +{ + FT8_start_cmd(CMD_MEDIAFIFO); + FT8_send_long(ptr, size, 0, 2); + + spi_lobo_device_deselect(eve_spi); +} +#endif + + +// =========================================================== +// ==== Commands for setting the bitmap transform matrix: ==== +// =========================================================== + +//-------------------------------------------- +void FT8_cmd_translate(int32_t tx, int32_t ty) +{ + FT8_start_cmd(CMD_TRANSLATE); + FT8_send_long(tx, ty, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//---------------------------------------- +void FT8_cmd_scale(int32_t sx, int32_t sy) +{ + FT8_start_cmd(CMD_SCALE); + FT8_send_long(sx, sy, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------ +void FT8_cmd_rotate(int32_t ang) +{ + FT8_start_cmd(CMD_ROTATE); + FT8_send_long(ang, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +/* + * the description in the programmers guide is strange for this function + while it is named *get*matrix, parameters 'a' to 'f' are supplied to + the function and described as "output parameter" + best guess is that this one allows to setup the matrix coefficients manually + instead automatically like with _translate, _scale and _rotate + if this assumption is correct it rather should be named cmd_setupmatrix() + */ +//-------------------------------------------------------------------------------------- +void FT8_cmd_getmatrix(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f) +{ + FT8_start_cmd(CMD_SETMATRIX); + FT8_send_long(a, b, c, 3); + FT8_send_long(d, e, f, 3); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +// ========================= +// ==== Other commands: ==== +// ========================= + +//-------------------------- +void FT8_cmd_calibrate(void) +{ + FT8_start_cmd(CMD_CALIBRATE); + FT8_send_long(0, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//--------------------------------- +void FT8_cmd_interrupt(uint32_t ms) +{ + FT8_start_cmd(CMD_INTERRUPT); + FT8_send_long(ms, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +#ifdef FT8_81X_ENABLE +//--------------------------------------------------- +void FT8_cmd_romfont(uint32_t font, uint32_t romslot) +{ + FT8_start_cmd(CMD_ROMFONT); + FT8_send_long(font, romslot & 0xFFFF, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} +#endif + +//----------------------------------------------- +void FT8_cmd_setfont(uint32_t font, uint32_t ptr) +{ + FT8_start_cmd(CMD_SETFONT); + FT8_send_long(font, ptr, 0, 2); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +#ifdef FT8_81X_ENABLE +//-------------------------------------------------------------------- +void FT8_cmd_setfont2(uint32_t font, uint32_t ptr, uint32_t firstchar) +{ + FT8_start_cmd(CMD_SETFONT2); + FT8_send_long(font, ptr, firstchar, 3); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//-------------------------------- +void FT8_cmd_setrotate(uint32_t r) +{ + FT8_start_cmd(CMD_SETROTATE); + FT8_send_long(r, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//-------------------------------------- +void FT8_cmd_setscratch(uint32_t handle) +{ + FT8_start_cmd(CMD_SETSCRATCH); + FT8_send_long(handle, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} +#endif + +//-------------------------------------------------------------------------------------------------- +void FT8_cmd_sketch(int16_t x0, int16_t y0, uint16_t w0, uint16_t h0, uint32_t ptr, uint16_t format) +{ + FT8_start_cmd(CMD_SKETCH); + FT8_send_params(x0, y0, w0, h0, (uint16_t)ptr, (uint16_t)(ptr >> 16), 0, 0, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//--------------------------------- +void FT8_cmd_snapshot(uint32_t ptr) +{ + FT8_start_cmd(CMD_SNAPSHOT); + FT8_send_long(ptr, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +#ifdef FT8_81X_ENABLE +//------------------------------------------------------------------------------------------------ +void FT8_cmd_snapshot2(uint32_t fmt, uint32_t ptr, int16_t x0, int16_t y0, int16_t w0, int16_t h0) +{ + FT8_start_cmd(CMD_SNAPSHOT2); + FT8_send_params((uint16_t)fmt, (uint16_t)(fmt >> 16), (uint16_t)ptr, (uint16_t)(ptr >> 16), x0, y0, w0, h0, 8); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} +#endif + +//-------------------------------------------------------------------------- +void FT8_cmd_spinner(int16_t x0, int16_t y0, uint16_t style, uint16_t scale) +{ + FT8_start_cmd(CMD_SPINNER); + FT8_send_params(x0, y0, style, scale, 0, 0, 0, 0, 4); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//----------------------------------------------------------------------------- +void FT8_cmd_track(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t tag) +{ + FT8_start_cmd(CMD_TRACK); + FT8_send_params(x0, y0, w0, h0, tag, 0, 0, 0, 6); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +// ==================================================================== +// ==== Commands that return values by writing to the command-fifo ==== +// ==================================================================== + + +/* + * This is handled by having this functions return the offset address on the command-fifo from + * which the results can be fetched after execution: FT8_memRead32(FT8_RAM_CMD + offset) + * + * Note: yes, these are different than the functions in the Programmers Guide from FTDI, + this is because I have no idea why anyone would want to pass "result" as an actual argument to these functions + when this only marks the offset the command-processor is writing to, + it may even be okay to not transfer anything at all, + just advance the offset by 4 bytes + + * Example of using FT8_cmd_memcrc: + + offset = FT8_cmd_memcrc(my_ptr_to_some_memory_region, some_amount_of_bytes); + FT8_cmd_execute(); + crc32 = FT8_memRead32(FT8_RAM_CMD + offset); + +*/ + +//------------------------------------------------- +uint16_t FT8_cmd_memcrc(uint32_t ptr, uint32_t num) +{ + uint16_t offset; + + FT8_start_cmd(CMD_MEMCRC); + FT8_send_long(ptr, num, 0, 3); + offset = eve_cmdOffset - 4; + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); + + return offset; +} + +//--------------------------- +uint16_t FT8_cmd_getptr(void) +{ + uint16_t offset; + + FT8_start_cmd(CMD_GETPTR); + FT8_send_long(0, 0, 0, 1); + offset = eve_cmdOffset - 4; + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); + + return offset; +} + +//------------------------------------ +uint16_t FT8_cmd_regread(uint32_t ptr) +{ + uint16_t offset; + + FT8_start_cmd(CMD_REGREAD); + FT8_send_long(ptr, 0, 0, 2); + offset = eve_cmdOffset - 4; + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); + + return offset; +} + + +/* + * Be aware that this returns the first offset pointing to "width", + * in order to also read "height" you need to: + + offset = FT8_cmd_getprops(my_last_picture_pointer); + FT8_cmd_execute(); + width = FT8_memRead32(FT8_RAM_CMD + offset); + offset += 4; + offset &= 0x0fff; + height = FT8_memRead32(FT8_RAM_CMD + offset); +*/ + +//------------------------------------- +uint16_t FT8_cmd_getprops(uint32_t ptr) +{ + uint16_t offset; + + FT8_start_cmd(CMD_REGREAD); + FT8_send_long(ptr, 0, 0, 3); + offset = eve_cmdOffset - 8; + eve_cmdOffset -= 4; + eve_cmdOffset &= 0x0fff; + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); + + return offset; +} + +// ======================================================================================================================================== +// ==== meta-commands, sequences of several display-list entries condensed into simpler to use functions at the price of some overhead ==== +// ======================================================================================================================================== + +//------------------------------------------------------- +void FT8_cmd_point(int16_t x0, int16_t y0, uint16_t size) +{ + uint32_t calc1, calc2; + + FT8_start_cmd((DL_BEGIN | FT8_POINTS)); + + calc1 = POINT_SIZE(size*16); + calc2 = VERTEX2F(x0 * 16, y0 * 16); + FT8_send_long(calc1, calc2, DL_END, 3); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//------------------------------------------------------------------------------- +void FT8_cmd_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t width) +{ + uint32_t calc1, calc2,calc3; + + FT8_start_cmd((DL_BEGIN | FT8_LINES)); + + calc1 = LINE_WIDTH(width * 16); + calc2 = VERTEX2F(x0 * 16, y0 * 16); + calc3 = VERTEX2F(x1 * 16, y1 * 16); + FT8_send_long(calc1, calc2, calc3, 3); + FT8_send_long(DL_END, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + +//-------------------------------------------------------------------------------- +void FT8_cmd_rect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t corner) +{ + uint32_t calc1, calc2, calc3; + + FT8_start_cmd((DL_BEGIN | FT8_RECTS)); + + calc1 = LINE_WIDTH(corner * 16); + calc2 = VERTEX2F(x0 * 16, y0 * 16); + calc3 = VERTEX2F(x1 * 16, y1 * 16); + FT8_send_long(calc1, calc2, calc3, 3); + FT8_send_long(DL_END, 0, 0, 1); + + if (cmd_burst == 0) spi_lobo_device_deselect(eve_spi); +} + + +// ============================================================================================ +// ==== init, has to be executed with the SPI setup to 11 MHz or less as required by FT8xx ==== +// ============================================================================================ + +uint8_t FT8_init(void) +{ + uint8_t gpio; + uint8_t chipid; + uint8_t timeout = 0; + + //FT8_pdn_set(); + vTaskDelay(10 / portTICK_RATE_MS); // minimum time for power-down is 5ms + //FT8_pdn_clear(); + vTaskDelay(21 / portTICK_RATE_MS); // minimum time to allow from rising PD_N to first access is 20ms + + // FT8_cmdWrite(FT8_CORERST); // reset, only required for warmstart if PowerDown line is not used + + if (FT8_HAS_CRYSTAL != 0) FT8_cmdWrite(FT8_CLKEXT); // setup FT8xx for external clock + else FT8_cmdWrite(FT8_CLKINT); // setup FT8xx for internal clock + + FT8_cmdWrite(FT8_ACTIVE); // start FT8xx + + chipid = FT8_memRead8(REG_ID); // Read ID register + // if chip id is not 0x7c, continue to read it until it is, + // FT81x may need a moment for it's power on self test + while(chipid != 0x7C) { + chipid = FT8_memRead8(REG_ID); + vTaskDelay(2 / portTICK_RATE_MS); + timeout++; + if (timeout > 100) return 0; + } + + FT8_memWrite8(REG_PCLK, 0x00); // set PCLK to zero - don't clock the LCD until later + FT8_memWrite8(REG_PWM_DUTY, 10); // turn off backlight + + // *** Initialize Display + FT8_memWrite16(REG_HSIZE, FT8_HSIZE); // active display width + FT8_memWrite16(REG_HCYCLE, FT8_HCYCLE); // total number of clocks per line, including front/back porch + FT8_memWrite16(REG_HOFFSET, FT8_HOFFSET); // start of active line + FT8_memWrite16(REG_HSYNC0, FT8_HSYNC0); // start of horizontal sync pulse + FT8_memWrite16(REG_HSYNC1, FT8_HSYNC1); // end of horizontal sync pulse + FT8_memWrite16(REG_VSIZE, FT8_VSIZE); // active display height + FT8_memWrite16(REG_VCYCLE, FT8_VCYCLE); // total number of lines per screen, incl pre/post + FT8_memWrite16(REG_VOFFSET, FT8_VOFFSET); // start of active screen + FT8_memWrite16(REG_VSYNC0, FT8_VSYNC0); // start of vertical sync pulse + FT8_memWrite16(REG_VSYNC1, FT8_VSYNC1); // end of vertical sync pulse + FT8_memWrite8(REG_SWIZZLE, FT8_SWIZZLE); // FT8xx output to LCD - pin order + FT8_memWrite8(REG_PCLK_POL, FT8_PCLKPOL); /// LCD data is clocked in on this PCLK edge + // Don't set PCLK yet - wait for just after the first display list + + // ** Configure Touch + FT8_memWrite8(REG_TOUCH_MODE, FT8_TMODE_CONTINUOUS); // enable touch + FT8_memWrite16(REG_TOUCH_RZTHRESH, FT8_TOUCH_RZTHRESH); // eliminate any false touches + + // ** Configure Audio - not used, so disable it + FT8_memWrite8(REG_VOL_PB, 0x00); // turn recorded audio volume down + // FT8_memWrite8(REG_VOL_SOUND, 0xff); // turn synthesizer volume on + FT8_memWrite8(REG_VOL_SOUND, 0x00); // turn synthesizer volume off + FT8_memWrite16(REG_SOUND, 0x6000); // set synthesizer to mute + + FT8_memWrite32(FT8_RAM_DL, DL_CLEAR_RGB); + FT8_memWrite32(FT8_RAM_DL + 4, (DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG)); + FT8_memWrite32(FT8_RAM_DL + 8, DL_DISPLAY); // end of display list + FT8_memWrite32(REG_DLSWAP, FT8_DLSWAP_FRAME); + + // nothing is being displayed yet... the pixel clock is still 0x00 + + gpio = FT8_memRead8(REG_GPIO_DIR); + // set DISP to Output although it always is output, set GPIO1 to Output - Audio Enable on VM800B + gpio |= 0x82; + FT8_memWrite8(REG_GPIO_DIR, gpio); + + gpio = FT8_memRead8(REG_GPIO); // read the FT8xx GPIO register for a read/modify/write operation + // gpio |= 0x82; // set bit 7 of FT8xx GPIO register (DISP), set GPIO1 to High to enable Audio - others are inputs + gpio |= 0x80; // set bit 7 of FT8xx GPIO register (DISP), others are inputs + FT8_memWrite8(REG_GPIO, gpio); // enable the DISP signal to the LCD panel + FT8_memWrite8(REG_PCLK, FT8_PCLK); // now start clocking data to the LCD panel + + FT8_memWrite8(REG_PWM_DUTY, 70); // turn on backlight + + vTaskDelay(2 / portTICK_RATE_MS); // just to be safe + + while (FT8_busy() == 1) ; + + FT8_get_cmdoffset(); + return 1; +} + +#endif // CONFIG_MICROPY_USE_EVE diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.h b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.h new file mode 100644 index 0000000..c68955a --- /dev/null +++ b/MicroPython_BUILD/components/micropython/esp32/libs/eve/FT8_commands.h @@ -0,0 +1,322 @@ +/* + * This file is part of the ESP32 MicroPython project, https://github.com/loboris/MicroPython_ESP32_psRAM_LoBo + * + * Contains Functions for using the FT8xx + * === Ported from https://github.com/RudolphRiedel/FT800-FT813 === + * + * The MIT License (MIT) + * + * Copyright (c) 2017 Rudolph Riedel + * Copyright (c) 2018 LoBo (https://github.com/loboris) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + + +#ifndef FT8_COMMANDS_H_ +#define FT8_COMMANDS_H_ + +#include + +/* switch over to FT81x */ +#define FT8_81X_ENABLE + + +/* select the settings for the TFT attached */ +#if 0 + #define FT8_VM800B35A + #define FT8_VM800B43A + #define FT8_VM800B50A + #define FT8_FT810CB_HY50HD + #define FT8_FT811CB_HY50HD + #define FT8_ET07 + #define FT8_RVT70AQ +#endif + +#define FT8_FT810CB_HY50HD + + +/* some pre-definded colors */ +#define RED 0xff0000UL +#define ORANGE 0xffa500UL +#define GREEN 0x00ff00UL +#define BLUE 0x0000ffUL +#define YELLOW 0xffff00UL +/*#define PINK 0xff00ffUL*/ +#define PURPLE 0x800080UL +#define WHITE 0xffffffUL +#define BLACK 0x000000UL + + +/* VM800B35A: FT800 320x240 3.5" FTDI */ +#ifdef FT8_VM800B35A +#define FT8_VSYNC0 (0L) /* Tvf Vertical Front Porch */ +#define FT8_VSYNC1 (2L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */ +#define FT8_VOFFSET (13L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */ +#define FT8_VCYCLE (263L) /* Tv Total number of lines (visible and non-visible) (in lines) */ +#define FT8_VSIZE (240L) /* Tvd Number of visible lines (in lines) - display height */ +#define FT8_HSYNC0 (0L) /* Thf Horizontal Front Porch */ +#define FT8_HSYNC1 (10L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */ +#define FT8_HOFFSET (70L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */ +#define FT8_HCYCLE (408L) /* Th Total length of line (visible and non-visible) (in PCLKs) */ +#define FT8_HSIZE (320L) /* Thd Length of visible part of line (in PCLKs) - display width */ +#define FT8_PCLKPOL (0L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */ +#define FT8_SWIZZLE (2L) /* Defines the arrangement of the RGB pins of the FT800 */ +#define FT8_PCLK (8L) /* 48MHz / REG_PCLK = PCLK frequency */ +#define FT8_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */ +#define FT8_HAS_CRYSTAL 1 /* use external crystal or internal oscillator? */ +#endif + +/* VM800B43A: FT800 480x272 4.3" FTDI */ +#ifdef FT8_VM800B43A +#define FT8_VSYNC0 (0L) +#define FT8_VSYNC1 (10L) +#define FT8_VOFFSET (12L) +#define FT8_VCYCLE (292L) +#define FT8_VSIZE (272L) +#define FT8_HSYNC0 (0L) +#define FT8_HSYNC1 (41L) +#define FT8_HOFFSET (43L) +#define FT8_HCYCLE (548L) +#define FT8_HSIZE (480L) +#define FT8_PCLKPOL (1L) +#define FT8_SWIZZLE (0L) +#define FT8_PCLK (5L) +#define FT8_TOUCH_RZTHRESH (1200L) +#define FT8_HAS_CRYSTAL 1 +#endif + +/* VM800B50A: FT800 480x272 5.0" FTDI */ +#ifdef FT8_VM800B50A +#define FT8_VSYNC0 (0L) +#define FT8_VSYNC1 (10L) +#define FT8_VOFFSET (12L) +#define FT8_VCYCLE (292L) +#define FT8_VSIZE (272L) +#define FT8_HSYNC0 (0L) +#define FT8_HSYNC1 (41L) +#define FT8_HOFFSET (43L) +#define FT8_HCYCLE (548L) +#define FT8_HSIZE (480L) +#define FT8_PCLKPOL (1L) +#define FT8_SWIZZLE (0L) +#define FT8_PCLK (5L) +#define FT8_TOUCH_RZTHRESH (1200L) +#define FT8_HAS_CRYSTAL 1 +#endif + +/* FT810CB-HY50HD: FT810 800x480 5" HAOYU */ +#ifdef FT8_FT810CB_HY50HD +#define FT8_VSYNC0 (0L) +#define FT8_VSYNC1 (2L) +#define FT8_VOFFSET (13L) +#define FT8_VCYCLE (525L) +#define FT8_VSIZE (480L) +#define FT8_HSYNC0 (0L) +#define FT8_HSYNC1 (20L) +#define FT8_HOFFSET (64L) +#define FT8_HCYCLE (952L) +#define FT8_HSIZE (800L) +#define FT8_PCLKPOL (1L) +#define FT8_SWIZZLE (0L) +#define FT8_PCLK (2L) +#define FT8_TOUCH_RZTHRESH (2000L) /* touch-sensitivity */ +#define FT8_HAS_CRYSTAL 1 +#endif + +/* FT811CB-HY50HD: FT811 800x480 5" HAOYU */ +#ifdef FT8_FT811CB_HY50HD +#define FT8_VSYNC0 (0L) +#define FT8_VSYNC1 (2L) +#define FT8_VOFFSET (13L) +#define FT8_VCYCLE (525L) +#define FT8_VSIZE (480L) +#define FT8_HSYNC0 (0L) +#define FT8_HSYNC1 (20L) +#define FT8_HOFFSET (64L) +#define FT8_HCYCLE (952L) +#define FT8_HSIZE (800L) +#define FT8_PCLKPOL (1L) +#define FT8_SWIZZLE (0L) +#define FT8_PCLK (2L) +#define FT8_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */ +#define FT8_HAS_CRYSTAL 1 +#endif + +/* some test setup */ +#ifdef FT8_800x480x +#define FT8_VSYNC0 (0L) /* Tvf Vertical Front Porch */ +#define FT8_VSYNC1 (10L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */ +#define FT8_VOFFSET (35L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */ +#define FT8_VCYCLE (516L) /* Tv Total number of lines (visible and non-visible) (in lines) */ +#define FT8_VSIZE (480L) /* Tvd Number of visible lines (in lines) - display height */ +#define FT8_HSYNC0 (0L) /* (40L) // Thf Horizontal Front Porch */ +#define FT8_HSYNC1 (88L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */ +#define FT8_HOFFSET (169L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */ +#define FT8_HCYCLE (969L) /* Th Total length of line (visible and non-visible) (in PCLKs) */ +#define FT8_HSIZE (800L) /* Thd Length of visible part of line (in PCLKs) - display width */ +#define FT8_PCLKPOL (1L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */ +#define FT8_SWIZZLE (0L) /* Defines the arrangement of the RGB pins of the FT800 */ +#define FT8_PCLK (2L) /* 60MHz / REG_PCLK = PCLK frequency 30 MHz */ +#define FT8_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */ +#define FT8_HAS_CRYSTAL 1 +#endif + +/* G-ET0700G0DM6 800x480 7" Glyn, untested */ +#ifdef FT8_ET07 +#define FT8_VSYNC0 (0L) +#define FT8_VSYNC1 (2L) +#define FT8_VOFFSET (35L) +#define FT8_VCYCLE (525L) +#define FT8_VSIZE (480L) +#define FT8_HSYNC0 (0L) +#define FT8_HSYNC1 (128L) +#define FT8_HOFFSET (203L) +#define FT8_HCYCLE (1056L) +#define FT8_HSIZE (800L) +#define FT8_PCLKPOL (1L) +#define FT8_SWIZZLE (0L) +#define FT8_PCLK (2L) +#define FT8_TOUCH_RZTHRESH (1200L) +#define FT8_HAS_CRYSTAL 0 /* no idea if these come with a crystal populated or not */ +#endif + +/* RVT70AQxxxxxx 800x480 7" Riverdi, various options, FT812/FT813, tested with RVT70UQFNWC0x */ +#ifdef FT8_RVT70AQ +#define FT8_VSYNC0 (0L) /* Tvf Vertical Front Porch */ +#define FT8_VSYNC1 (10L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */ +#define FT8_VOFFSET (23L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */ +#define FT8_VCYCLE (525L) /* Tv Total number of lines (visible and non-visible) (in lines) */ +#define FT8_VSIZE (480L) /* Tvd Number of visible lines (in lines) - display height */ +#define FT8_HSYNC0 (0L) /* Thf Horizontal Front Porch */ +#define FT8_HSYNC1 (10L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */ +#define FT8_HOFFSET (46L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */ +#define FT8_HCYCLE (1056L) /* Th Total length of line (visible and non-visible) (in PCLKs) */ +#define FT8_HSIZE (800L) /* Thd Length of visible part of line (in PCLKs) - display width */ +#define FT8_PCLKPOL (1L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */ +#define FT8_SWIZZLE (0L) /* Defines the arrangement of the RGB pins of the FT800 */ +#define FT8_PCLK (2L) /* 60MHz / REG_PCLK = PCLK frequency 30 MHz */ +#define FT8_TOUCH_RZTHRESH (1800L) /* touch-sensitivity */ +#define FT8_HAS_CRYSTAL 0 +#endif + +// ---------------------------------------------------------------------------------- + +extern uint16_t eve_cmdOffset; + +void FT8_cmdWrite(uint8_t data); + +uint8_t FT8_memRead8(uint32_t ftAddress); +uint16_t FT8_memRead16(uint32_t ftAddress); +uint32_t FT8_memRead32(uint32_t ftAddress); +void FT8_memWrite8(uint32_t ftAddress, uint8_t ftData8); +void FT8_memWrite16(uint32_t ftAddress, uint16_t ftData16); +void FT8_memWrite32(uint32_t ftAddress, uint32_t ftData32); +void FT8_memWrite_flash_buffer(uint32_t ftAddress, const uint8_t *data, uint16_t len); +uint8_t FT8_busy(void); +void FT8_cmd_dl(uint32_t command); + +void FT8_get_cmdoffset(void); +uint32_t FT8_get_touch_tag(void); +void FT8_cmd_start(void); +void FT8_cmd_execute(void); + +void FT8_start_cmd_burst(void); +void FT8_end_cmd_burst(void); + +/* commands to draw graphics objects: */ +void FT8_cmd_text(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text); +void FT8_cmd_button(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text); +void FT8_cmd_clock(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t hours, uint16_t minutes, uint16_t seconds, uint16_t millisecs); +void FT8_cmd_bgcolor(uint32_t color); +void FT8_cmd_fgcolor(uint32_t color); +void FT8_cmd_gradcolor(uint32_t color); +void FT8_cmd_gauge(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range); +void FT8_cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1); +void FT8_cmd_keys(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text); +void FT8_cmd_progress(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t range); +void FT8_cmd_scrollbar(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t size, uint16_t range); +void FT8_cmd_slider(int16_t x1, int16_t y1, int16_t w1, int16_t h1, uint16_t options, uint16_t val, uint16_t range); +void FT8_cmd_dial(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t val); +void FT8_cmd_toggle(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text); +void FT8_cmd_number(int16_t x0, int16_t y0, int16_t font, uint16_t options, int32_t number); + +#ifdef FT8_81X_ENABLE +void FT8_cmd_setbase(uint32_t base); +void FT8_cmd_setbitmap(uint32_t addr, uint16_t fmt, uint16_t width, uint16_t height); +#endif + +/* commands to operate on memory: */ +void FT8_cmd_memzero(uint32_t ptr, uint32_t num); +void FT8_cmd_memset(uint32_t ptr, uint8_t value, uint32_t num); +/*(void FT8_cmd_memwrite(uint32_t dest, uint32_t num, const uint8_t *data); */ +void FT8_cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num); +void FT8_cmd_append(uint32_t ptr, uint32_t num); + + +/* commands for loading image data into FT8xx memory: */ +void FT8_cmd_inflate(uint32_t ptr, const uint8_t *data, uint16_t len); +void FT8_cmd_loadimage(uint32_t ptr, uint32_t options, const uint8_t *data, uint16_t len); +#ifdef FT8_81X_ENABLE +void FT8_cmd_mediafifo(uint32_t ptr, uint32_t size); +#endif + +/* commands for setting the bitmap transform matrix: */ +void FT8_cmd_translate(int32_t tx, int32_t ty); +void FT8_cmd_scale(int32_t sx, int32_t sy); +void FT8_cmd_rotate(int32_t ang); +void FT8_cmd_getmatrix(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f); + + +/* other commands: */ +void FT8_cmd_calibrate(void); +void FT8_cmd_interrupt(uint32_t ms); +void FT8_cmd_setfont(uint32_t font, uint32_t ptr); +#ifdef FT8_81X_ENABLE +void FT8_cmd_romfont(uint32_t font, uint32_t romslot); +void FT8_cmd_setfont2(uint32_t font, uint32_t ptr, uint32_t firstchar); +void FT8_cmd_setrotate(uint32_t r); +void FT8_cmd_setscratch(uint32_t handle); +#endif +void FT8_cmd_sketch(int16_t x0, int16_t y0, uint16_t w0, uint16_t h0, uint32_t ptr, uint16_t format); +void FT8_cmd_snapshot(uint32_t ptr); +#ifdef FT8_81X_ENABLE +void FT8_cmd_snapshot2(uint32_t fmt, uint32_t ptr, int16_t x0, int16_t y0, int16_t w0, int16_t h0); +#endif +void FT8_cmd_spinner(int16_t x0, int16_t y0, uint16_t style, uint16_t scale); +void FT8_cmd_track(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t tag); + + +/* commands that return values by writing to the command-fifo */ +uint16_t FT8_cmd_memcrc(uint32_t ptr, uint32_t num); +uint16_t FT8_cmd_getptr(void); +uint16_t FT8_cmd_regread(uint32_t ptr); +uint16_t FT8_cmd_getprops(uint32_t ptr); + + +/* meta-commands, sequences of several display-list entries condensed into simpler to use functions at the price of some overhead */ +void FT8_cmd_point(int16_t x0, int16_t y0, uint16_t size); +void FT8_cmd_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t w0); +void FT8_cmd_rect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t corner); + + +/* startup FT8xx: */ +uint8_t FT8_init(void); + +#endif // FT8_COMMANDS_H_ diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/eve/LICENSE b/MicroPython_BUILD/components/micropython/esp32/libs/eve/LICENSE new file mode 100644 index 0000000..8864d4a --- /dev/null +++ b/MicroPython_BUILD/components/micropython/esp32/libs/eve/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/ftp.c b/MicroPython_BUILD/components/micropython/esp32/libs/ftp.c index 10c3f99..ef3f7ff 100644 --- a/MicroPython_BUILD/components/micropython/esp32/libs/ftp.c +++ b/MicroPython_BUILD/components/micropython/esp32/libs/ftp.c @@ -747,7 +747,8 @@ static void ftp_process_cmd (void) { if (result == E_FTP_RESULT_OK) { // bufptr is moved as commands are being popped ftp_cmd_index_t cmd = ftp_pop_command(&bufptr); - if (!ftp_data.loggin.passvalid && (cmd != E_FTP_CMD_USER && cmd != E_FTP_CMD_PASS && cmd != E_FTP_CMD_QUIT)) { + if (!ftp_data.loggin.passvalid && + ((cmd != E_FTP_CMD_USER) && (cmd != E_FTP_CMD_PASS) && (cmd != E_FTP_CMD_QUIT) && (cmd != E_FTP_CMD_FEAT))) { ftp_send_reply(332, NULL); return; } diff --git a/MicroPython_BUILD/components/micropython/esp32/libs/tft/tftspi.h b/MicroPython_BUILD/components/micropython/esp32/libs/tft/tftspi.h index 09a95c5..e7a0d39 100644 --- a/MicroPython_BUILD/components/micropython/esp32/libs/tft/tftspi.h +++ b/MicroPython_BUILD/components/micropython/esp32/libs/tft/tftspi.h @@ -456,6 +456,7 @@ static const uint8_t Rcmd3[] = { // ==== Public functions ========================================================= // == Low level functions; usually not used directly == + esp_err_t wait_trans_finish(uint8_t free_line); void disp_spi_transfer_cmd(int8_t cmd); void disp_spi_transfer_cmd_data(int8_t cmd, uint8_t *data, uint32_t len); diff --git a/MicroPython_BUILD/components/micropython/esp32/machine_uart.c b/MicroPython_BUILD/components/micropython/esp32/machine_uart.c index c8f1f5b..39c85b2 100644 --- a/MicroPython_BUILD/components/micropython/esp32/machine_uart.c +++ b/MicroPython_BUILD/components/micropython/esp32/machine_uart.c @@ -34,6 +34,7 @@ #include "py/runtime.h" #include "py/stream.h" #include "py/mperrno.h" +#include "py/mphal.h" #include "modmachine.h" typedef struct _machine_uart_obj_t { @@ -47,7 +48,8 @@ typedef struct _machine_uart_obj_t { int8_t rts; int8_t cts; uint16_t timeout; // timeout waiting for first char (in ms) - uint16_t timeout_char; // timeout waiting between chars (in ms) + uint16_t timeout_char; // timeout character + uint16_t buffer_size; } machine_uart_obj_t; STATIC const char *_parity_name[] = {"None", "1", "0"}; @@ -62,26 +64,28 @@ STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_pri machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in); uint32_t baudrate; uart_get_baudrate(self->uart_num, &baudrate); - mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, timeout=%u, timeout_char=%u)", + mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, timeout=%u, timeout_char=%u, buf_size=%u)", self->uart_num, baudrate, self->bits, _parity_name[self->parity], - self->stop, self->tx, self->rx, self->rts, self->cts, self->timeout, self->timeout_char); + self->stop, self->tx, self->rx, self->rts, self->cts, self->timeout, self->timeout_char, self->buffer_size); } +static const mp_arg_t allowed_args[] = { + { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_bits, MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, + { MP_QSTR_stop, MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, + { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, + { MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, + { MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, + { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, + { MP_QSTR_buffer_size, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, +}; + //-------------------------------------------------------------------------------------------------------------------------- STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { - enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_timeout, ARG_timeout_char }; - static const mp_arg_t allowed_args[] = { - { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_bits, MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} }, - { MP_QSTR_stop, MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, - { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, - { MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, - { MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_PIN_NO_CHANGE} }, - { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, - { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} }, - }; + enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_timeout, ARG_timeout_char, ARG_buffer_size }; mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)]; mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); @@ -245,6 +249,18 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, break; } + mp_map_t kw_args; + mp_map_init_fixed_table(&kw_args, n_kw, args + n_args); + + enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_timeout, ARG_timeout_char, ARG_buffer_size }; + mp_arg_val_t kargs[MP_ARRAY_SIZE(allowed_args)]; + mp_arg_parse_all(n_args-1, args+1, &kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, kargs); + + int bufsize = kargs[ARG_buffer_size].u_int; + if (bufsize < 256) bufsize = 256; + if (bufsize > 4096) bufsize = 4096; + self->buffer_size = bufsize; + // Remove any existing configuration uart_driver_delete(self->uart_num); @@ -253,13 +269,13 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, uart_param_config(self->uart_num, &uartcfg); // RX and TX buffers are currently hardcoded at 256 and 256 bytes respectively. - esp_err_t res = uart_driver_install(uart_num, 256, 0, 10, &UART_QUEUE[self->uart_num], 0); + //esp_err_t res = uart_driver_install(uart_num, 256, 0, 10, &UART_QUEUE[self->uart_num], 0); + esp_err_t res = uart_driver_install(uart_num, bufsize, 0, 0, NULL, 0); if (res != ESP_OK) { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) Error installing driver", uart_num)); } - mp_map_t kw_args; - mp_map_init_fixed_table(&kw_args, n_kw, args + n_args); + machine_uart_init_helper(self, n_args - 1, args + 1, &kw_args); // Make sure pins are connected. @@ -305,14 +321,22 @@ STATIC mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t siz return 0; } - TickType_t time_to_wait; + int bytes_read = 0; + mp_hal_set_wdt_tmo(); if (self->timeout == 0) { - time_to_wait = 0; - } else { - time_to_wait = pdMS_TO_TICKS(self->timeout); + bytes_read = uart_read_bytes(self->uart_num, buf_in, size, 0); + } + else { + int wait = self->timeout; + MP_THREAD_GIL_EXIT(); + while (wait > 0) { + bytes_read = uart_read_bytes(self->uart_num, buf_in, size, pdMS_TO_TICKS(10)); + if (bytes_read != 0) break; + mp_hal_reset_wdt(); + wait -= 10; + } + MP_THREAD_GIL_ENTER(); } - - int bytes_read = uart_read_bytes(self->uart_num, buf_in, size, time_to_wait); if (bytes_read < 0) { *errcode = MP_EAGAIN; diff --git a/MicroPython_BUILD/components/micropython/esp32/moddisplay.c b/MicroPython_BUILD/components/micropython/esp32/moddisplay.c index 0578447..169f310 100644 --- a/MicroPython_BUILD/components/micropython/esp32/moddisplay.c +++ b/MicroPython_BUILD/components/micropython/esp32/moddisplay.c @@ -27,6 +27,10 @@ * THE SOFTWARE. */ +#include "sdkconfig.h" + +#ifdef CONFIG_MICROPY_USE_DISPLAY + #include #include #include @@ -1407,3 +1411,4 @@ const mp_obj_module_t mp_module_display = { .globals = (mp_obj_dict_t*)&display_module_globals, }; +#endif // CONFIG_MICROPY_USE_DISPLAY diff --git a/MicroPython_BUILD/components/micropython/esp32/mpconfigport.h b/MicroPython_BUILD/components/micropython/esp32/mpconfigport.h index fe35ccb..88d33e2 100644 --- a/MicroPython_BUILD/components/micropython/esp32/mpconfigport.h +++ b/MicroPython_BUILD/components/micropython/esp32/mpconfigport.h @@ -219,7 +219,6 @@ extern const struct _mp_obj_module_t mp_module_usocket; extern const struct _mp_obj_module_t mp_module_machine; extern const struct _mp_obj_module_t mp_module_network; extern const struct _mp_obj_module_t mp_module_ymodem; -extern const struct _mp_obj_module_t mp_module_display; #ifdef CONFIG_MICROPY_USE_CURL extern const struct _mp_obj_module_t mp_module_curl; @@ -235,6 +234,13 @@ extern const struct _mp_obj_module_t mp_module_ssh; #define BUILTIN_MODULE_SSH #endif +#ifdef CONFIG_MICROPY_USE_DISPLAY +extern const struct _mp_obj_module_t mp_module_display; +#define BUILTIN_MODULE_DISPLAY { MP_OBJ_NEW_QSTR(MP_QSTR_display), (mp_obj_t)&mp_module_display }, +#else +#define BUILTIN_MODULE_DISPLAY +#endif + #ifdef CONFIG_MICROPY_USE_GSM extern const struct _mp_obj_module_t mp_module_gsm; #define BUILTIN_MODULE_GSM { MP_OBJ_NEW_QSTR(MP_QSTR_gsm), (mp_obj_t)&mp_module_gsm }, @@ -256,7 +262,7 @@ extern const struct _mp_obj_module_t mp_module_ota; { MP_OBJ_NEW_QSTR(MP_QSTR_machine), (mp_obj_t)&mp_module_machine }, \ { MP_OBJ_NEW_QSTR(MP_QSTR_network), (mp_obj_t)&mp_module_network }, \ { MP_OBJ_NEW_QSTR(MP_QSTR_ymodem), (mp_obj_t)&mp_module_ymodem }, \ - { MP_OBJ_NEW_QSTR(MP_QSTR_display), (mp_obj_t)&mp_module_display }, \ + BUILTIN_MODULE_DISPLAY \ BUILTIN_MODULE_CURL \ BUILTIN_MODULE_SSH \ BUILTIN_MODULE_GSM \ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip index b164e8c..21cc8ae 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32.zip differ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip index 75ca686..0f79851 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_all.zip differ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip index 15c8f71..0b09ac2 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_ota.zip differ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip index 2282cfd..f9f7c11 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram.zip differ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip index 9d3dbbe..367695d 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_all.zip differ diff --git a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip index cad316f..8c14f6b 100644 Binary files a/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip and b/MicroPython_BUILD/firmware/MicroPython_LoBo_esp32_psram_ota.zip differ diff --git a/MicroPython_BUILD/firmware/esp32/MicroPython.bin b/MicroPython_BUILD/firmware/esp32/MicroPython.bin index 8590e38..9c6069b 100644 Binary files a/MicroPython_BUILD/firmware/esp32/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin index 52989b0..aa36093 100644 Binary files a/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32/sdkconfig b/MicroPython_BUILD/firmware/esp32/sdkconfig index 6c89796..85f679d 100644 --- a/MicroPython_BUILD/firmware/esp32/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32/sdkconfig @@ -121,6 +121,8 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE= CONFIG_MICROPY_USE_WEBSOCKETS= +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE= CONFIG_MICROPY_USE_GSM= CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y diff --git a/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin index ef7d212..c8bc050 100644 Binary files a/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_all/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin index 4913237..eb5f8d7 100644 Binary files a/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_all/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_all/sdkconfig b/MicroPython_BUILD/firmware/esp32_all/sdkconfig index 0a4e2e1..d6193a9 100644 --- a/MicroPython_BUILD/firmware/esp32_all/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32_all/sdkconfig @@ -121,7 +121,9 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE=y CONFIG_MICROPY_USE_WEBSOCKETS=y -CONFIG_MICROPY_USE_GSM= +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE=n +CONFIG_MICROPY_USE_GSM=y CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y CONFIG_MICROPY_USE_CURL=y diff --git a/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin index cbfa2c5..fe00374 100644 Binary files a/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_ota/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin index b0807be..56c7d57 100644 Binary files a/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_ota/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_ota/sdkconfig b/MicroPython_BUILD/firmware/esp32_ota/sdkconfig index 47af6b8..2b32b4f 100644 --- a/MicroPython_BUILD/firmware/esp32_ota/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32_ota/sdkconfig @@ -122,6 +122,8 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE= CONFIG_MICROPY_USE_WEBSOCKETS= +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE= CONFIG_MICROPY_USE_GSM= CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y diff --git a/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin index 2c5db92..15e8318 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin index eae86d9..d2f7ec8 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram/sdkconfig b/MicroPython_BUILD/firmware/esp32_psram/sdkconfig index 99410b4..3bcb621 100644 --- a/MicroPython_BUILD/firmware/esp32_psram/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32_psram/sdkconfig @@ -121,6 +121,8 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE= CONFIG_MICROPY_USE_WEBSOCKETS= +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE= CONFIG_MICROPY_USE_GSM= CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y diff --git a/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin index 5655e4c..c86e4ec 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram_all/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin index 6bc27e7..a0d47e6 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram_all/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram_all/sdkconfig b/MicroPython_BUILD/firmware/esp32_psram_all/sdkconfig index 935b42a..1c582c2 100644 --- a/MicroPython_BUILD/firmware/esp32_psram_all/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32_psram_all/sdkconfig @@ -121,6 +121,8 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE=y CONFIG_MICROPY_USE_WEBSOCKETS=y +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE= CONFIG_MICROPY_USE_GSM=y CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y diff --git a/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin b/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin index e995831..d6a07da 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin and b/MicroPython_BUILD/firmware/esp32_psram_ota/MicroPython.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin b/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin index 94c8f2d..5f546eb 100644 Binary files a/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin and b/MicroPython_BUILD/firmware/esp32_psram_ota/bootloader/bootloader.bin differ diff --git a/MicroPython_BUILD/firmware/esp32_psram_ota/sdkconfig b/MicroPython_BUILD/firmware/esp32_psram_ota/sdkconfig index 324add2..1290bf2 100644 --- a/MicroPython_BUILD/firmware/esp32_psram_ota/sdkconfig +++ b/MicroPython_BUILD/firmware/esp32_psram_ota/sdkconfig @@ -122,6 +122,8 @@ CONFIG_MICROPY_FTPSERVER_BUFFER_SIZE=1024 CONFIG_MICROPY_PY_FRAMEBUF=y CONFIG_MICROPY_PY_USE_BTREE= CONFIG_MICROPY_USE_WEBSOCKETS= +CONFIG_MICROPY_USE_DISPLAY=y +CONFIG_MICROPY_USE_EVE= CONFIG_MICROPY_USE_GSM= CONFIG_MICROPY_USE_ETHERNET= CONFIG_MICROPY_USE_MDNS=y