├── .gitignore ├── .travis.yml ├── .vscode ├── extensions.json └── settings.json ├── README.md ├── images └── gamebuino-esp32.jpg ├── lib ├── Gamebuino-META-master │ ├── .gitattributes │ ├── .gitignore │ ├── examples │ │ ├── 1.Basics │ │ │ ├── a_Hello │ │ │ │ └── a_Hello.ino │ │ │ ├── b_Bouncing │ │ │ │ └── b_Bouncing.ino │ │ │ └── c_Controls │ │ │ │ └── c_Controls.ino │ │ ├── 2.Intermediate │ │ │ ├── Audio │ │ │ │ ├── Audio.ino │ │ │ │ └── test.wav │ │ │ ├── CirclesPhysics │ │ │ │ ├── CirclesPhysics.ino │ │ │ │ └── circles.ino │ │ │ ├── Language │ │ │ │ └── Language.ino │ │ │ ├── Lights │ │ │ │ └── Lights.ino │ │ │ ├── Physics │ │ │ │ ├── Physics.ino │ │ │ │ ├── obstacles.ino │ │ │ │ └── player.ino │ │ │ ├── Pong │ │ │ │ └── Pong.ino │ │ │ └── Save │ │ │ │ └── Save.ino │ │ ├── 3.Grove │ │ │ ├── AnalogIn │ │ │ │ └── AnalogIn.ino │ │ │ ├── DigitalIn │ │ │ │ └── DigitalIn.ino │ │ │ ├── DigitalOut │ │ │ │ └── DigitalOut.ino │ │ │ ├── Infrared │ │ │ │ ├── infrared_recv │ │ │ │ │ └── infrared_recv.ino │ │ │ │ └── infrared_send │ │ │ │ │ └── infrared_send.ino │ │ │ ├── Joystick │ │ │ │ └── Joystick.ino │ │ │ ├── Temperature │ │ │ │ └── Temperature.ino │ │ │ ├── UART │ │ │ │ ├── UART_GB1 │ │ │ │ │ └── UART_GB1.ino │ │ │ │ └── UART_GB2 │ │ │ │ │ └── UART_GB2.ino │ │ │ └── i2c │ │ │ │ ├── i2c_master_reader │ │ │ │ └── i2c_master_reader.ino │ │ │ │ └── i2c_slave_sender │ │ │ │ └── i2c_slave_sender.ino │ │ └── 5.Tests │ │ │ ├── BatteryBench │ │ │ └── BatteryBench.ino │ │ │ ├── BitmapPlayer │ │ │ └── BitmapPlayer.ino │ │ │ ├── DisplayDynamic │ │ │ └── DisplayDynamic.ino │ │ │ ├── DisplayStatic │ │ │ ├── DisplayStatic.ino │ │ │ ├── bitmaps │ │ │ │ ├── DRAKKER-02.bmp │ │ │ │ ├── DRAKKER-03.bmp │ │ │ │ └── PLAYER1.bmp │ │ │ └── config-gamebuino.h │ │ │ ├── HardFaultTest │ │ │ └── HardFaultTest.ino │ │ │ └── SdBench │ │ │ └── SdBench.ino │ ├── keywords.txt │ ├── lgpl-3.0.txt │ ├── library.properties │ ├── readme.md │ └── src │ │ ├── Gamebuino-Meta.cpp │ │ ├── Gamebuino-Meta.h │ │ ├── assets │ │ ├── gamebuino R 80x14.png │ │ ├── startLight.bmp │ │ └── startLight.psd │ │ ├── config │ │ ├── config-default.h │ │ └── config.h │ │ ├── sketch │ │ └── config-gamebuino.h │ │ └── utility │ │ ├── Buttons.h │ │ ├── Buttons │ │ ├── Buttons.cpp │ │ └── Buttons.h │ │ ├── Collide.h │ │ ├── Collide │ │ ├── Collide.cpp │ │ └── Collide.h │ │ ├── Display-ST7735.h │ │ ├── Display-ST7735 │ │ ├── .github │ │ │ ├── ISSUE_TEMPLATE.md │ │ │ └── PULL_REQUEST_TEMPLATE.md │ │ ├── Display-ST7735.cpp │ │ ├── Display-ST7735.h │ │ ├── README.txt │ │ ├── examples │ │ │ ├── graphicstest │ │ │ │ └── graphicstest.ino │ │ │ ├── rotationtest │ │ │ │ └── rotationtest.ino │ │ │ ├── shieldtest │ │ │ │ └── shieldtest.ino │ │ │ ├── soft_spitftbitmap │ │ │ │ └── soft_spitftbitmap.ino │ │ │ └── spitftbitmap │ │ │ │ └── spitftbitmap.ino │ │ └── library.properties │ │ ├── Graphics-SD.h │ │ ├── Graphics-SD │ │ ├── BMP.cpp │ │ ├── BMP.h │ │ ├── GMV.cpp │ │ ├── GMV.h │ │ ├── Graphics-SD.cpp │ │ └── Graphics-SD.h │ │ ├── Graphics.h │ │ ├── Graphics │ │ ├── Fonts │ │ │ ├── FreeMono12pt7b.h │ │ │ ├── FreeMono18pt7b.h │ │ │ ├── FreeMono24pt7b.h │ │ │ ├── FreeMono9pt7b.h │ │ │ ├── FreeMonoBold12pt7b.h │ │ │ ├── FreeMonoBold18pt7b.h │ │ │ ├── FreeMonoBold24pt7b.h │ │ │ ├── FreeMonoBold9pt7b.h │ │ │ ├── FreeMonoBoldOblique12pt7b.h │ │ │ ├── FreeMonoBoldOblique18pt7b.h │ │ │ ├── FreeMonoBoldOblique24pt7b.h │ │ │ ├── FreeMonoBoldOblique9pt7b.h │ │ │ ├── FreeMonoOblique12pt7b.h │ │ │ ├── FreeMonoOblique18pt7b.h │ │ │ ├── FreeMonoOblique24pt7b.h │ │ │ ├── FreeMonoOblique9pt7b.h │ │ │ ├── FreeSans12pt7b.h │ │ │ ├── FreeSans18pt7b.h │ │ │ ├── FreeSans24pt7b.h │ │ │ ├── FreeSans9pt7b.h │ │ │ ├── FreeSansBold12pt7b.h │ │ │ ├── FreeSansBold18pt7b.h │ │ │ ├── FreeSansBold24pt7b.h │ │ │ ├── FreeSansBold9pt7b.h │ │ │ ├── FreeSansBoldOblique12pt7b.h │ │ │ ├── FreeSansBoldOblique18pt7b.h │ │ │ ├── FreeSansBoldOblique24pt7b.h │ │ │ ├── FreeSansBoldOblique9pt7b.h │ │ │ ├── FreeSansOblique12pt7b.h │ │ │ ├── FreeSansOblique18pt7b.h │ │ │ ├── FreeSansOblique24pt7b.h │ │ │ ├── FreeSansOblique9pt7b.h │ │ │ ├── FreeSerif12pt7b.h │ │ │ ├── FreeSerif18pt7b.h │ │ │ ├── FreeSerif24pt7b.h │ │ │ ├── FreeSerif9pt7b.h │ │ │ ├── FreeSerifBold12pt7b.h │ │ │ ├── FreeSerifBold18pt7b.h │ │ │ ├── FreeSerifBold24pt7b.h │ │ │ ├── FreeSerifBold9pt7b.h │ │ │ ├── FreeSerifBoldItalic12pt7b.h │ │ │ ├── FreeSerifBoldItalic18pt7b.h │ │ │ ├── FreeSerifBoldItalic24pt7b.h │ │ │ ├── FreeSerifBoldItalic9pt7b.h │ │ │ ├── FreeSerifItalic12pt7b.h │ │ │ ├── FreeSerifItalic18pt7b.h │ │ │ ├── FreeSerifItalic24pt7b.h │ │ │ ├── FreeSerifItalic9pt7b.h │ │ │ └── TomThumb.h │ │ ├── Graphics.cpp │ │ ├── Graphics.h │ │ ├── Image.cpp │ │ ├── Image.h │ │ ├── Images │ │ │ ├── favicon16.bmp │ │ │ ├── favicon16.h │ │ │ ├── logo.bmp │ │ │ ├── logo.h │ │ │ ├── tilemap.bmp │ │ │ └── tilemap.h │ │ ├── README.md │ │ ├── font3x3.c │ │ ├── font3x5.c │ │ ├── font5x7.c │ │ ├── gfxfont.h │ │ ├── library.properties │ │ └── license.txt │ │ ├── Gui.h │ │ ├── Gui │ │ ├── Gui.cpp │ │ ├── Gui.h │ │ └── KeyboardLayouts.cpp │ │ ├── Image.h │ │ ├── Language.h │ │ ├── Language │ │ ├── LangCode.h │ │ ├── Language.cpp │ │ └── Language.h │ │ ├── MetaMode.h │ │ ├── MetaMode │ │ ├── MetaMode.cpp │ │ └── MetaMode.h │ │ ├── Misc.h │ │ ├── Misc │ │ ├── Misc.cpp │ │ └── Misc.h │ │ ├── Save.h │ │ ├── Save │ │ ├── Save.cpp │ │ └── Save.h │ │ ├── Sound-SD.h │ │ ├── Sound-SD │ │ ├── Sound-SD.cpp │ │ └── Sound-SD.h │ │ ├── Sound.h │ │ └── Sound │ │ ├── Pattern.cpp │ │ ├── Pattern.h │ │ ├── Raw.cpp │ │ ├── Raw.h │ │ ├── Sound.cpp │ │ ├── Sound.h │ │ ├── Sound_FX.cpp │ │ ├── Sound_FX.h │ │ ├── Tone.cpp │ │ └── Tone.h └── TFT_eSPI-master │ ├── .gitattributes │ ├── .gitignore │ ├── Extensions │ ├── Button.cpp │ ├── Button.h │ ├── Smooth_font.cpp │ ├── Smooth_font.h │ ├── Sprite.cpp │ ├── Sprite.h │ ├── Touch.cpp │ └── Touch.h │ ├── Processors │ ├── TFT_eSPI_ESP32.c │ ├── TFT_eSPI_ESP32.h │ ├── TFT_eSPI_ESP8266.c │ ├── TFT_eSPI_ESP8266.h │ ├── TFT_eSPI_Generic.c │ ├── TFT_eSPI_Generic.h │ ├── TFT_eSPI_STM32.c │ └── TFT_eSPI_STM32.h │ ├── README.md │ ├── README.txt │ ├── TFT_Drivers │ ├── EPD_Defines.h │ ├── HX8357D_Defines.h │ ├── HX8357D_Init.h │ ├── HX8357D_Rotation.h │ ├── ILI9163_Defines.h │ ├── ILI9163_Init.h │ ├── ILI9163_Rotation.h │ ├── ILI9341_Defines.h │ ├── ILI9341_Init.h │ ├── ILI9341_Rotation.h │ ├── ILI9481_Defines.h │ ├── ILI9481_Init.h │ ├── ILI9481_Rotation.h │ ├── ILI9486_Defines.h │ ├── ILI9486_Init.h │ ├── ILI9486_Rotation.h │ ├── ILI9488_Defines.h │ ├── ILI9488_Init.h │ ├── ILI9488_Rotation.h │ ├── R61581_Defines.h │ ├── R61581_Init.h │ ├── R61581_Rotation.h │ ├── RM68140_Defines.h │ ├── RM68140_Init.h │ ├── RM68140_Rotation.h │ ├── S6D02A1_Defines.h │ ├── S6D02A1_Init.h │ ├── S6D02A1_Rotation.h │ ├── ST7735_Defines.h │ ├── ST7735_Init.h │ ├── ST7735_Rotation.h │ ├── ST7789_2_Defines.h │ ├── ST7789_2_Init.h │ ├── ST7789_2_Rotation.h │ ├── ST7789_Defines.h │ ├── ST7789_Init.h │ ├── ST7789_Rotation.h │ ├── ST7796_Defines.h │ ├── ST7796_Init.h │ └── ST7796_Rotation.h │ ├── TFT_eSPI.cpp │ ├── TFT_eSPI.h │ ├── Tools │ ├── Create_Smooth_Font │ │ └── Create_font │ │ │ ├── Create_font.pde │ │ │ ├── FontFiles │ │ │ └── Final-Frontier28.vlw │ │ │ └── data │ │ │ └── Final-Frontier.ttf │ ├── ESP32 UNO board mod │ │ ├── ESP32 UNO board mod.jpg │ │ └── ESP32 UNO board pinout.jpg │ ├── PlatformIO │ │ └── Configuring options.txt │ ├── RPi_TFT_Connections.png │ ├── RPi_TFT_mod.png │ └── Screenshot_client │ │ └── Screenshot_client.pde │ ├── User_Setup.h │ ├── User_Setup_Select.h │ ├── User_Setups │ ├── Setup10_RPi_touch_ILI9486.h │ ├── Setup11_RPi_touch_ILI9486.h │ ├── Setup12_M5Stack.h │ ├── Setup135_ST7789.h │ ├── Setup13_ILI9481_Parallel.h │ ├── Setup14_ILI9341_Parallel.h │ ├── Setup15_HX8357D.h │ ├── Setup16_ILI9488_Parallel.h │ ├── Setup17_ePaper.h │ ├── Setup18_ST7789.h │ ├── Setup19_RM68140_Parallel.h │ ├── Setup1_ILI9341.h │ ├── Setup20_ILI9488.h │ ├── Setup21_ILI9488.h │ ├── Setup22_TTGO_T4.h │ ├── Setup23_TTGO_TM.h │ ├── Setup24_ST7789.h │ ├── Setup25_TTGO_T_Display.h │ ├── Setup26_TTGO_T_Wristband.h │ ├── Setup27_RPi_ST7796_ESP32.h │ ├── Setup28_RPi_ST7796_ESP8266.h │ ├── Setup29_ILI9341_STM32.h │ ├── Setup2_ST7735.h │ ├── Setup30_ILI9341_Parallel_STM32.h │ ├── Setup3_ILI9163.h │ ├── Setup43_ST7735.h │ ├── Setup4_S6D02A1.h │ ├── Setup5_RPi_ILI9486.h │ ├── Setup6_RPi_Wr_ILI9486.h │ ├── Setup7_ST7735_128x128.h │ ├── Setup8_ILI9163_128x128.h │ ├── Setup9_ST7735_Overlap.h │ ├── SetupX_Template.h │ └── User_Custom_Fonts.h │ ├── examples │ ├── 160 x 128 │ │ ├── Arduino_Life │ │ │ └── Arduino_Life.ino │ │ ├── Pong_v3 │ │ │ └── Pong_v3.ino │ │ ├── RLE_Font_test │ │ │ └── RLE_Font_test.ino │ │ ├── TFT_Char_times │ │ │ └── TFT_Char_times.ino │ │ ├── TFT_Clock │ │ │ └── TFT_Clock.ino │ │ ├── TFT_Clock_Digital │ │ │ └── TFT_Clock_Digital.ino │ │ ├── TFT_Ellipse │ │ │ └── TFT_Ellipse.ino │ │ ├── TFT_Meter_5 │ │ │ └── TFT_Meter_5.ino │ │ ├── TFT_Print_Test │ │ │ └── TFT_Print_Test.ino │ │ ├── TFT_Rainbow │ │ │ └── TFT_Rainbow.ino │ │ ├── TFT_SPIFFS_Jpeg │ │ │ ├── JPEG_functions.ino │ │ │ ├── SPIFFS_functions.ino │ │ │ └── TFT_SPIFFS_Jpeg.ino │ │ ├── TFT_flash_jpg │ │ │ ├── TFT_flash_jpg.ino │ │ │ ├── jpeg1.h │ │ │ ├── jpeg2.h │ │ │ ├── jpeg3.h │ │ │ └── jpeg4.h │ │ ├── TFT_graphicstest_PDQ3 │ │ │ └── TFT_graphicstest_PDQ3.ino │ │ ├── TFT_graphicstest_small │ │ │ └── TFT_graphicstest_small.ino │ │ └── UTFT_demo_fast │ │ │ └── UTFT_demo_fast.ino │ ├── 320 x 240 │ │ ├── All_Free_Fonts_Demo │ │ │ ├── All_Free_Fonts_Demo.ino │ │ │ └── Free_Fonts.h │ │ ├── Cellular_Automata │ │ │ └── Cellular_Automata.ino │ │ ├── Free_Font_Demo │ │ │ ├── Free_Font_Demo.ino │ │ │ └── Free_Fonts.h │ │ ├── Keypad_240x320 │ │ │ └── Keypad_240x320.ino │ │ ├── RLE_Font_test │ │ │ └── RLE_Font_test.ino │ │ ├── Read_ID_bitbash │ │ │ └── Read_ID_bitbash.ino │ │ ├── TFT_ArcFill │ │ │ └── TFT_ArcFill.ino │ │ ├── TFT_Char_times │ │ │ └── TFT_Char_times.ino │ │ ├── TFT_Clock │ │ │ └── TFT_Clock.ino │ │ ├── TFT_Clock_Digital │ │ │ └── TFT_Clock_Digital.ino │ │ ├── TFT_Custom_Fonts │ │ │ └── TFT_Custom_Fonts.ino │ │ ├── TFT_Ellipse │ │ │ └── TFT_Ellipse.ino │ │ ├── TFT_FillArcSpiral │ │ │ └── TFT_FillArcSpiral.ino │ │ ├── TFT_Float_Test │ │ │ └── TFT_Float_Test.ino │ │ ├── TFT_Mandlebrot │ │ │ └── TFT_Mandlebrot.ino │ │ ├── TFT_Matrix │ │ │ └── TFT_Matrix.ino │ │ ├── TFT_Meter_linear │ │ │ └── TFT_Meter_linear.ino │ │ ├── TFT_Meters │ │ │ └── TFT_Meters.ino │ │ ├── TFT_Pie_Chart │ │ │ └── TFT_Pie_Chart.ino │ │ ├── TFT_Pong │ │ │ └── TFT_Pong.ino │ │ ├── TFT_Print_Test │ │ │ └── TFT_Print_Test.ino │ │ ├── TFT_Rainbow_one_lib │ │ │ └── TFT_Rainbow_one_lib.ino │ │ ├── TFT_Read_Reg │ │ │ └── TFT_Read_Reg.ino │ │ ├── TFT_Spiro │ │ │ └── TFT_Spiro.ino │ │ ├── TFT_Starfield │ │ │ └── TFT_Starfield.ino │ │ ├── TFT_String_Align │ │ │ └── TFT_String_Align.ino │ │ ├── TFT_Terminal │ │ │ └── TFT_Terminal.ino │ │ ├── TFT_graphicstest_PDQ │ │ │ └── TFT_graphicstest_PDQ.ino │ │ ├── TFT_graphicstest_one_lib │ │ │ └── TFT_graphicstest_one_lib.ino │ │ └── UTFT_demo │ │ │ └── UTFT_demo.ino │ ├── 480 x 320 │ │ ├── Cellular_Automata │ │ │ └── Cellular_Automata.ino │ │ ├── Demo_3D_cube │ │ │ └── Demo_3D_cube.ino │ │ ├── Free_Font_Demo │ │ │ ├── Free_Font_Demo.ino │ │ │ └── Free_Fonts.h │ │ ├── Graph_2 │ │ │ └── Graph_2.ino │ │ ├── Keypad_480x320 │ │ │ └── Keypad_480x320.ino │ │ ├── TFT_Char_times │ │ │ └── TFT_Char_times.ino │ │ ├── TFT_Ellipse │ │ │ └── TFT_Ellipse.ino │ │ ├── TFT_Meter_4 │ │ │ └── TFT_Meter_4.ino │ │ ├── TFT_Meters │ │ │ └── TFT_Meters.ino │ │ ├── TFT_Padding_demo │ │ │ └── TFT_Padding_demo.ino │ │ ├── TFT_Print_Test │ │ │ └── TFT_Print_Test.ino │ │ ├── TFT_Rainbow480 │ │ │ └── TFT_Rainbow480.ino │ │ ├── TFT_String_Align │ │ │ └── TFT_String_Align.ino │ │ ├── TFT_flash_jpg │ │ │ ├── TFT_flash_jpg.ino │ │ │ ├── jpeg1.h │ │ │ ├── jpeg2.h │ │ │ ├── jpeg3.h │ │ │ └── jpeg4.h │ │ ├── TFT_graphicstest_one_lib │ │ │ └── TFT_graphicstest_one_lib.ino │ │ ├── TFT_ring_meter │ │ │ ├── Alert.h │ │ │ └── TFT_ring_meter.ino │ │ ├── Touch_Controller_Demo │ │ │ └── Touch_Controller_Demo.ino │ │ └── UTFT_Demo_480x320 │ │ │ └── UTFT_Demo_480x320.ino │ ├── DMA test │ │ ├── Flash_Jpg_DMA │ │ │ ├── Flash_Jpg_DMA.ino │ │ │ └── panda.h │ │ ├── SpriteRotatingCube │ │ │ └── SpriteRotatingCube.ino │ │ └── boing_ball │ │ │ ├── boing_ball.ino │ │ │ └── graphic.h │ ├── Generic │ │ ├── ESP32_SDcard_jpeg │ │ │ ├── Data │ │ │ │ ├── Baboon40.jpg │ │ │ │ ├── EagleEye.jpg │ │ │ │ ├── Mouse480.jpg │ │ │ │ └── lena20k.jpg │ │ │ └── ESP32_SDcard_jpeg.ino │ │ ├── ESP8266_uncannyEyes │ │ │ ├── ESP8266_uncannyEyes.ino │ │ │ ├── defaultEye.h │ │ │ ├── dragonEye.h │ │ │ ├── goatEye.h │ │ │ ├── noScleraEye.h │ │ │ └── screenshotToConsole.ino │ │ ├── Local_Custom_Fonts │ │ │ ├── Local_Custom_Fonts.ino │ │ │ └── MyFont.h │ │ ├── On_Off_Button │ │ │ └── On_Off_Button.ino │ │ ├── TFT_Flash_Bitmap │ │ │ ├── Alert.h │ │ │ ├── Close.h │ │ │ ├── Info.h │ │ │ └── TFT_Flash_Bitmap.ino │ │ ├── TFT_SPIFFS_BMP │ │ │ ├── BMP_functions.ino │ │ │ ├── TFT_SPIFFS_BMP.ino │ │ │ └── data │ │ │ │ └── parrot.bmp │ │ ├── TFT_Screen_Capture │ │ │ ├── TFT_Screen_Capture.ino │ │ │ ├── processing_sketch.ino │ │ │ └── screenServer.ino │ │ ├── Touch_calibrate │ │ │ └── Touch_calibrate.ino │ │ └── drawXBitmap │ │ │ ├── drawXBitmap.ino │ │ │ └── xbm.h │ ├── Smooth Fonts │ │ ├── ESP32_Smooth_Font_SD │ │ │ ├── ESP32_Smooth_Font_SD.ino │ │ │ └── data │ │ │ │ └── Final-Frontier-28.vlw │ │ ├── Font_Demo_1 │ │ │ ├── Font_Demo_1.ino │ │ │ ├── Notes.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ └── NotoSansBold36.vlw │ │ ├── Font_Demo_2 │ │ │ ├── Font_Demo_2.ino │ │ │ ├── Notes.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ └── NotoSansBold36.vlw │ │ ├── Font_Demo_3 │ │ │ ├── Font_Demo_3.ino │ │ │ ├── Notes.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ ├── NotoSansBold36.vlw │ │ │ │ └── NotoSansMonoSCB20.vlw │ │ ├── Font_Demo_4 │ │ │ ├── Font_Demo_4.ino │ │ │ ├── Notes.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ └── NotoSansBold36.vlw │ │ ├── Print_Smooth_Font │ │ │ ├── Print_Smooth_Font.ino │ │ │ └── data │ │ │ │ └── Final-Frontier-28.vlw │ │ ├── Smooth_font_gradient │ │ │ ├── Smooth_font_gradient.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ └── NotoSansBold36.vlw │ │ ├── Smooth_font_reading_TFT │ │ │ ├── Smooth_font_reading_TFT.ino │ │ │ └── data │ │ │ │ ├── NotoSansBold15.vlw │ │ │ │ └── NotoSansBold36.vlw │ │ ├── Unicode_test │ │ │ ├── SPIFFS_functions.ino │ │ │ ├── Unicode_test.ino │ │ │ └── data │ │ │ │ ├── Final-Frontier-28.vlw │ │ │ │ ├── Latin-Hiragana-24.vlw │ │ │ │ └── Unicode-Test-72.vlw │ │ └── alphaBlend_Test │ │ │ └── alphaBlend_Test.ino │ ├── Sprite │ │ ├── One_bit_Sprite_Demo │ │ │ └── One_bit_Sprite_Demo.ino │ │ ├── One_bit_Yin_Yang │ │ │ └── One_bit_Yin_Yang.ino │ │ ├── Rotated_Sprite_1 │ │ │ └── Rotated_Sprite_1.ino │ │ ├── Rotated_Sprite_2 │ │ │ └── Rotated_Sprite_2.ino │ │ ├── Rotated_Sprite_3 │ │ │ ├── Rotated_Sprite_3.ino │ │ │ └── data │ │ │ │ ├── EagleEye.jpg │ │ │ │ └── Eye_80x64.jpg │ │ ├── Sprite_RLE_Font_test │ │ │ └── Sprite_RLE_Font_test.ino │ │ ├── Sprite_TFT_Rainbow │ │ │ └── Sprite_TFT_Rainbow.ino │ │ ├── Sprite_drawPixel │ │ │ └── Sprite_drawPixel.ino │ │ ├── Sprite_scroll │ │ │ └── Sprite_scroll.ino │ │ ├── Sprite_scroll_16bit │ │ │ └── Sprite_scroll_16bit.ino │ │ ├── Sprite_scroll_1bit │ │ │ └── Sprite_scroll_1bit.ino │ │ ├── Sprite_scroll_8bit │ │ │ └── Sprite_scroll_8bit.ino │ │ ├── Sprite_scroll_wrap_1bit │ │ │ └── Sprite_scroll_wrap_1bit.ino │ │ └── Transparent_Sprite_Demo │ │ │ └── Transparent_Sprite_Demo.ino │ ├── Test and diagnostics │ │ ├── Colour_Test │ │ │ └── Colour_Test.ino │ │ ├── Read_User_Setup │ │ │ └── Read_User_Setup.ino │ │ └── Test_Touch_Controller │ │ │ └── Test_Touch_Controller.ino │ └── ePaper │ │ └── Floyd_Steinberg │ │ ├── EPD_Support.h │ │ ├── Floyd_Steinberg.ino │ │ ├── Floyd_Steinberg_BMP.ino │ │ ├── SPIFFS.ino │ │ └── data │ │ ├── TestCard.bmp │ │ └── Tiger.bmp │ ├── keywords.txt │ ├── library.json │ ├── library.properties │ └── license.txt ├── platformio.ini └── src ├── config-gamebuino.h ├── main.cpp ├── main.cpp__audio_tester └── main.cpp__benchmark /.gitignore: -------------------------------------------------------------------------------- 1 | .pio 2 | .vscode/.browse.c_cpp.db* 3 | .vscode/c_cpp_properties.json 4 | .vscode/launch.json 5 | .vscode/ipch 6 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | # Continuous Integration (CI) is the practice, in software 2 | # engineering, of merging all developer working copies with a shared mainline 3 | # several times a day < https://docs.platformio.org/page/ci/index.html > 4 | # 5 | # Documentation: 6 | # 7 | # * Travis CI Embedded Builds with PlatformIO 8 | # < https://docs.travis-ci.com/user/integration/platformio/ > 9 | # 10 | # * PlatformIO integration with Travis CI 11 | # < https://docs.platformio.org/page/ci/travis.html > 12 | # 13 | # * User Guide for `platformio ci` command 14 | # < https://docs.platformio.org/page/userguide/cmd_ci.html > 15 | # 16 | # 17 | # Please choose one of the following templates (proposed below) and uncomment 18 | # it (remove "# " before each line) or use own configuration according to the 19 | # Travis CI documentation (see above). 20 | # 21 | 22 | 23 | # 24 | # Template #1: General project. Test it using existing `platformio.ini`. 25 | # 26 | 27 | # language: python 28 | # python: 29 | # - "2.7" 30 | # 31 | # sudo: false 32 | # cache: 33 | # directories: 34 | # - "~/.platformio" 35 | # 36 | # install: 37 | # - pip install -U platformio 38 | # - platformio update 39 | # 40 | # script: 41 | # - platformio run 42 | 43 | 44 | # 45 | # Template #2: The project is intended to be used as a library with examples. 46 | # 47 | 48 | # language: python 49 | # python: 50 | # - "2.7" 51 | # 52 | # sudo: false 53 | # cache: 54 | # directories: 55 | # - "~/.platformio" 56 | # 57 | # env: 58 | # - PLATFORMIO_CI_SRC=path/to/test/file.c 59 | # - PLATFORMIO_CI_SRC=examples/file.ino 60 | # - PLATFORMIO_CI_SRC=path/to/test/directory 61 | # 62 | # install: 63 | # - pip install -U platformio 64 | # - platformio update 65 | # 66 | # script: 67 | # - platformio ci --lib="." --board=ID_1 --board=ID_2 --board=ID_N 68 | -------------------------------------------------------------------------------- /.vscode/extensions.json: -------------------------------------------------------------------------------- 1 | { 2 | // See http://go.microsoft.com/fwlink/?LinkId=827846 3 | // for the documentation about the extensions.json format 4 | "recommendations": [ 5 | "platformio.platformio-ide" 6 | ] 7 | } -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "*.tcc": "cpp", 4 | "fstream": "cpp", 5 | "array": "cpp", 6 | "deque": "cpp", 7 | "string": "cpp", 8 | "unordered_map": "cpp", 9 | "unordered_set": "cpp", 10 | "vector": "cpp", 11 | "initializer_list": "cpp" 12 | } 13 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # gamebuino-esp32 2 | 3 | This is an ESP32 Port for Handheld Game Console Gamebuino META which is originally based on ATSAMD21. 4 | 5 | Ported to ESP32 TTGO T4 v1.3 with ILI9341 LCD Display 6 | 7 | ![Gamebuino ESP32 Port](images/gamebuino-esp32.jpg) 8 | 9 | # Why Port to ESP32? 10 | Because I want to play Gamebuino META games and I don't have physical Gamebuino META. But I do have an ESP32 laying around, and it is a good exercise to do. 11 | 12 | # What Part that is working? 13 | I've already done some initial porting effort, and thanks to Gamebuino META great modularity, I only need to port most low-level parts. 14 | 15 | I've ported these parts: 16 | * Display 17 | * Keypad 18 | * Audio (although it is not as smooth as the original) 19 | * SD Card 20 | 21 | # What Is Your Next Plan? 22 | * Improve display rendering performance by enabling DMA 23 | * Add Multiplayer support through WiFi/Bluetooth 24 | * Port Game Loader 25 | -------------------------------------------------------------------------------- /images/gamebuino-esp32.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/images/gamebuino-esp32.jpg -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | 7 | # Standard to msysgit 8 | *.doc diff=astextplain 9 | *.DOC diff=astextplain 10 | *.docx diff=astextplain 11 | *.DOCX diff=astextplain 12 | *.dot diff=astextplain 13 | *.DOT diff=astextplain 14 | *.pdf diff=astextplain 15 | *.PDF diff=astextplain 16 | *.rtf diff=astextplain 17 | *.RTF diff=astextplain 18 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/1.Basics/a_Hello/a_Hello.ino: -------------------------------------------------------------------------------- 1 | //imports the Gamebuino library and the gb object 2 | #include 3 | 4 | // the setup routine runs once when Gamebuino starts up 5 | void setup(){ 6 | // initialize the Gamebuino object 7 | gb.begin(); 8 | } 9 | 10 | // the loop routine runs over and over again forever 11 | void loop(){ 12 | // wait until the gamebuino is ready to update at stable 25 FPS 13 | // this also updates sounds, button presses... everything! 14 | while(!gb.update()); 15 | 16 | // clear the previous screen 17 | gb.display.clear(); 18 | 19 | //prints Hello World! on the screen 20 | gb.display.println("hello world!"); 21 | //declare a variable named count of type integer : 22 | int count; 23 | //get the number of frames rendered and assign it to the "count" variable 24 | count = gb.frameCount; 25 | //prints the variable "count" 26 | gb.display.println(count); 27 | } -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/1.Basics/b_Bouncing/b_Bouncing.ino: -------------------------------------------------------------------------------- 1 | //imports the Gamebuino library and the gb object 2 | #include 3 | 4 | //declare all the variables needed for the game : 5 | int ball_x = gb.display.width() / 2; //set the horizontal position to the middle of the screen 6 | int ball_y = gb.display.height() / 2; //vertical position 7 | int ball_vx = 1; //horizontal velocity 8 | int ball_vy = 1; //vertical velocity 9 | int ball_size = 6; //the size of the ball in number of pixels 10 | 11 | // the setup routine runs once when Gamebuino starts up 12 | void setup() { 13 | // initialize the Gamebuino object 14 | gb.begin(); 15 | } 16 | 17 | // the loop routine runs over and over again forever 18 | void loop() { 19 | // wait until the gamebuino is ready to update at stable 25 FPS 20 | // this also updates sounds, button presses....everything! 21 | while (!gb.update()); 22 | 23 | // clear the previous screen 24 | gb.display.clear(); 25 | 26 | //add the speed of the ball to its position 27 | ball_x = ball_x + ball_vx; 28 | ball_y = ball_y + ball_vy; 29 | 30 | //check that the ball is not going out of the screen 31 | //if the ball is touching the left side of the screen 32 | if (ball_x < 0) { 33 | //change the direction of the horizontal speed 34 | ball_vx = -ball_vx; 35 | //play a preset "tick" sound when the ball hits the border 36 | gb.sound.playTick(); 37 | } 38 | //if the ball is touching the right side 39 | if ((ball_x + ball_size) > gb.display.width()) { 40 | ball_vx = -ball_vx; 41 | gb.sound.playTick(); 42 | } 43 | //if the ball is touching the top side 44 | if (ball_y < 0) { 45 | ball_vy = -ball_vy; 46 | gb.sound.playTick(); 47 | } 48 | //if the ball is touching the down side 49 | if ((ball_y + ball_size) > gb.display.height()) { 50 | ball_vy = -ball_vy; 51 | gb.sound.playTick(); 52 | } 53 | 54 | //draw the ball on the screen 55 | gb.display.fillRect(ball_x, ball_y, ball_size, ball_size); 56 | } -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/1.Basics/c_Controls/c_Controls.ino: -------------------------------------------------------------------------------- 1 | //importe the Gamebuino library and the gb object 2 | #include 3 | 4 | //declare all the variables needed for the game : 5 | int ball_x = gb.display.width() / 2; //set the horizontal position to the middle of the screen 6 | int ball_y = gb.display.height() / 2; //vertical position 7 | int ball_vx = 1; //horizontal velocity 8 | int ball_vy = 1; //vertical velocity 9 | int ball_size = 6; //the size of the ball in number of pixels 10 | 11 | // the setup routine runs once when Gamebuino starts up 12 | void setup() { 13 | // initialize the Gamebuino 14 | gb.begin(); 15 | } 16 | 17 | // the loop routine runs over and over again forever 18 | void loop() { 19 | // wait until the gamebuino is ready to update at stable 25 FPS 20 | // this also updates sounds, button presses....everything! 21 | while (!gb.update()); 22 | 23 | // clear the previous screen 24 | gb.display.clear(); 25 | 26 | //move the ball using the buttons 27 | if (gb.buttons.repeat(BUTTON_RIGHT, 2)) { //every 2 frames when the right button is held down 28 | ball_x = ball_x + ball_vx; //increase the horizontal position by the ball's velocity 29 | } 30 | if (gb.buttons.repeat(BUTTON_LEFT, 2)) { 31 | ball_x = ball_x - ball_vx; 32 | } 33 | if (gb.buttons.repeat(BUTTON_DOWN, 2)) { 34 | ball_y = ball_y + ball_vy; 35 | } 36 | if (gb.buttons.repeat(BUTTON_UP, 2)) { 37 | ball_y = ball_y - ball_vy; 38 | } 39 | //bonus : play a sound when A and B are pressed 40 | if (gb.buttons.pressed(BUTTON_A)) { 41 | gb.sound.playOK(); 42 | } 43 | if (gb.buttons.pressed(BUTTON_B)) { 44 | gb.sound.playCancel(); 45 | } 46 | 47 | //check that the ball is not going out of the screen 48 | //if the ball is touching the left side of the screen 49 | if (ball_x < 0) { 50 | //bring it back in the screen 51 | ball_x = 0; 52 | } 53 | //if the ball is touching the right side 54 | if ((ball_x + ball_size) > gb.display.width()) { 55 | ball_x = gb.display.width() - ball_size; 56 | } 57 | //if the ball is touching the top side 58 | if (ball_y < 0) { 59 | ball_y = 0; 60 | } 61 | //if the ball is touching the down side 62 | if ((ball_y + ball_size) > gb.display.height()) { 63 | ball_y = gb.display.height() - ball_size; 64 | } 65 | 66 | //draw the ball on the screen 67 | gb.display.fillRect(ball_x, ball_y, ball_size, ball_size); 68 | } -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/Audio/test.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/examples/2.Intermediate/Audio/test.wav -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/CirclesPhysics/CirclesPhysics.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef struct{ 4 | float x, y, r, vx, vy; 5 | } Circle; 6 | 7 | void setup() 8 | { 9 | gb.begin(); 10 | initGame(); 11 | } 12 | 13 | void loop() 14 | { 15 | while(!gb.update()); 16 | 17 | // clear the previous screen 18 | gb.display.clear(); 19 | 20 | //pause the game if MENU is pressed 21 | if(gb.buttons.pressed(BUTTON_MENU)){ 22 | initGame(); 23 | } 24 | updateCircles(); 25 | drawCircles(); 26 | } 27 | 28 | void initGame(){ 29 | initCircles(); 30 | } 31 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/Language/Language.ino: -------------------------------------------------------------------------------- 1 | // import the Gamebuino library 2 | #include 3 | 4 | // here we define our language variable "fox" 5 | // it has two entries, one for english and one for german 6 | const MultiLang fox[] = { 7 | {LANG_EN, "the fox"}, // english entry 8 | {LANG_DE, "der Fuchs"}, // german entry 9 | }; 10 | 11 | // gamebuino setup 12 | void setup() { 13 | gb.begin(); 14 | } 15 | 16 | void loop() { 17 | while(!gb.update()); 18 | 19 | // clear the previous screen 20 | gb.display.clear(); 21 | 22 | // here we get the pointer ot our string, depending on the users language setting 23 | const char* lang_fox = gb.language.get(fox); 24 | // aaaaand print it to the screen 25 | gb.display.println(lang_fox); 26 | 27 | // we can also combind the two lines above, letting it become: 28 | gb.display.println(gb.language.get(fox)); 29 | 30 | // or, if we want to print to the display, we can even do 31 | gb.display.println(fox); 32 | } 33 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/Lights/Lights.ino: -------------------------------------------------------------------------------- 1 | // === LIGHTS === // 2 | // gb.light is a 2x4 pixel image to which we can draw to 3 | // drawing stuff to it will automatically update the lights in the background 4 | 5 | // import the Gamebuino library 6 | #include 7 | 8 | 9 | bool lightsOn = false; 10 | bool redLight = false; 11 | 12 | void setup() { 13 | gb.begin(); 14 | } 15 | 16 | void loop() { 17 | while(!gb.update()); 18 | 19 | // clear the previous screen 20 | gb.display.clear(); 21 | 22 | // clear the previous state of the lights 23 | gb.lights.clear(); 24 | 25 | if (lightsOn) { 26 | // if we want the lights to be on, let's turn all lights white! 27 | gb.lights.fill(WHITE); 28 | } 29 | 30 | if (redLight) { 31 | // if we want the red light, let's set the lower-left light red 32 | // if lightsOn is true we will just over-write the lower-left light, and thus the lower-left light **WILL** be red for sure! 33 | gb.lights.drawPixel(0, 3, RED); 34 | } 35 | 36 | if (gb.buttons.pressed(BUTTON_A)) { 37 | // toggle lightsOn 38 | lightsOn = !lightsOn; 39 | } 40 | 41 | if (gb.buttons.pressed(BUTTON_B)) { 42 | // toggle redLight 43 | redLight = !redLight; 44 | } 45 | 46 | // now let's just display our controls 47 | gb.display.println("LIGHTS\nA: TOGGLE ALL\nB: TOGGLE RED"); 48 | } -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/Physics/Physics.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //define de Box structure for obstacles 4 | typedef struct { 5 | byte w; 6 | byte x; 7 | byte h; 8 | byte y; 9 | } Box; 10 | 11 | //define de MovingBox structure for player 12 | typedef struct { 13 | byte w; 14 | float x; 15 | float xv; 16 | byte h; 17 | float y; 18 | float yv; 19 | } MovingBox; 20 | 21 | void setup() 22 | { 23 | gb.begin(); 24 | initGame(); 25 | } 26 | 27 | void loop(){ 28 | while(!gb.update()); 29 | 30 | // clear the previous screen 31 | gb.display.clear(); 32 | 33 | //pause the game if MENU is pressed 34 | if(gb.buttons.pressed(BUTTON_MENU)){ 35 | initGame(); 36 | } 37 | 38 | updatePlayer(); 39 | updateObstacles(); 40 | 41 | drawObstacles(); 42 | drawPlayer(); 43 | //gb.display.print(F("CPU:")); 44 | //gb.display.print(gb.getCpuLoad()); 45 | //gb.display.print(F("%")); 46 | } 47 | 48 | void initGame(){ 49 | initObstacles(); 50 | initPlayer(); 51 | } 52 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/2.Intermediate/Physics/obstacles.ino: -------------------------------------------------------------------------------- 1 | 2 | #define NUM_OBSTACLES 10 //define a constant named "NUM_OBSTACLES" equal to 8 3 | Box obstacles[NUM_OBSTACLES]; //create the obstacles array 4 | 5 | void initObstacles(){ 6 | //top 7 | obstacles[0].w = gb.display.width(); 8 | obstacles[0].h = 4; 9 | obstacles[0].x = 0; 10 | obstacles[0].y = 0; 11 | //bottom 12 | obstacles[1].w = gb.display.width(); 13 | obstacles[1].h = 4; 14 | obstacles[1].x = 0; 15 | obstacles[1].y = gb.display.height()-4; 16 | //left 17 | obstacles[2].w = 4; 18 | obstacles[2].h = gb.display.height(); 19 | obstacles[2].x = 0; 20 | obstacles[2].y = 0; 21 | //right 22 | obstacles[3].w = 4; 23 | obstacles[3].h = gb.display.height(); 24 | obstacles[3].x = gb.display.width()-4; 25 | obstacles[3].y = 0; 26 | //randomize the other obstacles 27 | for(byte i=4; i 0 & gb.buttons.timeHeld(BUTTON_A) < 5 ){ //higher jump by holding A down 50 | player.yv -= 1; //jump 51 | } 52 | if(gb.buttons.pressed(BUTTON_A)){ 53 | gb.sound.playOK(); 54 | } 55 | player.y += player.yv; //move forward of 1 step 56 | //check for collisions on y axis 57 | if(playerCollision()){ 58 | player.y -= player.yv; //move back of 1 step 59 | player.yv *= -0.5; //change the velocity direction 60 | } 61 | } 62 | 63 | void drawPlayer(){ 64 | gb.display.fillRect(player.x, player.y, player.w, player.h); 65 | } 66 | 67 | boolean playerCollision(){ 68 | for(byte i=0; i 3 | 4 | // set our save slot for a number 5 | #define SAVE_NUMBER 0 6 | // set our save slot for a string 7 | #define SAVE_STRING 1 8 | 9 | // these variables will be used to cache our save variables in ram 10 | // ACCESSING SAVE VARIABLES IS SLOW AND NOT TO BE USED IN A LOOP REPETITIVELY 11 | char string[40]; 12 | int number; 13 | 14 | 15 | // gamebuino setup 16 | void setup() { 17 | gb.begin(); 18 | 19 | // let's load our save variables! 20 | // if not set, number defaults to zero 21 | number = gb.save.get(SAVE_NUMBER); 22 | // if not set, string will be filled with zeros 23 | gb.save.get(SAVE_STRING, string); 24 | } 25 | 26 | void loop() { 27 | while(!gb.update()); 28 | 29 | // clear the previous screen 30 | gb.display.clear(); 31 | 32 | // let's first output our cached stuff 33 | gb.display.println("Number:"); 34 | gb.display.println(number); 35 | gb.display.println("String:"); 36 | gb.display.println(string); 37 | 38 | if (gb.buttons.pressed(BUTTON_UP)) { 39 | // first increase our cached variable 40 | number++; 41 | // now save it to our save slot! 42 | gb.save.set(SAVE_NUMBER, number); 43 | gb.sound.playTick(); 44 | } 45 | if (gb.buttons.pressed(BUTTON_DOWN)) { 46 | // first decrease our cached variable 47 | number--; 48 | // now save it to our save slot! 49 | gb.save.set(SAVE_NUMBER, number); 50 | gb.sound.playTick(); 51 | } 52 | 53 | if (gb.buttons.pressed(BUTTON_A)) { 54 | // okay, let's let the user modify our cached string variable 55 | gb.keyboard(string, 40); 56 | // aaaaaand now save it to its slot! 57 | gb.save.set(SAVE_STRING, string); 58 | } 59 | 60 | if (gb.buttons.pressed(BUTTON_B)) { 61 | // first we delete both of our save slots 62 | gb.save.del(SAVE_NUMBER); 63 | gb.save.del(SAVE_STRING); 64 | 65 | // and now we reset our cached variables 66 | // alternatively we could fetch the defaults with gb.save.get, too 67 | number = 0; 68 | memset(string, 0, sizeof(string)); 69 | gb.sound.playCancel(); 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/AnalogIn/AnalogIn.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int MyPotentiometre = A1; // select the input pin for the potentiometer 4 | int MyValue; 5 | 6 | void setup() { 7 | // put your setup code here, to run once: 8 | gb.begin(); 9 | 10 | } 11 | 12 | void loop() { 13 | // put your main code here, to run repeatedly: 14 | while (!gb.update()); 15 | gb.display.clear(); 16 | 17 | //update your value from your potentiometer 18 | MyValue = analogRead(MyPotentiometre); 19 | 20 | //print it on screen 21 | gb.display.print("ANALOG INPUT\nA1: "); 22 | gb.display.print(MyValue); 23 | 24 | //maps the value from 0..1023 to 0..64 25 | MyValue = (MyValue * 64) / 1023; 26 | 27 | //gb.display.print("\n"); 28 | //gb.display.print(MyValue); 29 | 30 | //Draw it as a rectangle 31 | gb.display.drawRect(0, 16, 64, 5); 32 | gb.display.fillRect(0, 16, MyValue, 5); 33 | } 34 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/DigitalIn/DigitalIn.ino: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | int MySwitch = A1; //Select the input pin for the switch // Si je mets autre chose que A.. ça ne fonctionne pas 5 | int MyValue; 6 | 7 | void setup() { 8 | // put your setup code here, to run once: 9 | gb.begin(); 10 | pinMode(MySwitch, INPUT); 11 | } 12 | 13 | void loop() { 14 | // put your main code here, to run repeatedly: 15 | while (!gb.update()); 16 | gb.display.clear(); 17 | 18 | //update your value from the switch 19 | MyValue = digitalRead(MySwitch); 20 | 21 | //print it on screen 22 | gb.display.print("DIGITAL INPUT\nA1: "); 23 | 24 | // If we press the button, "ON" is displayed on screen. Otherwise : "OFF" 25 | if (MyValue) { 26 | gb.display.print("ON"); 27 | } 28 | else { 29 | gb.display.print("OFF"); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/DigitalOut/DigitalOut.ino: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | int MyLed = A1; //Select the input pin for the switch // Si je mets autre chose que A.. ça ne fonctionne pas 5 | 6 | void setup() { 7 | // put your setup code here, to run once: 8 | gb.begin(); 9 | pinMode(MyLed, OUTPUT); 10 | 11 | } 12 | 13 | void loop() { 14 | // put your main code here, to run repeatedly: 15 | while (!gb.update()); 16 | gb.display.clear(); 17 | 18 | //print it on screen 19 | gb.display.print("DIGITAL OUTPUT\nA1: "); 20 | 21 | // To enlighten the LED, press A 22 | if (gb.buttons.repeat(BUTTON_A, 0)) { 23 | digitalWrite(MyLed, HIGH); 24 | gb.display.print("ON"); 25 | } 26 | else { 27 | digitalWrite(MyLed, LOW); 28 | gb.display.print("OFF"); 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/Infrared/infrared_recv/infrared_recv.ino: -------------------------------------------------------------------------------- 1 | /* 2 | IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv 3 | An IR detector/demodulator must be connected to the input RECV_PIN. 4 | Version 0.1 July, 2009 5 | Copyright 2009 Ken Shirriff 6 | http://arcfn.com 7 | */ 8 | #include 9 | #include 10 | 11 | int RECV_PIN = A3; 12 | int count = 0; 13 | 14 | IRrecv irrecv(RECV_PIN); 15 | 16 | decode_results results; 17 | 18 | void setup() 19 | { 20 | gb.begin(); 21 | irrecv.enableIRIn(); // Start the receiver 22 | gb.display.print("INFRARED RECEIVER \n "); 23 | gb.display.print("\n "); 24 | gb.display.print("Received message : \n"); 25 | gb.display.print("\n "); 26 | 27 | } 28 | 29 | void loop() { 30 | while (!gb.update()); 31 | //gb.display.clear(); 32 | 33 | //Clear 34 | if (count == 2) { 35 | delay(1000); 36 | gb.display.clear(); 37 | gb.display.print("INFRARED RECEIVER \n "); 38 | gb.display.print("\n "); 39 | gb.display.print("Received message : \n"); 40 | gb.display.print("\n "); 41 | count = 0; 42 | } 43 | 44 | 45 | 46 | //check if a message is received 47 | if (irrecv.decode(&results)) { 48 | 49 | gb.display.print(results.value, HEX); 50 | gb.display.print("\n "); 51 | irrecv.resume(); // Receive the next value 52 | count = count + 1; 53 | } 54 | delay(10); 55 | } 56 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/Infrared/infrared_send/infrared_send.ino: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | IRremote: IRsendDemo - demonstrates sending IR codes with IRsend 4 | An IR LED must be connected to Arduino PWM pin 3. 5 | Version 0.1 July, 2009 6 | Copyright 2009 Ken Shirriff 7 | http://arcfn.com 8 | */ 9 | 10 | #include 11 | #include 12 | 13 | 14 | IRsend irsend(A3); 15 | 16 | void setup() 17 | { 18 | gb.begin(); 19 | 20 | } 21 | 22 | void loop() { 23 | while (!gb.update()); 24 | gb.display.clear(); 25 | 26 | //print it on screen 27 | gb.display.print("INFRARED EMMITER \n "); 28 | gb.display.print("\n "); 29 | gb.display.print("Press A to send A:\n"); 30 | 31 | //If the user clicks on the button A, a signal is sent 32 | if (gb.buttons.repeat(BUTTON_A, 0)) { 33 | irsend.sendSony(0xa, 12); 34 | //delay(10); 35 | gb.display.print("SENDING"); 36 | } 37 | delay(100); 38 | } 39 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/Joystick/Joystick.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int xAxis = A1; 4 | int yAxis = A2; 5 | int x, y; 6 | int value; 7 | 8 | int range = 40; 9 | int offset = 20; // vertical offset 10 | 11 | 12 | void setup() { 13 | // put your setup code here, to run once: 14 | gb.begin(); 15 | 16 | } 17 | 18 | void loop() { 19 | // put your main code here, to run repeatedly: 20 | while (!gb.update()); 21 | gb.display.clear(); 22 | 23 | // reads and maps the value from 0..1023 to -range/2..range/2 24 | x = analogRead(xAxis) * range / 1024 - (range / 2); 25 | y = analogRead(yAxis) * range / 1024 - (range / 2); 26 | 27 | //print the values 28 | gb.display.print("JOYSTICK"); 29 | gb.display.print("\nA1 x:"); 30 | gb.display.print(x); 31 | gb.display.print("\nA2 y:"); 32 | gb.display.print(y); 33 | 34 | //draw the graphic 35 | gb.display.drawRect(0, 0 + offset, range, range); 36 | gb.display.fillRect(0, x + (range / 2) + offset, range, 1); 37 | gb.display.fillRect(y + range / 2, 0 + offset, 1, range); 38 | 39 | 40 | } 41 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/Temperature/Temperature.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int thermistor = A1; //Select the input pin for the thermistor 5 | double temperature, B, R0, R, value; 6 | 7 | 8 | void setup() { 9 | // put your setup code here, to run once: 10 | gb.begin(); 11 | pinMode(thermistor, INPUT); 12 | 13 | } 14 | 15 | void loop() { 16 | // put your main code here, to run repeatedly: 17 | while (!gb.update()); 18 | gb.display.clear(); 19 | 20 | //read the value of the thermocouple and convert it to temperature 21 | temperature = 999.99; 22 | B = 4275.0; // B value of the thermistor 23 | R0 = 100000.0; // R0 = 100k 24 | value = analogRead(thermistor); 25 | R = 1024 / value - 1.0; // analog input 26 | R = R0 * R; 27 | if ( R0 / R > 0) { 28 | temperature = 1.0 / ( log(R / R0) / B + 1 / 298.15 ) - 273.15; 29 | } 30 | 31 | //print it on screen 32 | gb.display.print("TEMPERATURE SENSOR\nA1: "); 33 | gb.display.print(value); 34 | gb.display.print("\nTEMP: "); 35 | gb.display.print(temperature); 36 | gb.display.print("C "); 37 | 38 | 39 | } 40 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/UART/UART_GB1/UART_GB1.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | char c; 5 | 6 | void setup() { 7 | // put your setup code here, to run once: 8 | gb.begin(); 9 | Serial1.begin(9600); 10 | 11 | } 12 | 13 | void loop() { 14 | // put your main code here, to run repeatedly: 15 | while (!gb.update()); 16 | gb.display.clear(); 17 | 18 | //print it on screea 19 | gb.display.print("UART TEST GB1 \n\n"); 20 | gb.display.print("A to send a msg \n\n"); 21 | 22 | if (gb.buttons.repeat(BUTTON_A, 0)) { 23 | gb.display.print("\nSending Text"); 24 | Serial1.write("\nTest "); 25 | 26 | } 27 | 28 | delay(500); 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | } 37 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/UART/UART_GB2/UART_GB2.ino: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | char c; 6 | 7 | void setup() { 8 | // put your setup code here, to run once: 9 | gb.begin(); 10 | Serial1.begin(9600); 11 | 12 | 13 | } 14 | 15 | void loop() { 16 | // put your main code here, to run repeatedly: 17 | while (!gb.update()); 18 | gb.display.clear(); 19 | 20 | // Wait a text from GB1 21 | gb.display.print("UART TEST GB2\n\n"); 22 | gb.display.print("A text from GB1 :\n\n"); 23 | 24 | 25 | //Receive the text and print it 26 | while (Serial1.available()) { 27 | c = Serial1.read(); 28 | gb.display.print(c); 29 | } 30 | 31 | 32 | delay(1000); 33 | 34 | 35 | } 36 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/i2c/i2c_master_reader/i2c_master_reader.ino: -------------------------------------------------------------------------------- 1 | // Wire Master Reader 2 | // by Nicholas Zambetti 3 | 4 | // Demonstrates use of the Wire library 5 | // Reads data from an I2C/TWI slave device 6 | // Refer to the "Wire Slave Sender" example for use with this 7 | 8 | // Created 29 March 2006 9 | 10 | // This example code is in the public domain. 11 | 12 | 13 | #include 14 | #include 15 | 16 | // Two external pull-up resistors are plugged in. 17 | 18 | void setup() 19 | { 20 | gb.begin(); 21 | Wire.begin(); // join i2c bus (address optional for master) 22 | 23 | } 24 | 25 | void loop() 26 | { 27 | while (!gb.update()); 28 | gb.display.clear(); 29 | 30 | 31 | //Display on screen 32 | gb.display.print("I2C Test\n"); 33 | gb.display.print("\n"); 34 | gb.display.print("A to receive a msg"); 35 | gb.display.print("\n\n"); 36 | 37 | // When button A is pressed, a request is sent to the other gamebuino 38 | if (gb.buttons.repeat(BUTTON_A, 0)) { 39 | gb.display.print("REQUESTING..\n"); 40 | gb.display.print("\n"); 41 | if (Wire.requestFrom(2, 6)) { // request 6 bytes from slave device #2 42 | //delay(10); 43 | gb.display.print("RECEIVED : "); 44 | } 45 | } 46 | 47 | //When the other gamebuino received the request, it sends "Hello" 48 | while (Wire.available()) // slave may send less than requested 49 | { 50 | 51 | char c = Wire.read(); // receive a byte as character 52 | gb.display.print(c); // print the character 53 | } 54 | 55 | delay(500); 56 | } 57 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/3.Grove/i2c/i2c_slave_sender/i2c_slave_sender.ino: -------------------------------------------------------------------------------- 1 | // Wire Slave Sender 2 | // by Nicholas Zambetti 3 | 4 | // Demonstrates use of the Wire library 5 | // Sends data as an I2C/TWI slave device 6 | // Refer to the "Wire Master Reader" example for use with this 7 | 8 | // Created 29 March 2006 9 | 10 | // This example code is in the public domain. 11 | 12 | 13 | #include 14 | #include 15 | 16 | void setup() 17 | { 18 | gb.begin(); 19 | Wire.begin(2); // join i2c bus with address #2 20 | 21 | } 22 | 23 | void loop() 24 | { 25 | while (!gb.update()); 26 | gb.display.clear(); 27 | 28 | //Display on screen 29 | gb.display.print("I2C Test\n"); 30 | gb.display.print("\n\n"); 31 | gb.display.print("Press A on the other\n"); 32 | gb.display.print("GAMEBUINO\n\n"); 33 | //Wait for a request 34 | Wire.onRequest(requestEvent); // register event 35 | delay(500); 36 | 37 | } 38 | 39 | // function that executes whenever data is requested by master 40 | // this function is registered as an event, see setup() 41 | void requestEvent() 42 | { 43 | Wire.write("hello "); // respond with message of 6 bytes as expected by master 44 | gb.display.print("Sending Hello"); 45 | 46 | } 47 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/BatteryBench/BatteryBench.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void setup() { 4 | gb.begin(); 5 | 6 | gb.tft.print("OPENING FILE... "); 7 | //open the file (or create if not existing), read/write mode, start writing at the end. 8 | File file = SD.open("BATTERY.TXT", O_CREAT | O_RDWR | O_AT_END); 9 | if (!file) { 10 | gb.tft.println("ERROR"); 11 | while (1); 12 | } else { 13 | gb.tft.println("OK"); 14 | file.print("\n### STARTING BATTERY BENCHMARK ###\n"); 15 | file.flush(); 16 | } 17 | 18 | while (1) { 19 | while(!gb.update()); 20 | gb.display.clear(); 21 | gb.lights.clear(); 22 | gb.display.println("BATTERY BENCHMARK\n"); 23 | gb.display.println("I'VE BEEN UP FOR "); 24 | gb.display.print(millis() / 1000 / 60 / 60 ); 25 | gb.display.println(" HOURS "); 26 | gb.display.print((millis() / 1000 / 60) % 60); 27 | gb.display.println(" MINUTES "); 28 | gb.display.print((millis() / 1000) % 60); 29 | gb.display.println(" SECONDS "); 30 | gb.display.print(millis() % 1000); 31 | gb.display.println(" MILLISEC "); 32 | if ((gb.frameCount % (25 * 60)) == 0) { 33 | file.print(millis() / 1000 / 60 / 60 ); 34 | file.print("H "); 35 | file.print((millis() / 1000 / 60) % 60); 36 | file.print("M "); 37 | file.print((millis() / 1000) % 60); 38 | file.print("S ("); 39 | file.print(millis()); 40 | file.println("ms)"); 41 | file.flush(); 42 | } 43 | } 44 | } 45 | 46 | void loop() { 47 | } 48 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/DRAKKER-02.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/DRAKKER-02.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/DRAKKER-03.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/DRAKKER-03.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/PLAYER1.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/bitmaps/PLAYER1.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/DisplayStatic/config-gamebuino.h: -------------------------------------------------------------------------------- 1 | //enable one of the display modes 2 | //if no config-gamebuino.h is present, it defaults to RGB 3 | 4 | #define DISPLAY_MODE DISPLAY_MODE_RGB565 5 | //#define DISPLAY_MODE DISPLAY_MODE_INDEX 6 | //#define DISPLAY_MODE DISPLAY_MODE_INDEX_HALFRES 7 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/examples/5.Tests/HardFaultTest/HardFaultTest.ino: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void setup() { 4 | gb.begin(); 5 | } 6 | 7 | void loop() { 8 | while(!gb.update()); 9 | // clear the previous screen 10 | gb.display.clear(); 11 | 12 | gb.display.println("A to trigger hard fault"); 13 | gb.display.println(gb.frameCount); 14 | if (gb.buttons.pressed(BUTTON_A)) { 15 | // nuke (jumping to a non-aligned location) 16 | ((void(*)(void))(*((uint32_t*)0x3FEC) + 1))(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/library.properties: -------------------------------------------------------------------------------- 1 | name=Gamebuino META 2 | version=1.3.2 3 | author=Sorunome, Aurélien Rodot et al. 4 | maintainer=Rodot 5 | sentence=Make your first game within hours. 6 | paragraph=See more on https://gamebuino.com 7 | category=Device Control 8 | url=https://github.com/Gamebuino/Gamebuino-Meta 9 | architectures=samd 10 | includes=Gamebuino-Meta.h 11 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/readme.md: -------------------------------------------------------------------------------- 1 | Welcome to the Gamebuino Meta official repository ! 2 | Get started [HERE](https://gamebuino.com/start)! -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/assets/gamebuino R 80x14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/assets/gamebuino R 80x14.png -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/assets/startLight.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/assets/startLight.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/assets/startLight.psd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/assets/startLight.psd -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/sketch/config-gamebuino.h: -------------------------------------------------------------------------------- 1 | // this file is only needed to not get include errors, just leave it here 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Buttons.h: -------------------------------------------------------------------------------- 1 | #include "Buttons/Buttons.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Buttons/Buttons.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2014, 2016-2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Aurelien Rodot 21 | - Sorunome 22 | */ 23 | 24 | #ifndef _GAMEBUINO_META_BUTTONS_H_ 25 | #define _GAMEBUINO_META_BUTTONS_H_ 26 | 27 | #include "../../config/config.h" 28 | 29 | namespace Gamebuino_Meta { 30 | const uint8_t NUM_BTN = 8; 31 | const uint8_t BTN_CS = 25; 32 | 33 | enum class Button : uint8_t { 34 | home = 7, 35 | menu = 6, 36 | b = 5, 37 | a = 4, 38 | up = 3, 39 | right = 2, 40 | left = 1, 41 | down = 0, 42 | }; 43 | 44 | class Buttons { 45 | public: 46 | void begin(); 47 | void update(); 48 | bool pressed(Button button); 49 | bool released(Button button); 50 | bool held(Button button, uint16_t time); 51 | bool repeat(Button button, uint16_t period); 52 | uint16_t timeHeld(Button button); 53 | uint16_t states[NUM_BTN]; 54 | }; 55 | 56 | } // namespace Gamebuino_Meta 57 | 58 | using Gamebuino_Meta::Button; 59 | 60 | const Button BUTTON_DOWN = Button::down; 61 | const Button BUTTON_LEFT = Button::left; 62 | const Button BUTTON_RIGHT = Button::right; 63 | const Button BUTTON_UP = Button::up; 64 | const Button BUTTON_A = Button::a; 65 | const Button BUTTON_B = Button::b; 66 | const Button BUTTON_MENU = Button::menu; 67 | const Button BUTTON_HOME = Button::home; 68 | const Button BUTTON_C = Button::menu; 69 | const Button BUTTON_D = Button::home; 70 | 71 | #endif // _GAMEBUINO_META_BUTTONS_H_ 72 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Collide.h: -------------------------------------------------------------------------------- 1 | #include "Collide/Collide.h" -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Collide/Collide.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2018 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Julien Giovinazzo 21 | */ 22 | 23 | #include "Collide.h" 24 | 25 | namespace Gamebuino_Meta { 26 | bool Collide::rectRect(int16_t x1, int16_t y1, int16_t w1, int16_t h1, int16_t x2, int16_t y2, int16_t w2, int16_t h2) { 27 | return (x2 < x1 + w1 && x2 + w2 > x1 28 | && y2 < y1 + h1 && y2 + h2 > y1); 29 | } 30 | 31 | bool Collide::pointRect(int16_t pointX, int16_t pointY, uint16_t rectX, uint16_t rectY, uint16_t rectW, uint16_t rectH) { 32 | return (pointX >= rectX && pointX < rectX + rectW && pointY >= rectY && pointY < rectY + rectH); 33 | } 34 | bool Collide::circleCircle(int16_t centerX1, int16_t centerY1, int16_t r1, int16_t centerX2, int16_t centerY2, int16_t r2) { 35 | // True if the distance between the centers is smaller than the sum of the radii : dist < r1 + r2 36 | // dist = sqrt( (centerX1 - centerX2)^2 + (centerY1 - centerY2)^2 ) but we can't use sqrt (too slow). 37 | // however, sqrt(a) < b <==> a < b*b for all natural numbers 38 | // in our case, 'a' is by definition a natural numbers 39 | // So let's make sure 'b' is a natural numbers 40 | r1 = abs(r1); 41 | r2 = abs(r2); 42 | // Now apply the formula 43 | return (((centerX1 - centerX2) * (centerX1 - centerX2) + (centerY1 - centerY2) * (centerY1 - centerY2)) < (r1 + r2) * (r1 + r2)); 44 | } 45 | bool Collide::pointCircle(int16_t pointX, int16_t pointY, int16_t centerX, int16_t centerY, int16_t r) { 46 | // Just like circleCircle collision, but r2 = 0 47 | r = abs(r); 48 | return (((pointX - centerX) * (pointX - centerX) + (pointY - centerY) * (pointY - centerY)) < r * r); 49 | } 50 | 51 | 52 | }; // Namespace Gamebuino_Meta 53 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Collide/Collide.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2018 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Julien Giovinazzo 21 | */ 22 | #ifndef _GAMEBUINO_META_COLLIDE_H_ 23 | #define _GAMEBUINO_META_COLLIDE_H_ 24 | 25 | #include "../../config/config.h" 26 | 27 | namespace Gamebuino_Meta { 28 | 29 | class Collide { 30 | public: 31 | bool rectRect(int16_t x1, int16_t y1, int16_t w1, int16_t h1, int16_t x2, int16_t y2, int16_t w2, int16_t h2); // Returns TRUE if the 2 rects overlap 32 | bool pointRect(int16_t pointX, int16_t pointY, uint16_t rectX, uint16_t rectY, uint16_t rectW, uint16_t rectH); // Returns TRUE if the point overlaps the rect 33 | bool circleCircle(int16_t centerX1, int16_t centerY1, int16_t r1, int16_t centerX2, int16_t centerY2, int16_t r2); // Returns TRUE if the 2 circles overlap 34 | bool pointCircle(int16_t pointX, int16_t pointY, int16_t centerX, int16_t centerY, int16_t r); // Returns TRUE if the point overlaps the circle 35 | }; 36 | }; // Namespace Gamebuino_Meta 37 | 38 | 39 | 40 | 41 | #endif // _GAMEBUINO_META_COLLIDE_H_ 42 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Display-ST7735.h: -------------------------------------------------------------------------------- 1 | #include "Display-ST7735/Display-ST7735.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Display-ST7735/.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | Thank you for creating a pull request to contribute to Adafruit's GitHub code! 2 | Before you open the request please review the following guidelines and tips to 3 | help it be more easily integrated: 4 | 5 | - **Describe the scope of your change--i.e. what the change does and what parts 6 | of the code were modified.** This will help us understand any risks of integrating 7 | the code. 8 | 9 | - **Describe any known limitations with your change.** For example if the change 10 | doesn't apply to a supported platform of the library please mention it. 11 | 12 | - **Please run any tests or examples that can exercise your modified code.** We 13 | strive to not break users of the code and running tests/examples helps with this 14 | process. 15 | 16 | Thank you again for contributing! We will try to test and integrate the change 17 | as soon as we can, but be aware we have many GitHub repositories to manage and 18 | can't immediately respond to every request. There is no need to bump or check in 19 | on a pull request (it will clutter the discussion of the request). 20 | 21 | Also don't be worried if the request is closed or not integrated--sometimes the 22 | priorities of Adafruit's GitHub code (education, ease of use) might not match the 23 | priorities of the pull request. Don't fret, the open source community thrives on 24 | forks and GitHub makes it easy to keep your changes in a forked repo. 25 | 26 | After reviewing the guidelines above you can delete this text from the pull request. 27 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Display-ST7735/README.txt: -------------------------------------------------------------------------------- 1 | This is a library for the Adafruit 1.8" SPI display. 2 | This library works with the Adafruit 1.8" TFT Breakout w/SD card 3 | ----> http://www.adafruit.com/products/358 4 | The 1.8" TFT shield 5 | ----> https://www.adafruit.com/product/802 6 | The 1.44" TFT breakout 7 | ----> https://www.adafruit.com/product/2088 8 | as well as Adafruit raw 1.8" TFT display 9 | ----> http://www.adafruit.com/products/618 10 | 11 | 12 | Check out the links above for our tutorials and wiring diagrams. 13 | These displays use SPI to communicate, 4 or 5 pins are required 14 | to interface (RST is optional). 15 | Adafruit invests time and resources providing this open source code, 16 | please support Adafruit and open-source hardware by purchasing 17 | products from Adafruit! 18 | 19 | Written by Limor Fried/Ladyada for Adafruit Industries. 20 | MIT license, all text above must be included in any redistribution 21 | 22 | To download. click the DOWNLOADS button in the top right corner, rename the uncompressed folder Display_ST7735. Check that the Display_ST7735 folder contains Display_ST7735.cpp and Display_ST7735. 23 | 24 | Place the Display_ST7735 library folder your /libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE 25 | 26 | Also requires the Graphics library for Arduino. 27 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Display-ST7735/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit ST7735 Library 2 | version=1.0.4 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=This is a library for the Adafruit 1.8" SPI displays. 6 | paragraph=This is a library for the Adafruit 1.8" SPI displays. 7 | category=Display 8 | url=https://github.com/adafruit/Adafruit-ST7735-Library 9 | architectures=* 10 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics-SD.h: -------------------------------------------------------------------------------- 1 | #include "Graphics-SD/Graphics-SD.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics-SD/BMP.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_BMP_H_ 24 | #define _GAMEBUINO_BMP_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "../Image.h" 28 | 29 | #if USE_SDFAT 30 | #include 31 | #endif 32 | 33 | namespace Gamebuino_Meta { 34 | 35 | 36 | class BMP { 37 | public: 38 | BMP(); 39 | BMP(Image* img, uint16_t frames); 40 | #if USE_SDFAT 41 | BMP(File* file, Image* img); 42 | #endif 43 | bool isValid(); 44 | uint32_t getCreatorBits(); 45 | #if USE_SDFAT 46 | void setCreatorBits(uint32_t bits, File* file); 47 | uint16_t readBuffer(uint16_t* buf, uint32_t offset, uint16_t transparentColor, File* file); 48 | uint16_t readFrame(uint16_t frame, uint16_t* buf, uint16_t transparentColor, File* file); 49 | #endif 50 | uint32_t getRowSize(); 51 | 52 | #if USE_SDFAT 53 | uint32_t writeHeader(File* file); 54 | void writeBuffer(uint16_t* buffer, uint16_t transparentColor, File* file); 55 | void writeFrame(uint16_t frame, uint16_t* buffer, uint16_t transparentColor, File* file); 56 | #endif 57 | uint8_t depth; 58 | bool upside_down; 59 | private: 60 | bool valid; 61 | uint8_t image_offset; 62 | uint32_t creatorBits; 63 | uint16_t width; 64 | uint16_t height; 65 | uint16_t frames; 66 | uint8_t indexMap[16]; 67 | }; 68 | 69 | } // namespace Gamebuino_Meta 70 | 71 | #endif /// _GAMEBUINO_BMP_H_ 72 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics-SD/GMV.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_GMV_H_ 24 | #define _GAMEBUINO_GMV_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "BMP.h" 28 | #include "../Image.h" 29 | #include "../Display-ST7735.h" 30 | #include "../Graphics.h" 31 | 32 | #if USE_SDFAT 33 | #include 34 | #endif 35 | 36 | namespace Gamebuino_Meta { 37 | 38 | class GMV { 39 | public: 40 | GMV(); 41 | GMV(Image* _img); 42 | GMV(Image* _img, char* filename); 43 | bool isValid(); 44 | bool is(Image* _img); 45 | bool initSave(char* filename); 46 | uint16_t getFrames(); 47 | void writeHeader(); 48 | void writeFrame(); 49 | void readFrame(); 50 | void setFrame(uint16_t frame); 51 | void finishSave(char* filename, uint16_t frames, bool output, Display_ST7735* tft); 52 | private: 53 | #if USE_SDFAT 54 | File file; 55 | #endif 56 | Image* img; 57 | void convertFromBMP(BMP& bmp, char* newname); 58 | #if USE_SDFAT 59 | void writeColor(File* f, uint16_t color, uint8_t count); 60 | void writeHeader(File* f); 61 | void writeFrame(File* f); 62 | #endif 63 | bool valid; 64 | uint16_t header_size; 65 | }; 66 | 67 | } // namespace Gamebuino_Meta 68 | 69 | #endif // _GAMEBUINO_GMV_H_ 70 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics-SD/Graphics-SD.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2016-2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_SD_GFX_H_ 24 | #define _GAMEBUINO_SD_GFX_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "../Image.h" 28 | #include "GMV.h" 29 | #include "../Display-ST7735.h" 30 | 31 | namespace Gamebuino_Meta { 32 | 33 | class Frame_Handler_SD : public Frame_Handler { 34 | public: 35 | Frame_Handler_SD(Image* img); 36 | ~Frame_Handler_SD(); 37 | void init(char* filename); 38 | void next(); 39 | void set(uint16_t frame); 40 | private: 41 | void lazy_init(); 42 | union { 43 | GMV* gmv; 44 | char* lazy_filename; 45 | }; 46 | }; 47 | 48 | class Recording_Image { 49 | public: 50 | Recording_Image(GMV& _gmv); 51 | ~Recording_Image(); 52 | void update(); 53 | bool is(Image* img); 54 | void finish(bool output); 55 | void setBmpFilename(char* filename); 56 | private: 57 | char* bmp_filename; 58 | GMV gmv; 59 | uint16_t frames; 60 | }; 61 | 62 | class Graphics_SD { 63 | public: 64 | static bool startRecording(Image* img, char* filename); 65 | static void stopRecording(Image* img, bool output); 66 | static bool save(Image* img, char* filename); 67 | static void update(); 68 | static void setTft(Display_ST7735* _tft); 69 | }; 70 | 71 | } // namespace Gamebuino_Meta 72 | 73 | #endif /// _GAMEBUINO_SD_GFX_H_ 74 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics.h: -------------------------------------------------------------------------------- 1 | #include "Graphics/Graphics.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/Images/favicon16.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/utility/Graphics/Images/favicon16.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/Images/favicon16.h: -------------------------------------------------------------------------------- 1 | #if defined(ARDUINO_ARCH_AVR) 2 | #include 3 | #elif defined(ARDUINO_SAM_DUE) 4 | #define PROGMEM 5 | #endif 6 | 7 | const uint16_t favicon16Width = 16; 8 | const uint16_t favicon16Height = 16; 9 | const uint16_t favicon16[256] PROGMEM={ 10 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0x4208,0x4208,0x4208,0x4208,0xF81F,0xF81F, // row 0, 16 pixels 11 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x4208,0x4208,0xF81F, // row 1, 32 pixels 12 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xF81F,0xDEFB,0xDEFB,0x4208,0xDEFB,0x4208,0x4208, // row 2, 48 pixels 13 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0xDEFB,0xDEFB,0x4208,0x4208,0xDEFB,0xDEFB,0x4208, // row 3, 64 pixels 14 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0xDEFB,0xDEFB,0xDEFB,0x01DF,0x01DF,0xDEFB,0x4208, // row 4, 80 pixels 15 | 0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0xDEFB,0xDEFB,0x27E0,0x27E0,0xDEFB,0x4208, // row 5, 96 pixels 16 | 0xF81F,0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0x9471,0x9471,0xDEFB,0xDEFB,0xDEFB,0x4208,0x4208, // row 6, 112 pixels 17 | 0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0x9471,0x9471,0x9471,0x9471,0xDEFB,0x4208,0x4208,0xF81F, // row 7, 128 pixels 18 | 0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0x9471,0x9471,0x9471,0x9471,0xDEFB,0xDEFB,0x4208,0xF81F,0xF81F, // row 8, 144 pixels 19 | 0xF81F,0xF81F,0xF81F,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0x9471,0x9471,0xDEFB,0xDEFB,0x069E,0xF81F,0xF81F,0xF81F, // row 9, 160 pixels 20 | 0x4208,0xF81F,0xDEFB,0x069E,0xDEFB,0xDEFB,0x9471,0x9471,0x9471,0xDEFB,0xDEFB,0x069E,0xF81F,0xF81F,0xF81F,0xF81F, // row 10, 176 pixels 21 | 0x4208,0xDEFB,0xDEFB,0xDEFB,0xDEFB,0xDEFB,0xDEFB,0x9471,0xDEFB,0xDEFB,0x069E,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F, // row 11, 192 pixels 22 | 0x4208,0xDEFB,0xDEFB,0xDEFB,0xFBA5,0xFBA5,0xDEFB,0xDEFB,0xDEFB,0x069E,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F, // row 12, 208 pixels 23 | 0x4208,0x4208,0xDEFB,0xDEFB,0xFBA5,0xFBA5,0xDEFB,0x4208,0x4208,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F, // row 13, 224 pixels 24 | 0xF81F,0x4208,0x4208,0xDEFB,0xDEFB,0xDEFB,0x4208,0x4208,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F, // row 14, 240 pixels 25 | 0xF81F,0xF81F,0x4208,0x4208,0x4208,0x4208,0x4208,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F,0xF81F}; // row 15, 256 pixels 26 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/Images/logo.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/utility/Graphics/Images/logo.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/Images/tilemap.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/Gamebuino-META-master/src/utility/Graphics/Images/tilemap.bmp -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/README.md: -------------------------------------------------------------------------------- 1 | # Adafruit GFX Library 2 | 3 | This is the core graphics library for all our displays, providing a common set of graphics primitives (points, lines, circles, etc.). It needs to be paired with a hardware-specific library for each display device we carry (to handle the lower-level functions). 4 | 5 | Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit! 6 | 7 | Written by Limor Fried/Ladyada for Adafruit Industries. 8 | BSD license, check license.txt for more information. 9 | All text above must be included in any redistribution. 10 | 11 | Recent Arduino IDE releases include the Library Manager for easy installation. Otherwise, to download, click the DOWNLOAD ZIP button, uncompress and rename the uncompressed folder Graphics. Confirm that the Graphics folder contains Graphics.cpp and Graphics.h. Place the Graphics library folder your /Libraries/ folder. You may need to create the Libraries subfolder if its your first library. Restart the IDE. 12 | 13 | # Useful Resources 14 | 15 | - Image2Code: This is a handy Java GUI utility to convert a BMP file into the array code necessary to display the image with the drawBitmap function. Check out the code at ehubin's GitHub repository: https://github.com/ehubin/Adafruit-GFX-Library/tree/master/Img2Code 16 | 17 | - drawXBitmap function: You can use the GIMP photo editor to save a .xbm file and use the array saved in the file to draw a bitmap with the drawXBitmap function. See the pull request here for more details: https://github.com/adafruit/Adafruit-GFX-Library/pull/31 18 | 19 | - 'Fonts' folder contains bitmap fonts for use with recent (1.1 and later) Graphics. To use a font in your Arduino sketch, #include the corresponding .h file and pass address of GFXfont struct to setFont(). Pass NULL to revert to 'classic' fixed-space bitmap font. 20 | 21 | - 'fontconvert' folder contains a command-line tool for converting TTF fonts to Graphics .h format. 22 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/gfxfont.h: -------------------------------------------------------------------------------- 1 | // Font structures for newer Graphics (1.1 and later). 2 | // Example fonts are included in 'Fonts' directory. 3 | // To use a font in your Arduino sketch, #include the corresponding .h 4 | // file and pass address of GFXfont struct to setFont(). Pass NULL to 5 | // revert to 'classic' fixed-space bitmap font. 6 | 7 | #ifndef _GFXFONT_H_ 8 | #define _GFXFONT_H_ 9 | 10 | #include "stdint.h" 11 | 12 | namespace Gamebuino_Meta { 13 | 14 | typedef struct { // Data stored PER GLYPH 15 | uint16_t bitmapOffset; // Pointer into GFXfont->bitmap 16 | uint8_t width, height; // Bitmap dimensions in pixels 17 | uint8_t xAdvance; // Distance to advance cursor (x axis) 18 | int8_t xOffset, yOffset; // Dist from cursor pos to UL corner 19 | } GFXglyph; 20 | 21 | typedef struct { // Data stored for FONT AS A WHOLE: 22 | uint8_t *bitmap; // Glyph bitmaps, concatenated 23 | GFXglyph *glyph; // Glyph array 24 | uint8_t first, last; // ASCII extents 25 | uint8_t yAdvance; // Newline distance (y axis) 26 | } GFXfont; 27 | 28 | } // namespace Gamebuino_Meta 29 | 30 | #endif // _GFXFONT_H_ 31 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit GFX Library 2 | version=1.1.5 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=Adafruit GFX graphics core library, this is the 'core' class that all our other graphics libraries derive from. 6 | paragraph=Install this library in addition to the display library for your hardware. 7 | category=Display 8 | url=https://github.com/adafruit/Adafruit-GFX-Library 9 | architectures=* 10 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Graphics/license.txt: -------------------------------------------------------------------------------- 1 | Software License Agreement (BSD License) 2 | 3 | Copyright (c) 2012 Adafruit Industries. All rights reserved. 4 | 5 | Redistribution and use in source and binary forms, with or without 6 | modification, are permitted provided that the following conditions are met: 7 | 8 | - Redistributions of source code must retain the above copyright notice, 9 | this list of conditions and the following disclaimer. 10 | - Redistributions in binary form must reproduce the above copyright notice, 11 | this list of conditions and the following disclaimer in the documentation 12 | and/or other materials provided with the distribution. 13 | 14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 18 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 19 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 20 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 21 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 22 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 23 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 24 | POSSIBILITY OF SUCH DAMAGE. 25 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Gui.h: -------------------------------------------------------------------------------- 1 | #include "Gui/Gui.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Gui/KeyboardLayouts.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2018 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | // This file is ISO-8859-1 encoded, or anything compatible, such as Windows-1252 24 | 25 | #include "../../config/config.h" 26 | 27 | namespace Gamebuino_Meta { 28 | 29 | const char keyboardLayoutPage0[] = "1234567890qwertyuiop[]*asdfghjkl;'\\*zxcvbnm,./-=*AB"; 30 | const char keyboardLayoutPage1[] = "!@*$%^&*()QWERTYUIOP{}*ASDFGHJKL:\"|*ZXCVBNM<>?_+*ab"; 31 | const char* keyboardLayout[] = { 32 | keyboardLayoutPage0, 33 | keyboardLayoutPage1, 34 | }; 35 | const uint8_t keyboardLayoutPages = 2; 36 | 37 | }; // namespace Gamebuino_Meta 38 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Image.h: -------------------------------------------------------------------------------- 1 | #include "Graphics/Image.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Language.h: -------------------------------------------------------------------------------- 1 | #include "Language/Language.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Language/Language.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #include "Language.h" 24 | 25 | namespace Gamebuino_Meta { 26 | 27 | LangCode Language::currentLang = LangCode::en; 28 | 29 | LangCode Language::getCurrentLang() { 30 | return currentLang; 31 | } 32 | 33 | void Language::setCurrentLang(LangCode c) { 34 | currentLang = c; 35 | } 36 | 37 | const char* Language::get(const MultiLang* l, uint8_t num) { 38 | const char* def = 0; 39 | for (uint8_t i = 0; i < num; i++) { 40 | if (l[i].code == currentLang) { 41 | return l[i].str; 42 | } 43 | if (!def) { 44 | def = l[i].str; 45 | } else if (l[i].code == LangCode::en) { 46 | def = l[i].str; 47 | } 48 | } 49 | return def; 50 | } 51 | 52 | void Print_Language::print(const MultiLang* l, uint8_t num ) { 53 | print(Language::get(l, num)); 54 | } 55 | 56 | void Print_Language::println(const MultiLang* l, uint8_t num ) { 57 | println(Language::get(l, num)); 58 | } 59 | 60 | }; // Gamebuino_Meta 61 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/MetaMode.h: -------------------------------------------------------------------------------- 1 | #include "MetaMode/MetaMode.h" -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Misc.h: -------------------------------------------------------------------------------- 1 | #include "Misc/Misc.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Misc/Misc.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_META_MISC_H_ 24 | #define _GAMEBUINO_META_MISC_H_ 25 | 26 | #include "../../config/config.h" 27 | 28 | #if USE_SDFAT 29 | #include 30 | #endif 31 | 32 | namespace Gamebuino_Meta { 33 | 34 | void intToStr(int32_t i, char* buf); 35 | 36 | int32_t sdPathNoDuplicate(char* name, uint8_t offset, uint8_t digits, int32_t start = 0); 37 | 38 | struct RGB888 { 39 | uint8_t r, g, b; 40 | }; 41 | 42 | uint16_t rgb888Torgb565(RGB888 c); 43 | RGB888 rgb565Torgb888(uint16_t c); 44 | 45 | #if USE_SDFAT 46 | uint16_t f_read16(File* f); 47 | 48 | uint32_t f_read32(File* f); 49 | 50 | void f_write32(uint32_t b, File* f); 51 | 52 | void f_write16(uint16_t b, File* f); 53 | #endif // USE_SDFAT 54 | 55 | } // namespace Gamebuino_Meta 56 | 57 | #endif // _GAMEBUINO_META_MISC_H_ 58 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Save.h: -------------------------------------------------------------------------------- 1 | #include "Save/Save.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound-SD.h: -------------------------------------------------------------------------------- 1 | #include "Sound-SD/Sound-SD.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound-SD/Sound-SD.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_META_SOUND_SD_H_ 24 | #define _GAMEBUINO_META_SOUND_SD_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "../Sound.h" 28 | #if USE_SDFAT 29 | #include 30 | #endif 31 | 32 | namespace Gamebuino_Meta { 33 | 34 | class Sound_Handler_Wav : public Sound_Handler { 35 | public: 36 | Sound_Handler_Wav(Sound_Channel* chan); 37 | ~Sound_Handler_Wav(); 38 | bool init(const char* filename); 39 | void update(); 40 | void rewind(); 41 | uint32_t getPos(); 42 | private: 43 | #if USE_SDFAT 44 | File file; 45 | #endif 46 | uint16_t head_index; 47 | uint32_t wav_offset; 48 | bool rewind_flag; 49 | }; 50 | 51 | } // namespace Gamebuino_Meta 52 | 53 | #endif // _GAMEBUINO_META_SOUND_SD_H_ 54 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound.h: -------------------------------------------------------------------------------- 1 | #include "Sound/Sound.h" 2 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound/Pattern.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_META_PATTERN_H_ 24 | #define _GAMEBUINO_META_PATTERN_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "Sound.h" 28 | 29 | namespace Gamebuino_Meta { 30 | 31 | class Sound_Handler_Pattern : public Sound_Handler { 32 | public: 33 | Sound_Handler_Pattern(Sound_Channel* chan, uint8_t* buffer); 34 | void update(); 35 | void rewind(); 36 | uint32_t getPos(); 37 | private: 38 | uint8_t patternCursor; 39 | uint8_t note_duration; 40 | }; 41 | 42 | }; // namespace Gamebuino_Meta 43 | 44 | #endif // _GAMEBUINO_META_PATTERN_H_ 45 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound/Raw.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #include "Raw.h" 24 | 25 | namespace Gamebuino_Meta { 26 | 27 | Sound_Handler_Raw::Sound_Handler_Raw(Sound_Channel* chan, uint8_t* _buffer, uint32_t _length) : Sound_Handler(chan) { 28 | buffer = _buffer; 29 | length = _length; 30 | rewind(); 31 | }; 32 | 33 | void Sound_Handler_Raw::update() { 34 | channel->buffer += channel->index; 35 | channel->index = 0; 36 | 37 | uint32_t cursor = getPos(); 38 | if (cursor + 0xFFFF > length) { 39 | channel->total = length - cursor; 40 | channel->last = true; 41 | } 42 | } 43 | 44 | void Sound_Handler_Raw::rewind() { 45 | channel->index = 0; 46 | channel->total = length > 0xFFFF ? 0xFFFF : length; 47 | channel->buffer = buffer; 48 | channel->type = Sound_Channel_Type::raw; 49 | if (length <= 0xFFFF) { 50 | channel->last = true; 51 | } 52 | 53 | channel->use = true; 54 | } 55 | 56 | uint32_t Sound_Handler_Raw::getPos() { 57 | return (uint32_t)channel->buffer - (uint32_t)buffer + channel->index; 58 | } 59 | 60 | }; // namespace Gamebuino_Meta 61 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound/Raw.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_META_SOUND_RAW_H_ 24 | #define _GAMEBUINO_META_SOUND_RAW_H_ 25 | 26 | #include "../../config/config.h" 27 | #include "Sound.h" 28 | 29 | namespace Gamebuino_Meta { 30 | 31 | class Sound_Handler_Raw : public Sound_Handler { 32 | public: 33 | Sound_Handler_Raw(Sound_Channel* chan, uint8_t* buffer, uint32_t lenght); 34 | void update(); 35 | void rewind(); 36 | uint32_t getPos(); 37 | private: 38 | uint8_t* buffer; 39 | uint32_t length; 40 | }; 41 | 42 | }; // namespace Gamebuino_Meta 43 | 44 | #endif // _GAMEBUINO_META_SOUND_RAW_H_ 45 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound/Tone.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #include "Tone.h" 24 | #include "../../Gamebuino-Meta.h" 25 | 26 | namespace Gamebuino_Meta { 27 | 28 | extern Gamebuino* gbptr; 29 | 30 | extern int8_t tone_identifier; 31 | 32 | Sound_Handler_Tone::Sound_Handler_Tone(Sound_Channel* chan, uint32_t frequency, int32_t duration, int8_t i) : Sound_Handler(chan) { 33 | channel->type = Sound_Channel_Type::square; 34 | channel->amplitude = 0x30; 35 | channel->total = 22050 / frequency; 36 | channel->index = 0; 37 | channel->buffer = (uint8_t*)duration; // that's what i call abusing 38 | identifier = i; 39 | channel->use = true; 40 | } 41 | 42 | Sound_Handler_Tone::~Sound_Handler_Tone() { 43 | if (tone_identifier == identifier) { 44 | tone_identifier = -1; 45 | } 46 | } 47 | 48 | void Sound_Handler_Tone::update() { 49 | if (channel->loop) { 50 | return; 51 | } 52 | int32_t duration = (int32_t)channel->buffer; 53 | duration -= gbptr->getTimePerFrame(); 54 | channel->buffer = (uint8_t*)duration; 55 | if (duration <= 0) { 56 | channel->use = false; 57 | if (tone_identifier == identifier) { 58 | tone_identifier = -1; 59 | } 60 | } 61 | } 62 | 63 | void Sound_Handler_Tone::rewind() { 64 | // trash 65 | } 66 | 67 | }; // namespace Gamebuino_Meta 68 | -------------------------------------------------------------------------------- /lib/Gamebuino-META-master/src/utility/Sound/Tone.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is part of the Gamebuino-Meta library, 3 | Copyright (c) Aadalie 2017 4 | 5 | This is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU Lesser General Public License (LGPL) 7 | as published by the Free Software Foundation, either version 3 of 8 | the License, or (at your option) any later version. 9 | 10 | This is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU Lesser General Public License (LGPL) for more details. 14 | 15 | You should have received a copy of the GNU Lesser General Public 16 | License (LGPL) along with the library. 17 | If not, see . 18 | 19 | Authors: 20 | - Sorunome 21 | */ 22 | 23 | #ifndef _GAMEBUINO_META_TONE_H_ 24 | #define _GAMEBUINO_META_TONE_H_ 25 | 26 | #include "Sound.h" 27 | #include "../../config/config.h" 28 | 29 | namespace Gamebuino_Meta { 30 | 31 | class Sound_Handler_Tone : public Sound_Handler { 32 | public: 33 | Sound_Handler_Tone(Sound_Channel* chan, uint32_t frequency, int32_t duration, int8_t i); 34 | ~Sound_Handler_Tone(); 35 | void update(); 36 | void rewind(); 37 | private: 38 | int8_t identifier; 39 | }; 40 | 41 | }; // namespace Gamebuino_Meta 42 | 43 | #endif // _GAMEBUINO_META_TONE_H_ 44 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | 7 | # Standard to msysgit 8 | *.doc diff=astextplain 9 | *.DOC diff=astextplain 10 | *.docx diff=astextplain 11 | *.DOCX diff=astextplain 12 | *.dot diff=astextplain 13 | *.DOT diff=astextplain 14 | *.pdf diff=astextplain 15 | *.PDF diff=astextplain 16 | *.rtf diff=astextplain 17 | *.RTF diff=astextplain 18 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/.gitignore: -------------------------------------------------------------------------------- 1 | # Windows image file caches 2 | Thumbs.db 3 | ehthumbs.db 4 | 5 | # Folder config file 6 | Desktop.ini 7 | 8 | # Recycle Bin used on file shares 9 | $RECYCLE.BIN/ 10 | 11 | # Windows Installer files 12 | *.cab 13 | *.msi 14 | *.msm 15 | *.msp 16 | 17 | # Windows shortcuts 18 | *.lnk 19 | 20 | # ========================= 21 | # Operating System Files 22 | # ========================= 23 | 24 | # OSX 25 | # ========================= 26 | 27 | .DS_Store 28 | .AppleDouble 29 | .LSOverride 30 | 31 | # Thumbnails 32 | ._* 33 | 34 | # Files that might appear in the root of a volume 35 | .DocumentRevisions-V100 36 | .fseventsd 37 | .Spotlight-V100 38 | .TemporaryItems 39 | .Trashes 40 | .VolumeIcon.icns 41 | 42 | # Directories potentially created on remote AFP share 43 | .AppleDB 44 | .AppleDesktop 45 | Network Trash Folder 46 | Temporary Items 47 | .apdisk 48 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Extensions/Button.h: -------------------------------------------------------------------------------- 1 | /*************************************************************************************** 2 | // The following button class has been ported over from the Adafruit_GFX library so 3 | // should be compatible. 4 | // A slightly different implementation in this TFT_eSPI library allows the button 5 | // legends to be in any font 6 | ***************************************************************************************/ 7 | 8 | class TFT_eSPI_Button { 9 | 10 | public: 11 | TFT_eSPI_Button(void); 12 | // "Classic" initButton() uses center & size 13 | void initButton(TFT_eSPI *gfx, int16_t x, int16_t y, 14 | uint16_t w, uint16_t h, uint16_t outline, uint16_t fill, 15 | uint16_t textcolor, char *label, uint8_t textsize); 16 | 17 | // New/alt initButton() uses upper-left corner & size 18 | void initButtonUL(TFT_eSPI *gfx, int16_t x1, int16_t y1, 19 | uint16_t w, uint16_t h, uint16_t outline, uint16_t fill, 20 | uint16_t textcolor, char *label, uint8_t textsize); 21 | void drawButton(bool inverted = false); 22 | bool contains(int16_t x, int16_t y); 23 | 24 | void press(bool p); 25 | bool isPressed(); 26 | bool justPressed(); 27 | bool justReleased(); 28 | 29 | private: 30 | TFT_eSPI *_gfx; 31 | int16_t _x1, _y1; // Coordinates of top-left corner 32 | uint16_t _w, _h; 33 | uint8_t _textsize; 34 | uint16_t _outlinecolor, _fillcolor, _textcolor; 35 | char _label[10]; 36 | 37 | bool currstate, laststate; 38 | }; 39 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Extensions/Smooth_font.h: -------------------------------------------------------------------------------- 1 | // Coded by Bodmer 10/2/18, see license in root directory. 2 | // This is part of the TFT_eSPI class and is associated with anti-aliased font functions 3 | 4 | public: 5 | 6 | // These are for the new antialiased fonts 7 | void loadFont(String fontName, fs::FS &ffs); 8 | void loadFont(String fontName, bool flash = true); 9 | void unloadFont( void ); 10 | bool getUnicodeIndex(uint16_t unicode, uint16_t *index); 11 | 12 | virtual void drawGlyph(uint16_t code); 13 | 14 | void showFont(uint32_t td); 15 | 16 | // This is for the whole font 17 | typedef struct 18 | { 19 | uint16_t gCount; // Total number of characters 20 | uint16_t yAdvance; // Line advance 21 | uint16_t spaceWidth; // Width of a space character 22 | int16_t ascent; // Height of top of 'd' above baseline, other characters may be taller 23 | int16_t descent; // Offset to bottom of 'p', other characters may have a larger descent 24 | uint16_t maxAscent; // Maximum ascent found in font 25 | uint16_t maxDescent; // Maximum descent found in font 26 | } fontMetrics; 27 | 28 | fontMetrics gFont = { 0, 0, 0, 0, 0, 0, 0 }; 29 | 30 | // These are for the metrics for each individual glyph (so we don't need to seek this in file and waste time) 31 | uint16_t* gUnicode = NULL; //UTF-16 code, the codes are searched so do not need to be sequential 32 | uint8_t* gHeight = NULL; //cheight 33 | uint8_t* gWidth = NULL; //cwidth 34 | uint8_t* gxAdvance = NULL; //setWidth 35 | int16_t* gdY = NULL; //topExtent 36 | int8_t* gdX = NULL; //leftExtent 37 | uint32_t* gBitmap = NULL; //file pointer to greyscale bitmap 38 | 39 | bool fontLoaded = false; // Flags when a anti-aliased font is loaded 40 | fs::File fontFile; 41 | 42 | private: 43 | 44 | void loadMetrics(uint16_t gCount); 45 | uint32_t readInt32(void); 46 | 47 | fs::FS &fontFS = SPIFFS; 48 | bool spiffs = true; -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Extensions/Touch.h: -------------------------------------------------------------------------------- 1 | // Coded by Bodmer 10/2/18, see license in root directory. 2 | // This is part of the TFT_eSPI class and is associated with the Touch Screen handlers 3 | 4 | public: 5 | // Get raw x,y ADC values from touch controller 6 | uint8_t getTouchRaw(uint16_t *x, uint16_t *y); 7 | // Get raw z (i.e. pressure) ADC value from touch controller 8 | uint16_t getTouchRawZ(void); 9 | // Convert raw x,y values to calibrated and correctly rotated screen coordinates 10 | void convertRawXY(uint16_t *x, uint16_t *y); 11 | // Get the screen touch coordinates, returns true if screen has been touched 12 | // if the touch cordinates are off screen then x and y are not updated 13 | uint8_t getTouch(uint16_t *x, uint16_t *y, uint16_t threshold = 600); 14 | 15 | // Run screen calibration and test, report calibration values to the serial port 16 | void calibrateTouch(uint16_t *data, uint32_t color_fg, uint32_t color_bg, uint8_t size); 17 | // Set the screen calibration values 18 | void setTouch(uint16_t *data); 19 | 20 | private: 21 | // Handlers for the SPI settings and clock speed change 22 | inline void spi_begin_touch() __attribute__((always_inline)); 23 | inline void spi_end_touch() __attribute__((always_inline)); 24 | 25 | // Private function to validate a touch, allow settle time and reduce spurious coordinates 26 | uint8_t validTouch(uint16_t *x, uint16_t *y, uint16_t threshold = 600); 27 | 28 | // Initialise with example calibration values so processor does not crash if setTouch() not called in setup() 29 | uint16_t touchCalibration_x0 = 300, touchCalibration_x1 = 3600, touchCalibration_y0 = 300, touchCalibration_y1 = 3600; 30 | uint8_t touchCalibration_rotate = 1, touchCalibration_invert_x = 2, touchCalibration_invert_y = 0; 31 | 32 | uint32_t _pressTime; // Press and hold time-out 33 | uint16_t _pressX, _pressY; // For future use (last sampled calibrated coordinates) 34 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/README.txt: -------------------------------------------------------------------------------- 1 | This is a standalone library that contains both graphics functions 2 | and the TFT chip driver library. 3 | 4 | This library has been derived from the Adafruit_GFX and driver library with 5 | further code from other authors. 6 | 7 | It is not compatible with legacy versions of the IDE (e.g. 1.0.6 and 8 | older. Use the latest version. 9 | 10 | New functions have been added in particular it contains proportional fonts 11 | in addition to the original Adafruit font. 12 | 13 | A sprite class has been added to aid the generation of flicker free complex 14 | graphics. 15 | 16 | Note: This version of the library might not be fully compatible with the 17 | original. 18 | 19 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/EPD_Defines.h: -------------------------------------------------------------------------------- 1 | // Null set for ePaper 2 | #define TFT_WIDTH 1000 3 | #define TFT_HEIGHT 1000 4 | 5 | #define TFT_INIT_DELAY 0 6 | 7 | #define TFT_NOP 0x00 8 | #define TFT_SWRST 0x00 9 | 10 | #define TFT_CASET 0x00 11 | #define TFT_PASET 0x00 12 | #define TFT_RAMWR 0x00 13 | 14 | #define TFT_RAMRD 0x00 15 | #define TFT_IDXRD 0x00 16 | 17 | #define TFT_MADCTL 0x00 18 | #define TFT_MAD_MY 0x00 19 | #define TFT_MAD_MX 0x00 20 | #define TFT_MAD_MV 0x00 21 | #define TFT_MAD_ML 0x00 22 | #define TFT_MAD_BGR 0x00 23 | #define TFT_MAD_MH 0x00 24 | #define TFT_MAD_RGB 0x00 25 | 26 | #define TFT_INVOFF 0x00 27 | #define TFT_INVON 0x00 28 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/HX8357D_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | 7 | // Delay between some initialisation commands 8 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 9 | 10 | 11 | // Generic commands used by TFT_eSPar.cpp 12 | #define TFT_NOP 0x00 13 | #define TFT_SWRST 0x01 14 | 15 | #define TFT_SLPIN 0x10 16 | #define TFT_SLPOUT 0x11 17 | 18 | #define TFT_INVOFF 0x20 19 | #define TFT_INVON 0x21 20 | 21 | #define TFT_DISPOFF 0x28 22 | #define TFT_DISPON 0x29 23 | 24 | #define TFT_CASET 0x2A 25 | #define TFT_PASET 0x2B 26 | #define TFT_RAMWR 0x2C 27 | 28 | #define TFT_RAMRD 0x2E 29 | 30 | #define TFT_MADCTL 0x36 31 | 32 | #define TFT_MAD_MY 0x80 33 | #define TFT_MAD_MX 0x40 34 | #define TFT_MAD_MV 0x20 35 | #define TFT_MAD_ML 0x10 36 | #define TFT_MAD_RGB 0x00 37 | #define TFT_MAD_BGR 0x08 38 | #define TFT_MAD_MH 0x04 39 | #define TFT_MAD_SS 0x02 40 | #define TFT_MAD_GS 0x01 41 | 42 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 43 | 44 | 45 | #define HX8357_NOP 0x00 46 | #define HX8357_SWRESET 0x01 47 | #define HX8357_RDDID 0x04 48 | #define HX8357_RDDST 0x09 49 | 50 | #define HX8357_RDPOWMODE 0x0A 51 | #define HX8357_RDMADCTL 0x0B 52 | #define HX8357_RDCOLMOD 0x0C 53 | #define HX8357_RDDIM 0x0D 54 | #define HX8357_RDDSDR 0x0F 55 | 56 | #define HX8357_SLPIN 0x10 57 | #define HX8357_SLPOUT 0x11 58 | 59 | #define HX8357_INVOFF 0x20 60 | #define HX8357_INVON 0x21 61 | #define HX8357_DISPOFF 0x28 62 | #define HX8357_DISPON 0x29 63 | 64 | #define HX8357_CASET 0x2A 65 | #define HX8357_PASET 0x2B 66 | #define HX8357_RAMWR 0x2C 67 | #define HX8357_RAMRD 0x2E 68 | 69 | #define HX8357_TEON 0x35 70 | #define HX8357_TEARLINE 0x44 71 | #define HX8357_MADCTL 0x36 72 | #define HX8357_COLMOD 0x3A 73 | 74 | #define HX8357_SETOSC 0xB0 75 | #define HX8357_SETPWR1 0xB1 76 | #define HX8357_SETRGB 0xB3 77 | #define HX8357D_SETCOM 0xB6 78 | 79 | #define HX8357D_SETCYC 0xB4 80 | #define HX8357D_SETC 0xB9 81 | 82 | #define HX8357D_SETSTBA 0xC0 83 | 84 | #define HX8357_SETPANEL 0xCC 85 | 86 | #define HX8357D_SETGAMMA 0xE0 87 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/HX8357D_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ILI9481 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_RGB); 8 | _width = TFT_WIDTH; 9 | _height = TFT_HEIGHT; 10 | break; 11 | case 1: // Landscape (Portrait + 90) 12 | writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_RGB); 13 | _width = TFT_HEIGHT; 14 | _height = TFT_WIDTH; 15 | break; 16 | case 2: // Inverter portrait 17 | writedata(TFT_MAD_RGB); 18 | _width = TFT_WIDTH; 19 | _height = TFT_HEIGHT; 20 | break; 21 | case 3: // Inverted landscape 22 | writedata(TFT_MAD_MX | TFT_MAD_MV | TFT_MAD_RGB); 23 | _width = TFT_HEIGHT; 24 | _height = TFT_WIDTH; 25 | break; 26 | } 27 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9163_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #ifndef TFT_WIDTH 4 | #define TFT_WIDTH 128 5 | #endif 6 | #ifndef TFT_HEIGHT 7 | #define TFT_HEIGHT 160 8 | #endif 9 | 10 | #if (TFT_HEIGHT == 128) && (TFT_WIDTH == 128) 11 | #define CGRAM_OFFSET 12 | #endif 13 | 14 | // Color definitions for backwards compatibility with old sketches 15 | // use colour definitions like TFT_BLACK to make sketches more portable 16 | #define ILI9163_BLACK 0x0000 /* 0, 0, 0 */ 17 | #define ILI9163_NAVY 0x000F /* 0, 0, 128 */ 18 | #define ILI9163_DARKGREEN 0x03E0 /* 0, 128, 0 */ 19 | #define ILI9163_DARKCYAN 0x03EF /* 0, 128, 128 */ 20 | #define ILI9163_MAROON 0x7800 /* 128, 0, 0 */ 21 | #define ILI9163_PURPLE 0x780F /* 128, 0, 128 */ 22 | #define ILI9163_OLIVE 0x7BE0 /* 128, 128, 0 */ 23 | #define ILI9163_LIGHTGREY 0xC618 /* 192, 192, 192 */ 24 | #define ILI9163_DARKGREY 0x7BEF /* 128, 128, 128 */ 25 | #define ILI9163_BLUE 0x001F /* 0, 0, 255 */ 26 | #define ILI9163_GREEN 0x07E0 /* 0, 255, 0 */ 27 | #define ILI9163_CYAN 0x07FF /* 0, 255, 255 */ 28 | #define ILI9163_RED 0xF800 /* 255, 0, 0 */ 29 | #define ILI9163_MAGENTA 0xF81F /* 255, 0, 255 */ 30 | #define ILI9163_YELLOW 0xFFE0 /* 255, 255, 0 */ 31 | #define ILI9163_WHITE 0xFFFF /* 255, 255, 255 */ 32 | #define ILI9163_ORANGE 0xFD20 /* 255, 165, 0 */ 33 | #define ILI9163_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ 34 | #define ILI9163_PINK 0xF81F 35 | 36 | 37 | // Delay between some initialisation commands 38 | #define TFT_INIT_DELAY 0x80 39 | 40 | 41 | // Generic commands used by TFT_eSPI.cpp 42 | #define TFT_NOP 0x00 43 | #define TFT_SWRST 0x01 44 | 45 | #define TFT_CASET 0x2A 46 | #define TFT_PASET 0x2B 47 | #define TFT_RAMWR 0x2C 48 | 49 | #define TFT_RAMRD 0x2E 50 | #define TFT_IDXRD 0x00 //0xDD // ILI9341 only, indexed control register read 51 | 52 | #define TFT_MADCTL 0x36 53 | #define TFT_MAD_MY 0x80 54 | #define TFT_MAD_MX 0x40 55 | #define TFT_MAD_MV 0x20 56 | #define TFT_MAD_ML 0x10 57 | #define TFT_MAD_BGR 0x08 58 | #define TFT_MAD_MH 0x04 59 | #define TFT_MAD_RGB 0x00 60 | 61 | #define TFT_INVOFF 0x20 62 | #define TFT_INVON 0x21 63 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9163_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the ILI9163 driver 3 | // 4 | // This setup information is in a format accecpted by the commandList() function 5 | // which reduces FLASH space, but on an ESP8266 there is plenty available! 6 | // 7 | // See ILI9341_Setup.h file for an alternative simpler format 8 | 9 | { 10 | // Initialization commands for ILI9163 screens 11 | static const uint8_t ILI9163_cmds[] PROGMEM = 12 | { 13 | 17, // 17 commands follow 14 | 0x01, 0 + TFT_INIT_DELAY, 120, // Software reset 15 | 0x11, 0 + TFT_INIT_DELAY, 5, // Exit sleep mode 16 | 0x3A, 1, 0x05, // Set pixel format 17 | 0x26, 1, 0x04, // Set Gamma curve 3 18 | 0xF2, 1, 0x01, // Gamma adjustment enabled 19 | 0xE0, 15, 0x3F, 0x25, 0x1C, 0x1E, 0x20, 0x12, 0x2A, 0x90, 20 | 0x24, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, // Positive Gamma 21 | 0xE1, 15, 0x20, 0x20, 0x20, 0x20, 0x05, 0x00, 0x15,0xA7, 22 | 0x3D, 0x18, 0x25, 0x2A, 0x2B, 0x2B, 0x3A, // Negative Gamma 23 | 0xB1, 2, 0x08, 0x08, // Frame rate control 1 24 | 0xB4, 1, 0x07, // Display inversion 25 | 0xC0, 2, 0x0A, 0x02, // Power control 1 26 | 0xC1, 1, 0x02, // Power control 2 27 | 0xC5, 2, 0x50, 0x5B, // Vcom control 1 28 | 0xC7, 1, 0x40, // Vcom offset 29 | 0x2A, 4, 0x00, 0x00, 0x00, 0x7F, // Set column address 30 | 0x2B, 4 + TFT_INIT_DELAY, 0x00, 0x00, 0x00, 0x9F, 250, // Set page address 31 | 0x36, 1, 0xC8, // Set address mode 32 | 0x29, 0, // Set display on 33 | }; 34 | 35 | commandList(ILI9163_cmds); 36 | 37 | #ifdef CGRAM_OFFSET 38 | colstart = 0; 39 | rowstart = 0; 40 | #endif 41 | } -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9163_Rotation.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that rotates the ILI9163 driver coordinate frame 3 | 4 | rotation = m % 4; 5 | 6 | writecommand(TFT_MADCTL); 7 | switch (rotation) { 8 | case 0: 9 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_BGR); 10 | _width = _init_width; 11 | _height = _init_height; 12 | #ifdef CGRAM_OFFSET 13 | colstart = 0; 14 | rowstart = 0; 15 | #endif 16 | break; 17 | case 1: 18 | writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_BGR); 19 | _width = _init_height; 20 | _height = _init_width; 21 | #ifdef CGRAM_OFFSET 22 | colstart = 0; 23 | rowstart = 0; 24 | #endif 25 | break; 26 | case 2: 27 | writedata(TFT_MAD_BGR); 28 | _width = _init_width; 29 | _height = _init_height; 30 | #ifdef CGRAM_OFFSET 31 | colstart = 0; 32 | rowstart = 32; 33 | #endif 34 | break; 35 | case 3: 36 | writedata(TFT_MAD_MX | TFT_MAD_MV | TFT_MAD_BGR); 37 | _width = _init_height; 38 | _height = _init_width; 39 | #ifdef CGRAM_OFFSET 40 | colstart = 32; 41 | rowstart = 0; 42 | #endif 43 | break; 44 | } 45 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9341_Rotation.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that rotates the ILI9341 driver coordinate frame 3 | 4 | rotation = m % 8; // Limit the range of values to 0-7 5 | 6 | writecommand(TFT_MADCTL); 7 | switch (rotation) { 8 | case 0: 9 | #ifdef M5STACK 10 | writedata(TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 11 | #else 12 | writedata(TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 13 | #endif 14 | _width = _init_width; 15 | _height = _init_height; 16 | break; 17 | case 1: 18 | #ifdef M5STACK 19 | writedata(TFT_MAD_COLOR_ORDER); 20 | #else 21 | writedata(TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 22 | #endif 23 | _width = _init_height; 24 | _height = _init_width; 25 | break; 26 | case 2: 27 | #ifdef M5STACK 28 | writedata(TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 29 | #else 30 | writedata(TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 31 | #endif 32 | _width = _init_width; 33 | _height = _init_height; 34 | break; 35 | case 3: 36 | #ifdef M5STACK 37 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 38 | #else 39 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 40 | #endif 41 | _width = _init_height; 42 | _height = _init_width; 43 | break; 44 | // These next rotations are for bottom up BMP drawing 45 | case 4: 46 | #ifdef M5STACK 47 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 48 | #else 49 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 50 | #endif 51 | _width = _init_width; 52 | _height = _init_height; 53 | break; 54 | case 5: 55 | #ifdef M5STACK 56 | writedata(TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 57 | #else 58 | writedata(TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 59 | #endif 60 | _width = _init_height; 61 | _height = _init_width; 62 | break; 63 | case 6: 64 | #ifdef M5STACK 65 | writedata(TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 66 | #else 67 | writedata(TFT_MAD_COLOR_ORDER); 68 | #endif 69 | _width = _init_width; 70 | _height = _init_height; 71 | break; 72 | case 7: 73 | #ifdef M5STACK 74 | writedata(TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 75 | #else 76 | writedata(TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 77 | #endif 78 | _width = _init_height; 79 | _height = _init_width; 80 | break; 81 | 82 | } 83 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9481_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | 7 | // Delay between some initialisation commands 8 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 9 | 10 | 11 | // Generic commands used by TFT_eSPI.cpp 12 | #define TFT_NOP 0x00 13 | #define TFT_SWRST 0x01 14 | 15 | #define TFT_SLPIN 0x10 16 | #define TFT_SLPOUT 0x11 17 | 18 | #define TFT_INVOFF 0x20 19 | #define TFT_INVON 0x21 20 | 21 | #define TFT_DISPOFF 0x28 22 | #define TFT_DISPON 0x29 23 | 24 | #define TFT_CASET 0x2A 25 | #define TFT_PASET 0x2B 26 | #define TFT_RAMWR 0x2C 27 | 28 | #define TFT_RAMRD 0x2E 29 | 30 | #define TFT_MADCTL 0x36 31 | 32 | #define TFT_MAD_MY 0x80 33 | #define TFT_MAD_MX 0x40 34 | #define TFT_MAD_MV 0x20 35 | #define TFT_MAD_ML 0x10 36 | #define TFT_MAD_RGB 0x00 37 | #define TFT_MAD_BGR 0x08 38 | #define TFT_MAD_MH 0x04 39 | #define TFT_MAD_SS 0x02 40 | #define TFT_MAD_GS 0x01 41 | 42 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 43 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9481_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the ILI9481 driver 3 | // 4 | // This setup information uses simple 8 bit SPI writecommand() and writedata() functions 5 | // 6 | // See ST7735_Setup.h file for an alternative format 7 | 8 | 9 | // Configure ILI9481 display 10 | 11 | writecommand(TFT_SLPOUT); 12 | delay(20); 13 | 14 | writecommand(0xD0); 15 | writedata(0x07); 16 | writedata(0x42); 17 | writedata(0x18); 18 | 19 | writecommand(0xD1); 20 | writedata(0x00); 21 | writedata(0x07); 22 | writedata(0x10); 23 | 24 | writecommand(0xD2); 25 | writedata(0x01); 26 | writedata(0x02); 27 | 28 | writecommand(0xC0); 29 | writedata(0x10); 30 | writedata(0x3B); 31 | writedata(0x00); 32 | writedata(0x02); 33 | writedata(0x11); 34 | 35 | writecommand(0xC5); 36 | writedata(0x03); 37 | 38 | writecommand(0xC8); 39 | writedata(0x00); 40 | writedata(0x32); 41 | writedata(0x36); 42 | writedata(0x45); 43 | writedata(0x06); 44 | writedata(0x16); 45 | writedata(0x37); 46 | writedata(0x75); 47 | writedata(0x77); 48 | writedata(0x54); 49 | writedata(0x0C); 50 | writedata(0x00); 51 | 52 | writecommand(TFT_MADCTL); 53 | writedata(0x0A); 54 | 55 | writecommand(0x3A); 56 | writedata(0x55); 57 | 58 | writecommand(TFT_CASET); 59 | writedata(0x00); 60 | writedata(0x00); 61 | writedata(0x01); 62 | writedata(0x3F); 63 | 64 | writecommand(TFT_PASET); 65 | writedata(0x00); 66 | writedata(0x00); 67 | writedata(0x01); 68 | writedata(0xDF); 69 | 70 | delay(120); 71 | writecommand(TFT_DISPON); 72 | 73 | delay(25); 74 | // End of ILI9481 display configuration 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9481_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ILI9481 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | writedata(TFT_MAD_BGR | TFT_MAD_SS); 8 | _width = TFT_WIDTH; 9 | _height = TFT_HEIGHT; 10 | break; 11 | case 1: // Landscape (Portrait + 90) 12 | writedata(TFT_MAD_MV | TFT_MAD_BGR); 13 | _width = TFT_HEIGHT; 14 | _height = TFT_WIDTH; 15 | break; 16 | case 2: // Inverter portrait 17 | writedata(TFT_MAD_BGR | TFT_MAD_GS); 18 | _width = TFT_WIDTH; 19 | _height = TFT_HEIGHT; 20 | break; 21 | case 3: // Inverted landscape 22 | writedata(TFT_MAD_MV | TFT_MAD_BGR | TFT_MAD_SS | TFT_MAD_GS); 23 | _width = TFT_HEIGHT; 24 | _height = TFT_WIDTH; 25 | break; 26 | } 27 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9486_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | // For Raspberry Pi ILI9486 only with a modified board to add a write strobe: 7 | #if defined (TFT_WR) && defined (RPI_ILI9486_DRIVER) 8 | #define RPI_WRITE_STROBE 9 | #endif 10 | 11 | // Color definitions for backwards compatibility with old sketches 12 | // use colour definitions like TFT_BLACK to make sketches more portable 13 | #define ILI9486_BLACK 0x0000 /* 0, 0, 0 */ 14 | #define ILI9486_NAVY 0x000F /* 0, 0, 128 */ 15 | #define ILI9486_DARKGREEN 0x03E0 /* 0, 128, 0 */ 16 | #define ILI9486_DARKCYAN 0x03EF /* 0, 128, 128 */ 17 | #define ILI9486_MAROON 0x7800 /* 128, 0, 0 */ 18 | #define ILI9486_PURPLE 0x780F /* 128, 0, 128 */ 19 | #define ILI9486_OLIVE 0x7BE0 /* 128, 128, 0 */ 20 | #define ILI9486_LIGHTGREY 0xC618 /* 192, 192, 192 */ 21 | #define ILI9486_DARKGREY 0x7BEF /* 128, 128, 128 */ 22 | #define ILI9486_BLUE 0x001F /* 0, 0, 255 */ 23 | #define ILI9486_GREEN 0x07E0 /* 0, 255, 0 */ 24 | #define ILI9486_CYAN 0x07FF /* 0, 255, 255 */ 25 | #define ILI9486_RED 0xF800 /* 255, 0, 0 */ 26 | #define ILI9486_MAGENTA 0xF81F /* 255, 0, 255 */ 27 | #define ILI9486_YELLOW 0xFFE0 /* 255, 255, 0 */ 28 | #define ILI9486_WHITE 0xFFFF /* 255, 255, 255 */ 29 | #define ILI9486_ORANGE 0xFD20 /* 255, 165, 0 */ 30 | #define ILI9486_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ 31 | #define ILI9486_PINK 0xF81F 32 | 33 | 34 | // Delay between some initialisation commands 35 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 36 | 37 | 38 | // Generic commands used by TFT_eSPI.cpp 39 | #define TFT_NOP 0x00 40 | #define TFT_SWRST 0x01 41 | 42 | #define TFT_CASET 0x2A 43 | #define TFT_PASET 0x2B 44 | #define TFT_RAMWR 0x2C 45 | 46 | #define TFT_RAMRD 0x2E 47 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 48 | 49 | #define TFT_MADCTL 0x36 50 | #define TFT_MAD_MY 0x80 51 | #define TFT_MAD_MX 0x40 52 | #define TFT_MAD_MV 0x20 53 | #define TFT_MAD_ML 0x10 54 | #define TFT_MAD_BGR 0x08 55 | #define TFT_MAD_MH 0x04 56 | #define TFT_MAD_SS 0x02 57 | #define TFT_MAD_GS 0x01 58 | #define TFT_MAD_RGB 0x00 59 | 60 | #define TFT_INVOFF 0x20 61 | #define TFT_INVON 0x21 62 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9486_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the ILI9486 driver 3 | // 4 | // This setup information uses simple 8 bit SPI writecommand() and writedata() functions 5 | // 6 | // See ST7735_Setup.h file for an alternative format 7 | 8 | { 9 | // From https://github.com/notro/fbtft/blob/master/fb_ili9486.c 10 | 11 | //writecommand(0x01); // SW reset 12 | //delay(120); 13 | 14 | writecommand(0x11); // Sleep out, also SW reset 15 | delay(120); 16 | 17 | writecommand(0x3A); 18 | writedata(0x55); 19 | 20 | writecommand(0xC2); 21 | writedata(0x44); 22 | 23 | writecommand(0xC5); 24 | writedata(0x00); 25 | writedata(0x00); 26 | writedata(0x00); 27 | writedata(0x00); 28 | 29 | writecommand(0xE0); 30 | writedata(0x0F); 31 | writedata(0x1F); 32 | writedata(0x1C); 33 | writedata(0x0C); 34 | writedata(0x0F); 35 | writedata(0x08); 36 | writedata(0x48); 37 | writedata(0x98); 38 | writedata(0x37); 39 | writedata(0x0A); 40 | writedata(0x13); 41 | writedata(0x04); 42 | writedata(0x11); 43 | writedata(0x0D); 44 | writedata(0x00); 45 | 46 | writecommand(0xE1); 47 | writedata(0x0F); 48 | writedata(0x32); 49 | writedata(0x2E); 50 | writedata(0x0B); 51 | writedata(0x0D); 52 | writedata(0x05); 53 | writedata(0x47); 54 | writedata(0x75); 55 | writedata(0x37); 56 | writedata(0x06); 57 | writedata(0x10); 58 | writedata(0x03); 59 | writedata(0x24); 60 | writedata(0x20); 61 | writedata(0x00); 62 | 63 | writecommand(0x20); // display inversion OFF 64 | 65 | writecommand(0x36); 66 | writedata(0x48); 67 | 68 | writecommand(0x29); // display on 69 | delay(150); 70 | } 71 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9486_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ILI9486 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 8; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | writedata(TFT_MAD_BGR | TFT_MAD_MX); 8 | _width = _init_width; 9 | _height = _init_height; 10 | break; 11 | case 1: // Landscape (Portrait + 90) 12 | writedata(TFT_MAD_BGR | TFT_MAD_MV); 13 | _width = _init_height; 14 | _height = _init_width; 15 | break; 16 | case 2: // Inverter portrait 17 | writedata( TFT_MAD_BGR | TFT_MAD_MY); 18 | _width = _init_width; 19 | _height = _init_height; 20 | break; 21 | case 3: // Inverted landscape 22 | writedata(TFT_MAD_BGR | TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_MY); 23 | _width = _init_height; 24 | _height = _init_width; 25 | break; 26 | case 4: // Portrait 27 | writedata(TFT_MAD_BGR | TFT_MAD_MX | TFT_MAD_MY); 28 | _width = _init_width; 29 | _height = _init_height; 30 | break; 31 | case 5: // Landscape (Portrait + 90) 32 | writedata(TFT_MAD_BGR | TFT_MAD_MV | TFT_MAD_MX); 33 | _width = _init_height; 34 | _height = _init_width; 35 | break; 36 | case 6: // Inverter portrait 37 | writedata( TFT_MAD_BGR); 38 | _width = _init_width; 39 | _height = _init_height; 40 | break; 41 | case 7: // Inverted landscape 42 | writedata(TFT_MAD_BGR | TFT_MAD_MV | TFT_MAD_MY); 43 | _width = _init_height; 44 | _height = _init_width; 45 | break; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9488_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | 7 | // Delay between some initialisation commands 8 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 9 | 10 | 11 | // Generic commands used by TFT_eSPI.cpp 12 | #define TFT_NOP 0x00 13 | #define TFT_SWRST 0x01 14 | 15 | #define TFT_SLPIN 0x10 16 | #define TFT_SLPOUT 0x11 17 | 18 | #define TFT_INVOFF 0x20 19 | #define TFT_INVON 0x21 20 | 21 | #define TFT_DISPOFF 0x28 22 | #define TFT_DISPON 0x29 23 | 24 | #define TFT_CASET 0x2A 25 | #define TFT_PASET 0x2B 26 | #define TFT_RAMWR 0x2C 27 | 28 | #define TFT_RAMRD 0x2E 29 | 30 | #define TFT_MADCTL 0x36 31 | 32 | #define TFT_MAD_MY 0x80 33 | #define TFT_MAD_MX 0x40 34 | #define TFT_MAD_MV 0x20 35 | #define TFT_MAD_ML 0x10 36 | #define TFT_MAD_RGB 0x00 37 | #define TFT_MAD_BGR 0x08 38 | #define TFT_MAD_MH 0x04 39 | #define TFT_MAD_SS 0x02 40 | #define TFT_MAD_GS 0x01 41 | 42 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 43 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ILI9488_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ILI9488 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | writedata(TFT_MAD_MX | TFT_MAD_BGR); 8 | _width = TFT_WIDTH; 9 | _height = TFT_HEIGHT; 10 | break; 11 | case 1: // Landscape (Portrait + 90) 12 | writedata(TFT_MAD_MV | TFT_MAD_BGR); 13 | _width = TFT_HEIGHT; 14 | _height = TFT_WIDTH; 15 | break; 16 | case 2: // Inverter portrait 17 | writedata(TFT_MAD_MY | TFT_MAD_BGR); 18 | _width = TFT_WIDTH; 19 | _height = TFT_HEIGHT; 20 | break; 21 | case 3: // Inverted landscape 22 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_BGR); 23 | _width = TFT_HEIGHT; 24 | _height = TFT_WIDTH; 25 | break; 26 | } 27 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/R61581_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | 7 | // Delay between some initialisation commands 8 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 9 | 10 | 11 | // Generic commands used by TFT_eSPI.cpp 12 | #define TFT_NOP 0x00 13 | #define TFT_SWRST 0x01 14 | 15 | #define TFT_SLPIN 0x10 16 | #define TFT_SLPOUT 0x11 17 | 18 | #define TFT_INVOFF 0x20 19 | #define TFT_INVON 0x21 20 | 21 | #define TFT_DISPOFF 0x28 22 | #define TFT_DISPON 0x29 23 | 24 | #define TFT_CASET 0x2A 25 | #define TFT_PASET 0x2B 26 | #define TFT_RAMWR 0x2C 27 | 28 | #define TFT_RAMRD 0x2E 29 | 30 | #define TFT_MADCTL 0x36 31 | 32 | #define TFT_MAD_MY 0x80 33 | #define TFT_MAD_MX 0x40 34 | #define TFT_MAD_MV 0x20 35 | #define TFT_MAD_ML 0x10 36 | #define TFT_MAD_RGB 0x00 37 | #define TFT_MAD_BGR 0x08 38 | #define TFT_MAD_MH 0x04 39 | #define TFT_MAD_SS 0x02 40 | #define TFT_MAD_GS 0x01 41 | 42 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 43 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/R61581_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the R61581 driver 3 | // 4 | // This setup information uses simple 8 bit SPI writecommand() and writedata() functions 5 | // 6 | // See ST7735_Setup.h file for an alternative format 7 | 8 | 9 | // Configure R61581 display 10 | 11 | writecommand(TFT_SLPOUT); 12 | delay(20); 13 | 14 | writecommand(0xB0); 15 | writedata(0x00); 16 | 17 | writecommand(0xD0); 18 | writedata(0x07); 19 | writedata(0x42); 20 | writedata(0x18); 21 | 22 | writecommand(0xD1); 23 | writedata(0x00); 24 | writedata(0x07); 25 | writedata(0x10); 26 | 27 | writecommand(0xD2); 28 | writedata(0x01); 29 | writedata(0x02); 30 | 31 | writecommand(0xC0); 32 | writedata(0x12); 33 | writedata(0x3B); 34 | writedata(0x00); 35 | writedata(0x02); 36 | writedata(0x11); 37 | 38 | writecommand(0xC5); 39 | writedata(0x03); 40 | 41 | writecommand(0xC8); 42 | writedata(0x00); 43 | writedata(0x32); 44 | writedata(0x36); 45 | writedata(0x45); 46 | writedata(0x06); 47 | writedata(0x16); 48 | writedata(0x37); 49 | writedata(0x75); 50 | writedata(0x77); 51 | writedata(0x54); 52 | writedata(0x0C); 53 | writedata(0x00); 54 | 55 | writecommand(TFT_MADCTL); 56 | writedata(0x0A); 57 | 58 | writecommand(0x3A); 59 | writedata(0x55); 60 | 61 | writecommand(TFT_CASET); 62 | writedata(0x00); 63 | writedata(0x00); 64 | writedata(0x01); 65 | writedata(0x3F); 66 | 67 | writecommand(TFT_PASET); 68 | writedata(0x00); 69 | writedata(0x00); 70 | writedata(0x01); 71 | writedata(0xDF); 72 | 73 | delay(120); 74 | writecommand(TFT_DISPON); 75 | 76 | delay(25); 77 | // End of R61581 display configuration 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/R61581_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the R61581 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | writedata(TFT_MAD_BGR | TFT_MAD_MX); 8 | _width = TFT_WIDTH; 9 | _height = TFT_HEIGHT; 10 | break; 11 | case 1: // Landscape (Portrait + 90) 12 | writedata(TFT_MAD_MV | TFT_MAD_BGR); 13 | _width = TFT_HEIGHT; 14 | _height = TFT_WIDTH; 15 | break; 16 | case 2: // Inverter portrait 17 | writedata(TFT_MAD_BGR | TFT_MAD_GS); 18 | _width = TFT_WIDTH; 19 | _height = TFT_HEIGHT; 20 | break; 21 | case 3: // Inverted landscape 22 | writedata(TFT_MAD_MV | TFT_MAD_BGR | TFT_MAD_MX | TFT_MAD_GS); 23 | _width = TFT_HEIGHT; 24 | _height = TFT_WIDTH; 25 | break; 26 | } 27 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/RM68140_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 320 4 | #define TFT_HEIGHT 480 5 | 6 | 7 | // Delay between some initialisation commands 8 | #define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked 9 | 10 | 11 | // Generic commands used by TFT_eSPI.cpp 12 | #define TFT_NOP 0x00 13 | #define TFT_SWRST 0x01 14 | 15 | #define TFT_SLPIN 0x10 16 | #define TFT_SLPOUT 0x11 17 | 18 | #define TFT_INVOFF 0x20 19 | #define TFT_INVON 0x21 20 | 21 | #define TFT_DISPOFF 0x28 22 | #define TFT_DISPON 0x29 23 | 24 | #define TFT_CASET 0x2A 25 | #define TFT_PASET 0x2B 26 | #define TFT_RAMWR 0x2C 27 | 28 | #define TFT_RAMRD 0x2E 29 | 30 | #define TFT_MADCTL 0x36 31 | 32 | #define TFT_MAD_MY 0x80 33 | #define TFT_MAD_MX 0x40 34 | #define TFT_MAD_MV 0x20 35 | #define TFT_MAD_ML 0x10 36 | #define TFT_MAD_RGB 0x00 37 | #define TFT_MAD_BGR 0x08 38 | #define TFT_MAD_MH 0x04 39 | #define TFT_MAD_SS 0x02 40 | #define TFT_MAD_GS 0x01 41 | 42 | #define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read 43 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/RM68140_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the RM68140 driver 3 | // 4 | // This setup information uses simple 8 bit SPI writecommand() and writedata() functions 5 | // 6 | // See ST7735_Setup.h file for an alternative format 7 | 8 | 9 | // Configure RM68140 display 10 | 11 | writecommand(TFT_SLPOUT); 12 | delay(20); 13 | 14 | writecommand(0xD0); 15 | writedata(0x07); 16 | writedata(0x42); 17 | writedata(0x18); 18 | 19 | writecommand(0xD1); 20 | writedata(0x00); 21 | writedata(0x07); 22 | writedata(0x10); 23 | 24 | writecommand(0xD2); 25 | writedata(0x01); 26 | writedata(0x02); 27 | 28 | writecommand(0xC0); 29 | writedata(0x10); 30 | writedata(0x3B); 31 | writedata(0x00); 32 | writedata(0x02); 33 | writedata(0x11); 34 | 35 | writecommand(0xC5); 36 | writedata(0x03); 37 | 38 | writecommand(0xC8); 39 | writedata(0x00); 40 | writedata(0x32); 41 | writedata(0x36); 42 | writedata(0x45); 43 | writedata(0x06); 44 | writedata(0x16); 45 | writedata(0x37); 46 | writedata(0x75); 47 | writedata(0x77); 48 | writedata(0x54); 49 | writedata(0x0C); 50 | writedata(0x00); 51 | 52 | writecommand(TFT_MADCTL); 53 | writedata(0x0A); 54 | 55 | writecommand(0x3A); 56 | writedata(0x55); 57 | 58 | writecommand(TFT_CASET); 59 | writedata(0x00); 60 | writedata(0x00); 61 | writedata(0x01); 62 | writedata(0x3F); 63 | 64 | writecommand(TFT_PASET); 65 | writedata(0x00); 66 | writedata(0x00); 67 | writedata(0x01); 68 | writedata(0xDF); 69 | 70 | delay(120); 71 | writecommand(TFT_DISPON); 72 | 73 | delay(25); 74 | // End of RM68140 display configuration 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/RM68140_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the RM68140 driver coordinate frame 2 | 3 | 4 | writecommand(TFT_MADCTL); 5 | rotation = m % 4; 6 | switch (rotation) { 7 | case 0: // Portrait 8 | writedata(TFT_MAD_BGR); 9 | writecommand(0xB6); 10 | writedata(0); 11 | writedata(0x22); 12 | writedata(0x3B); 13 | _width = TFT_WIDTH; 14 | _height = TFT_HEIGHT; 15 | break; 16 | case 1: // Landscape (Portrait + 90) 17 | writedata(TFT_MAD_MV | TFT_MAD_BGR); 18 | writecommand(0xB6); 19 | writedata(0); 20 | writedata(0x02); 21 | writedata(0x3B); 22 | _width = TFT_HEIGHT; 23 | _height = TFT_WIDTH; 24 | break; 25 | case 2: // Inverter portrait 26 | writedata(TFT_MAD_BGR); 27 | writecommand(0xB6); 28 | writedata(0); 29 | writedata(0x42); 30 | writedata(0x3B); 31 | _width = TFT_WIDTH; 32 | _height = TFT_HEIGHT; 33 | break; 34 | case 3: // Inverted landscape 35 | writedata(TFT_MAD_MV | TFT_MAD_BGR); 36 | writecommand(0xB6); 37 | writedata(0); 38 | writedata(0x62); 39 | writedata(0x3B); 40 | _width = TFT_HEIGHT; 41 | _height = TFT_WIDTH; 42 | break; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/S6D02A1_Defines.h: -------------------------------------------------------------------------------- 1 | // Change the width and height if required (defined in portrait mode) 2 | // or use the constructor to over-ride defaults 3 | #define TFT_WIDTH 128 4 | #define TFT_HEIGHT 160 5 | 6 | 7 | // Color definitions for backwards compatibility with old sketches 8 | // use colour definitions like TFT_BLACK to make sketches more portable 9 | #define S6D02A1_BLACK 0x0000 /* 0, 0, 0 */ 10 | #define S6D02A1_NAVY 0x000F /* 0, 0, 128 */ 11 | #define S6D02A1_DARKGREEN 0x03E0 /* 0, 128, 0 */ 12 | #define S6D02A1_DARKCYAN 0x03EF /* 0, 128, 128 */ 13 | #define S6D02A1_MAROON 0x7800 /* 128, 0, 0 */ 14 | #define S6D02A1_PURPLE 0x780F /* 128, 0, 128 */ 15 | #define S6D02A1_OLIVE 0x7BE0 /* 128, 128, 0 */ 16 | #define S6D02A1_LIGHTGREY 0xC618 /* 192, 192, 192 */ 17 | #define S6D02A1_DARKGREY 0x7BEF /* 128, 128, 128 */ 18 | #define S6D02A1_BLUE 0x001F /* 0, 0, 255 */ 19 | #define S6D02A1_GREEN 0x07E0 /* 0, 255, 0 */ 20 | #define S6D02A1_CYAN 0x07FF /* 0, 255, 255 */ 21 | #define S6D02A1_RED 0xF800 /* 255, 0, 0 */ 22 | #define S6D02A1_MAGENTA 0xF81F /* 255, 0, 255 */ 23 | #define S6D02A1_YELLOW 0xFFE0 /* 255, 255, 0 */ 24 | #define S6D02A1_WHITE 0xFFFF /* 255, 255, 255 */ 25 | #define S6D02A1_ORANGE 0xFD20 /* 255, 165, 0 */ 26 | #define S6D02A1_GREENYELLOW 0xAFE5 /* 173, 255, 47 */ 27 | #define S6D02A1_PINK 0xF81F 28 | 29 | 30 | // Delay between some initialisation commands 31 | #define TFT_INIT_DELAY 0x80 32 | 33 | 34 | // Generic commands used by TFT_eSPI.cpp 35 | #define TFT_NOP 0x00 36 | #define TFT_SWRST 0x01 37 | 38 | #define TFT_CASET 0x2A 39 | #define TFT_PASET 0x2B 40 | #define TFT_RAMWR 0x2C 41 | 42 | #define TFT_RAMRD 0x2E 43 | #define TFT_IDXRD 0x00 //0xDD // ILI9341 only, indexed control register read 44 | 45 | #define TFT_MADCTL 0x36 46 | #define TFT_MAD_MY 0x80 47 | #define TFT_MAD_MX 0x40 48 | #define TFT_MAD_MV 0x20 49 | #define TFT_MAD_ML 0x10 50 | #define TFT_MAD_BGR 0x08 51 | #define TFT_MAD_MH 0x04 52 | #define TFT_MAD_RGB 0x00 53 | 54 | #define TFT_INVOFF 0x20 55 | #define TFT_INVON 0x21 56 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/S6D02A1_Rotation.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that rotates the S6D02A1 driver coordinate frame 3 | 4 | rotation = m % 4; 5 | 6 | writecommand(TFT_MADCTL); 7 | switch (rotation) { 8 | case 0: 9 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_BGR); 10 | _width = _init_width; 11 | _height = _init_height; 12 | break; 13 | case 1: 14 | writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_BGR); 15 | _width = _init_height; 16 | _height = _init_width; 17 | break; 18 | case 2: 19 | writedata(TFT_MAD_BGR); 20 | _width = _init_width; 21 | _height = _init_height; 22 | break; 23 | case 3: 24 | writedata(TFT_MAD_MX | TFT_MAD_MV | TFT_MAD_BGR); 25 | _width = _init_height; 26 | _height = _init_width; 27 | break; 28 | } 29 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ST7789_2_Init.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that initialises the ST7789 driver 3 | 4 | // Configure ST7789 display 5 | 6 | { 7 | static const uint8_t PROGMEM 8 | st7789[] = { 9 | 8, 10 | TFT_SLPOUT, TFT_INIT_DELAY, 255, 11 | TFT_COLMOD, 1+TFT_INIT_DELAY, 0x55, 10, 12 | TFT_MADCTL, 1, 0x00, 13 | TFT_CASET, 4, 0x00, 0x00, 0x00, 0xF0, 14 | TFT_PASET, 4, 0x00, 0x00, 0x00, 0xF0, 15 | TFT_INVON, TFT_INIT_DELAY, 10, 16 | TFT_NORON, TFT_INIT_DELAY, 10, 17 | TFT_DISPON, TFT_INIT_DELAY, 255 18 | }; 19 | 20 | commandList(st7789); 21 | } 22 | // End of ST7789 display configuration -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ST7789_2_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ST7789 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | #ifdef CGRAM_OFFSET 8 | colstart = 0; 9 | rowstart = 0; 10 | #endif 11 | writedata(TFT_MAD_COLOR_ORDER); 12 | 13 | _width = _init_width; 14 | _height = _init_height; 15 | break; 16 | 17 | case 1: // Landscape (Portrait + 90) 18 | #ifdef CGRAM_OFFSET 19 | colstart = 0; 20 | rowstart = 0; 21 | #endif 22 | writedata(TFT_MAD_MX | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 23 | 24 | _width = _init_height; 25 | _height = _init_width; 26 | break; 27 | 28 | case 2: // Inverter portrait 29 | #ifdef CGRAM_OFFSET 30 | colstart = 0; 31 | rowstart = 80; 32 | #endif 33 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 34 | 35 | _width = _init_width; 36 | _height = _init_height; 37 | break; 38 | case 3: // Inverted landscape 39 | #ifdef CGRAM_OFFSET 40 | colstart = 80; 41 | rowstart = 0; 42 | #endif 43 | writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 44 | 45 | _width = _init_height; 46 | _height = _init_width; 47 | break; 48 | } 49 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ST7789_Rotation.h: -------------------------------------------------------------------------------- 1 | // This is the command sequence that rotates the ST7789 driver coordinate frame 2 | 3 | writecommand(TFT_MADCTL); 4 | rotation = m % 4; 5 | switch (rotation) { 6 | case 0: // Portrait 7 | #ifdef CGRAM_OFFSET 8 | if (_init_width == 135) 9 | { 10 | colstart = 52; 11 | rowstart = 40; 12 | } 13 | else 14 | { 15 | colstart = 0; 16 | rowstart = 0; 17 | } 18 | #endif 19 | writedata(TFT_MAD_COLOR_ORDER); 20 | 21 | _width = _init_width; 22 | _height = _init_height; 23 | break; 24 | 25 | case 1: // Landscape (Portrait + 90) 26 | #ifdef CGRAM_OFFSET 27 | if (_init_width == 135) 28 | { 29 | colstart = 40; 30 | rowstart = 53; 31 | } 32 | else 33 | { 34 | colstart = 0; 35 | rowstart = 0; 36 | } 37 | #endif 38 | writedata(TFT_MAD_MX | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 39 | 40 | _width = _init_height; 41 | _height = _init_width; 42 | break; 43 | 44 | case 2: // Inverter portrait 45 | #ifdef CGRAM_OFFSET 46 | if (_init_width == 135) 47 | { 48 | colstart = 53; 49 | rowstart = 40; 50 | } 51 | else 52 | { 53 | colstart = 0; 54 | rowstart = 80; 55 | } 56 | #endif 57 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 58 | 59 | _width = _init_width; 60 | _height = _init_height; 61 | break; 62 | case 3: // Inverted landscape 63 | #ifdef CGRAM_OFFSET 64 | if (_init_width == 135) 65 | { 66 | colstart = 40; 67 | rowstart = 52; 68 | } 69 | else 70 | { 71 | colstart = 80; 72 | rowstart = 0; 73 | } 74 | #endif 75 | writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 76 | 77 | _width = _init_height; 78 | _height = _init_width; 79 | break; 80 | } 81 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/TFT_Drivers/ST7796_Rotation.h: -------------------------------------------------------------------------------- 1 | 2 | // This is the command sequence that rotates the ST7796 driver coordinate frame 3 | 4 | rotation = m % 8; // Limit the range of values to 0-7 5 | 6 | writecommand(TFT_MADCTL); 7 | switch (rotation) { 8 | case 0: 9 | writedata(TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 10 | _width = _init_width; 11 | _height = _init_height; 12 | break; 13 | case 1: 14 | writedata(TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 15 | _width = _init_height; 16 | _height = _init_width; 17 | break; 18 | case 2: 19 | writedata(TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 20 | _width = _init_width; 21 | _height = _init_height; 22 | break; 23 | case 3: 24 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 25 | _width = _init_height; 26 | _height = _init_width; 27 | break; 28 | // These next rotations are for bottom up BMP drawing 29 | case 4: 30 | writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER); 31 | _width = _init_width; 32 | _height = _init_height; 33 | break; 34 | case 5: 35 | writedata(TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_COLOR_ORDER); 36 | _width = _init_height; 37 | _height = _init_width; 38 | break; 39 | case 6: 40 | writedata(TFT_MAD_COLOR_ORDER); 41 | _width = _init_width; 42 | _height = _init_height; 43 | break; 44 | case 7: 45 | writedata(TFT_MAD_MY | TFT_MAD_MV | TFT_MAD_COLOR_ORDER); 46 | _width = _init_height; 47 | _height = _init_width; 48 | break; 49 | 50 | } 51 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/Create_Smooth_Font/Create_font/FontFiles/Final-Frontier28.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/Create_Smooth_Font/Create_font/FontFiles/Final-Frontier28.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/Create_Smooth_Font/Create_font/data/Final-Frontier.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/Create_Smooth_Font/Create_font/data/Final-Frontier.ttf -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/ESP32 UNO board mod/ESP32 UNO board mod.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/ESP32 UNO board mod/ESP32 UNO board mod.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/ESP32 UNO board mod/ESP32 UNO board pinout.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/ESP32 UNO board mod/ESP32 UNO board pinout.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/PlatformIO/Configuring options.txt: -------------------------------------------------------------------------------- 1 | PlatformIO User notes: 2 | 3 | It is possible to load settings from the calling program rather than modifying 4 | the library for each project by modifying the "platformio.ini" file. 5 | 6 | The User_Setup_Select.h file will not load the user setting header files if 7 | USER_SETUP_LOADED is defined. 8 | 9 | Instead of using #define, use the -D prefix, for example: 10 | 11 | [env:esp32dev] 12 | platform = https://github.com/platformio/platform-espressif32.git#feature/stage 13 | board = esp32dev 14 | framework = arduino 15 | upload_port = ESP32-Test-2481CE9C.local 16 | 17 | build_flags = 18 | -Os 19 | -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG 20 | -DUSER_SETUP_LOADED=1 21 | -DILI9163_DRIVER=1 22 | -DTFT_WIDTH=128 23 | -DTFT_HEIGHT=160 24 | -DTFT_MISO=19 25 | -DTFT_MOSI=23 26 | -DTFT_SCLK=18 27 | -DTFT_CS=5 28 | -DTFT_DC=19 29 | -DTFT_RST=-1 30 | -DLOAD_GLCD=1 31 | -DSPI_FREQUENCY=27000000 32 | 33 | lib_extra_dirs = B:\Projects\ESP32\ESP32Lib 34 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/RPi_TFT_Connections.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/RPi_TFT_Connections.png -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/Tools/RPi_TFT_mod.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/Tools/RPi_TFT_mod.png -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup10_RPi_touch_ILI9486.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define RPI_ILI9486_DRIVER // 20MHz maximum SPI 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | #define TOUCH_CS PIN_D1 // Chip select pin (T_CS) of touch screen 13 | 14 | 15 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 16 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 17 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 18 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 19 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 20 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 21 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 22 | 23 | #define SMOOTH_FONT 24 | 25 | 26 | #define SPI_FREQUENCY 16000000 27 | 28 | #define SPI_TOUCH_FREQUENCY 2500000 29 | 30 | 31 | // #define SUPPORT_TRANSACTIONS 32 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup11_RPi_touch_ILI9486.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define RPI_ILI9486_DRIVER // 20MHz maximum SPI 4 | 5 | 6 | #define TFT_MISO 19 7 | #define TFT_MOSI 23 8 | #define TFT_SCLK 18 9 | #define TFT_CS 15 // Chip select control pin 10 | #define TFT_DC 2 // Data Command control pin 11 | #define TFT_RST 4 // Reset pin (could connect to RST pin) 12 | //#define TFT_RST -1 // Set TFT_RST to -1 if display RESET is connected to ESP32 board RST 13 | 14 | #define TOUCH_CS 22 // Chip select pin (T_CS) of touch screen 15 | 16 | 17 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 18 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 19 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 20 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 21 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 22 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 23 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 24 | 25 | #define SMOOTH_FONT 26 | 27 | 28 | #define SPI_FREQUENCY 20000000 29 | 30 | #define SPI_TOUCH_FREQUENCY 2500000 31 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup12_M5Stack.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9341_DRIVER 4 | 5 | 6 | #define M5STACK 7 | 8 | 9 | #define TFT_MISO 19 10 | #define TFT_MOSI 23 11 | #define TFT_SCLK 18 12 | #define TFT_CS 14 // Chip select control pin 13 | #define TFT_DC 27 // Data Command control pin 14 | #define TFT_RST 33 // Reset pin (could connect to Arduino RESET pin) 15 | #define TFT_BL 32 // LED back-light 16 | 17 | 18 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 19 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 20 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 21 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 22 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 23 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 24 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 25 | 26 | #define SMOOTH_FONT 27 | 28 | 29 | #define SPI_FREQUENCY 27000000 30 | 31 | // Optional reduced SPI frequency for reading TFT 32 | #define SPI_READ_FREQUENCY 5000000 -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup135_ST7789.h: -------------------------------------------------------------------------------- 1 | // ST7789 135 x 240 display with no chip select line 2 | 3 | #define ST7789_DRIVER // Configure all registers 4 | 5 | #define TFT_WIDTH 135 6 | #define TFT_HEIGHT 240 7 | 8 | #define CGRAM_OFFSET // Library will add offsets required 9 | 10 | //#define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue 11 | //#define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red 12 | 13 | //#define TFT_INVERSION_ON 14 | //#define TFT_INVERSION_OFF 15 | 16 | // DSTIKE stepup 17 | //#define TFT_DC 23 18 | //#define TFT_RST 32 19 | //#define TFT_MOSI 26 20 | //#define TFT_SCLK 27 21 | 22 | // Generic ESP32 setup 23 | //#define TFT_MISO 19 24 | //#define TFT_MOSI 23 25 | //#define TFT_SCLK 18 26 | //#define TFT_CS -1 // Not connected 27 | //#define TFT_DC 2 28 | //#define TFT_RST 4 // Connect reset to ensure display initialises 29 | 30 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 31 | #define TFT_CS -1 // Define as not used 32 | #define TFT_DC PIN_D1 // Data Command control pin 33 | //#define TFT_RST PIN_D4 // TFT reset pin (could connect to NodeMCU RST, see next line) 34 | #define TFT_RST -1 // TFT reset pin connect to NodeMCU RST, must also then add 10K pull down to TFT SCK 35 | 36 | 37 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 38 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 39 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 40 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 41 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 42 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 43 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 44 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 45 | 46 | #define SMOOTH_FONT 47 | 48 | 49 | // #define SPI_FREQUENCY 27000000 50 | #define SPI_FREQUENCY 40000000 51 | 52 | #define SPI_READ_FREQUENCY 20000000 53 | 54 | #define SPI_TOUCH_FREQUENCY 2500000 55 | 56 | // #define SUPPORT_TRANSACTIONS -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup13_ILI9481_Parallel.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ESP32_PARALLEL 4 | 5 | 6 | #define ILI9481_DRIVER 7 | 8 | 9 | // ESP32 pins used for UNO format board 10 | #define TFT_CS 33 // Chip select control pin 11 | #define TFT_DC 15 // Data Command control pin - must use a pin in the range 0-31 12 | #define TFT_RST 32 // Reset pin 13 | 14 | #define TFT_WR 4 // Write strobe control pin - must use a pin in the range 0-31 15 | #define TFT_RD 2 16 | 17 | #define TFT_D0 12 // Must use pins in the range 0-31 for the data bus 18 | #define TFT_D1 13 // so a single register write sets/clears all bits 19 | #define TFT_D2 26 20 | #define TFT_D3 25 21 | #define TFT_D4 17 22 | #define TFT_D5 16 23 | #define TFT_D6 27 24 | #define TFT_D7 14 25 | 26 | 27 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 28 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 29 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 30 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 31 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 32 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 33 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 34 | 35 | #define SMOOTH_FONT 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup14_ILI9341_Parallel.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ESP32_PARALLEL 4 | 5 | 6 | #define ILI9341_DRIVER 7 | 8 | 9 | // ESP32 pins used for the parallel interface TFT 10 | #define TFT_CS 33 // Chip select control pin 11 | #define TFT_DC 15 // Data Command control pin - must use a pin in the range 0-31 12 | #define TFT_RST 32 // Reset pin 13 | 14 | #define TFT_WR 4 // Write strobe control pin - must use a pin in the range 0-31 15 | #define TFT_RD 2 16 | 17 | #define TFT_D0 12 // Must use pins in the range 0-31 for the data bus 18 | #define TFT_D1 13 // so a single register write sets/clears all bits 19 | #define TFT_D2 26 20 | #define TFT_D3 25 21 | #define TFT_D4 17 22 | #define TFT_D5 16 23 | #define TFT_D6 27 24 | #define TFT_D7 14 25 | 26 | 27 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 28 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 29 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 30 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 31 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 32 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 33 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 34 | 35 | #define SMOOTH_FONT 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup15_HX8357D.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define HX8357D_DRIVER 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | 13 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 14 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 15 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 16 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 17 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 18 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 19 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 20 | 21 | #define SMOOTH_FONT 22 | 23 | 24 | // #define SPI_FREQUENCY 20000000 25 | #define SPI_FREQUENCY 27000000 26 | // #define SPI_FREQUENCY 40000000 27 | 28 | #define SPI_TOUCH_FREQUENCY 2500000 29 | 30 | 31 | // #define SUPPORT_TRANSACTIONS 32 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup16_ILI9488_Parallel.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ESP32_PARALLEL 4 | 5 | 6 | #define ILI9488_DRIVER 7 | 8 | 9 | // ESP32 pins used 10 | #define TFT_CS 33 // Chip select control pin 11 | #define TFT_DC 15 // Data Command control pin - must use a pin in the range 0-31 12 | #define TFT_RST 32 // Reset pin 13 | 14 | #define TFT_WR 4 // Write strobe control pin - must use a pin in the range 0-31 15 | #define TFT_RD 2 16 | 17 | #define TFT_D0 12 // Must use pins in the range 0-31 for the data bus 18 | #define TFT_D1 13 // so a single register write sets/clears all bits 19 | #define TFT_D2 26 20 | #define TFT_D3 25 21 | #define TFT_D4 17 22 | #define TFT_D5 16 23 | #define TFT_D6 27 24 | #define TFT_D7 14 25 | 26 | 27 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 28 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 29 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 30 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 31 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 32 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 33 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 34 | 35 | #define SMOOTH_FONT 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup17_ePaper.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define EPD_DRIVER // ePaper driver 4 | 5 | 6 | // READ THIS READ THIS READ THIS READ THIS READ THIS READ THIS 7 | // Install the ePaper library for your own display size and type 8 | // from here: 9 | // https://github.com/Bodmer/EPD_Libraries 10 | 11 | // Note: Pin allocations for the ePaper signals are defined in 12 | // the ePaper library's epdif.h file. There follows the default 13 | // pins already included in epdif.h file for the ESP8266: 14 | 15 | /////////////////////////////////////////////////////////////////// 16 | // For ESP8266 connect as follows: // 17 | // Display 3.3V to NodeMCU 3V3 // 18 | // Display GND to NodeMCU GND // 19 | // // 20 | // Display GPIO NodeMCU pin // 21 | // BUSY 5 D1 // 22 | // RESET 4 D2 // 23 | // DC 0 D3 // 24 | // CS 2 D4 // 25 | // CLK 14 D5 // 26 | // D6 (MISO not connected to display) // 27 | // DIN 13 D7 // 28 | // // 29 | /////////////////////////////////////////////////////////////////// 30 | 31 | 32 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 33 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 34 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 35 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 36 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-. 37 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 38 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 39 | 40 | #define SMOOTH_FONT 41 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup18_ST7789.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ST7789_DRIVER 4 | 5 | // #define TFT_SDA_READ // This option is for ESP32 ONLY, tested with ST7789 display only 6 | 7 | // If colours are inverted (white shows as black) then uncomment one of the next 8 | // 2 lines try both options, one of the options should correct the inversion. 9 | // #define TFT_INVERSION_ON 10 | // #define TFT_INVERSION_OFF 11 | 12 | // For ST7789 ONLY, define the colour order IF the blue and red are swapped on your display 13 | // Try ONE option at a time to find the correct colour order for your display 14 | // #define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue 15 | // #define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red 16 | 17 | 18 | // My ST7789 display has TCT_CS wired permananently low so the pin is not defined here 19 | 20 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 21 | #define TFT_DC PIN_D3 // Data Command control pin 22 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 23 | 24 | 25 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 26 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 27 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 28 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 29 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-. 30 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 31 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 32 | 33 | #define SMOOTH_FONT 34 | 35 | 36 | // #define SPI_FREQUENCY 20000000 37 | #define SPI_FREQUENCY 27000000 38 | // #define SPI_FREQUENCY 40000000 39 | // #define SPI_FREQUENCY 80000000 40 | 41 | #define SPI_TOUCH_FREQUENCY 2500000 42 | 43 | 44 | //#define SUPPORT_TRANSACTIONS 45 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup19_RM68140_Parallel.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ESP32_PARALLEL 4 | 5 | 6 | #define RM68140_DRIVER 7 | 8 | 9 | // ESP32 pins used for UNO format board 10 | #define TFT_CS 33 // Chip select control pin 11 | #define TFT_DC 15 // Data Command control pin - must use a pin in the range 0-31 12 | #define TFT_RST 32 // Reset pin 13 | 14 | #define TFT_WR 4 // Write strobe control pin - must use a pin in the range 0-31 15 | #define TFT_RD 2 16 | 17 | #define TFT_D0 12 // Must use pins in the range 0-31 for the data bus 18 | #define TFT_D1 13 // so a single register write sets/clears all bits 19 | #define TFT_D2 26 20 | #define TFT_D3 25 21 | #define TFT_D4 17 22 | #define TFT_D5 16 23 | #define TFT_D6 27 24 | #define TFT_D7 14 25 | 26 | 27 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 28 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 29 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 30 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 31 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 32 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 33 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 34 | 35 | #define SMOOTH_FONT 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup1_ILI9341.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9341_DRIVER 4 | 5 | 6 | #define TFT_CS PIN_D8 // Chip select control pin D8 7 | #define TFT_DC PIN_D3 // Data Command control pin 8 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 9 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 10 | 11 | 12 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 13 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 14 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 15 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 16 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 17 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 18 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 19 | 20 | 21 | #define SMOOTH_FONT 22 | 23 | 24 | // #define SPI_FREQUENCY 27000000 25 | #define SPI_FREQUENCY 40000000 26 | // #define SPI_FREQUENCY 80000000 27 | 28 | #define SPI_READ_FREQUENCY 20000000 29 | 30 | #define SPI_TOUCH_FREQUENCY 2500000 31 | 32 | 33 | // #define SUPPORT_TRANSACTIONS 34 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup20_ILI9488.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9488_DRIVER 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | 13 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 14 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 15 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 16 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 17 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 18 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 19 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 20 | 21 | #define SMOOTH_FONT 22 | 23 | 24 | // #define SPI_FREQUENCY 20000000 25 | #define SPI_FREQUENCY 27000000 26 | // #define SPI_FREQUENCY 40000000 27 | 28 | 29 | #define SPI_TOUCH_FREQUENCY 2500000 30 | 31 | 32 | // #define SUPPORT_TRANSACTIONS 33 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup21_ILI9488.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9488_DRIVER 4 | 5 | //#define TFT_INVERSION_OFF 6 | 7 | #define TFT_MISO 19 // (leave TFT SDO disconnected if other SPI devices share MISO) 8 | #define TFT_MOSI 23 9 | #define TFT_SCLK 18 10 | #define TFT_CS 15 // Chip select control pin 11 | #define TFT_DC 2 // Data Command control pin 12 | #define TFT_RST 4 // Reset pin (could connect to RST pin) 13 | 14 | 15 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 16 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 17 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 18 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 19 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 20 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 21 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 22 | 23 | #define SMOOTH_FONT 24 | 25 | 26 | // #define SPI_FREQUENCY 20000000 27 | #define SPI_FREQUENCY 27000000 28 | // #define SPI_FREQUENCY 40000000 29 | // #define SPI_FREQUENCY 80000000 30 | 31 | // Optional reduced SPI frequency for reading TFT 32 | #define SPI_READ_FREQUENCY 16000000 33 | 34 | #define SPI_TOUCH_FREQUENCY 2500000 35 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup22_TTGO_T4.h: -------------------------------------------------------------------------------- 1 | // Setup for the TTGO T4 ("Bitcoin Tracker") ESP32 board with 2.2" ILI9341 display 2 | 3 | // See SetupX_Template.h for all options available 4 | 5 | #define ILI9341_DRIVER 6 | 7 | #define TFT_MISO 12 8 | #define TFT_MOSI 23 9 | #define TFT_SCLK 18 10 | 11 | #define TFT_CS 27 12 | #define TFT_DC 32 13 | #define TFT_RST 5 14 | #define TFT_BL 4 15 | 16 | // #define LOAD_GLCD 17 | // #define LOAD_FONT2 18 | // #define LOAD_FONT4 19 | // #define LOAD_FONT6 20 | // #define LOAD_FONT7 21 | // #define LOAD_FONT8 22 | // #define LOAD_GFXFF 23 | 24 | // #define SMOOTH_FONT 25 | 26 | //#define SPI_FREQUENCY 27000000 27 | #define SPI_FREQUENCY 40000000 // Maximum for ILI9341 28 | 29 | #define USE_HSPI_PORT 30 | 31 | #define SPI_READ_FREQUENCY 6000000 // 6 MHz is the maximum SPI read speed for the ST7789V 32 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup23_TTGO_TM.h: -------------------------------------------------------------------------------- 1 | // Setup for the TTGO TM (Music) ESP32 board with 2.4" ST7789V display 2 | 3 | // See SetupX_Template.h for all options available 4 | 5 | #define ST7789_DRIVER 6 | 7 | #define TFT_SDA_READ // Read from display, it only provides an SDA pin 8 | 9 | #define TFT_MISO 19 // Must be defined even though it is not used 10 | #define TFT_MOSI 23 // Connected to display SDA line 11 | #define TFT_SCLK 18 12 | 13 | #define TFT_CS 05 14 | #define TFT_DC 16 15 | #define TFT_RST 17 16 | 17 | #define TFT_WIDTH 240 18 | #define TFT_HEIGHT 320 19 | 20 | //#define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue 21 | #define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red 22 | 23 | #define LOAD_GLCD 24 | #define LOAD_FONT2 25 | #define LOAD_FONT4 26 | #define LOAD_FONT6 27 | #define LOAD_FONT7 28 | #define LOAD_FONT8 29 | #define LOAD_GFXFF 30 | 31 | #define SMOOTH_FONT 32 | 33 | #define SPI_FREQUENCY 40000000 // This display also seems to work reliably at 80MHz 34 | #define SPI_FREQUENCY 80000000 35 | 36 | #define SPI_READ_FREQUENCY 6000000 // 6 MHz is the maximum SPI read speed for the ST7789V 37 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup24_ST7789.h: -------------------------------------------------------------------------------- 1 | // ST7789 240 x 240 display with no chip select line 2 | 3 | #define ST7789_DRIVER // Configure all registers 4 | 5 | #define TFT_WIDTH 240 6 | #define TFT_HEIGHT 240 7 | 8 | //#define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue 9 | //#define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red 10 | 11 | //#define TFT_INVERSION_ON 12 | //#define TFT_INVERSION_OFF 13 | 14 | // DSTIKE stepup 15 | //#define TFT_DC 23 16 | //#define TFT_RST 32 17 | //#define TFT_MOSI 26 18 | //#define TFT_SCLK 27 19 | 20 | // Generic ESP32 setup 21 | //#define TFT_MISO 19 22 | //#define TFT_MOSI 23 23 | //#define TFT_SCLK 18 24 | //#define TFT_CS -1 // Not connected 25 | //#define TFT_DC 2 26 | //#define TFT_RST 4 // Connect reset to ensure display initialises 27 | 28 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 29 | #define TFT_CS -1 // Define as not used 30 | #define TFT_DC PIN_D1 // Data Command control pin 31 | #define TFT_RST PIN_D4 // TFT reset pin (could connect to NodeMCU RST, see next line) 32 | //#define TFT_RST -1 // TFT reset pin connect to NodeMCU RST, must also then add 10K pull down to TFT SCK 33 | 34 | 35 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 36 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 37 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 38 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 39 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 40 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 41 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 42 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 43 | 44 | #define SMOOTH_FONT 45 | 46 | 47 | // #define SPI_FREQUENCY 27000000 48 | #define SPI_FREQUENCY 40000000 49 | 50 | #define SPI_READ_FREQUENCY 20000000 51 | 52 | #define SPI_TOUCH_FREQUENCY 2500000 53 | 54 | // #define SUPPORT_TRANSACTIONS -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup25_TTGO_T_Display.h: -------------------------------------------------------------------------------- 1 | // Setup for the TTGO T4 ("Bitcoin Tracker") ESP32 board with 2.2" ILI9341 display 2 | 3 | // See SetupX_Template.h for all options available 4 | 5 | #define ST7789_DRIVER 6 | 7 | #define TFT_WIDTH 135 8 | #define TFT_HEIGHT 240 9 | 10 | #define CGRAM_OFFSET // Library will add offsets required 11 | 12 | //#define TFT_MISO -1 13 | 14 | #define TFT_MOSI 19 15 | #define TFT_SCLK 18 16 | #define TFT_CS 5 17 | #define TFT_DC 16 18 | #define TFT_RST 23 19 | 20 | #define TFT_BL 4 // Display backlight control pin 21 | 22 | #define TFT_BACKLIGHT_ON HIGH // HIGH or LOW are options 23 | 24 | #define LOAD_GLCD 25 | #define LOAD_FONT2 26 | #define LOAD_FONT4 27 | #define LOAD_FONT6 28 | #define LOAD_FONT7 29 | #define LOAD_FONT8 30 | #define LOAD_GFXFF 31 | 32 | #define SMOOTH_FONT 33 | 34 | //#define SPI_FREQUENCY 27000000 35 | #define SPI_FREQUENCY 40000000 // Maximum for ILI9341 36 | 37 | 38 | #define SPI_READ_FREQUENCY 6000000 // 6 MHz is the maximum SPI read speed for the ST7789V 39 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup26_TTGO_T_Wristband.h: -------------------------------------------------------------------------------- 1 | #define ST7735_DRIVER 2 | 3 | #define TFT_WIDTH 80 4 | #define TFT_HEIGHT 160 5 | 6 | 7 | #define TFT_RST 26 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 8 | #define TFT_MISO -1 9 | #define TFT_MOSI 19 10 | #define TFT_SCLK 18 11 | #define TFT_CS 5 12 | #define TFT_DC 23 13 | #define TFT_BL 27 // Dispaly backlight control pin 14 | 15 | #define TFT_BACKLIGHT_ON HIGH // HIGH or LOW are options 16 | 17 | #define ST7735_GREENTAB160x80 // For 160 x 80 display (BGR, inverted, 26 offset) 18 | 19 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 20 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 21 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 22 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 23 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 24 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 25 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 26 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 27 | 28 | // Comment out the #define below to stop the SPIFFS filing system and smooth font code being loaded 29 | // this will save ~20kbytes of FLASH 30 | #define SMOOTH_FONT 31 | 32 | #define SPI_FREQUENCY 27000000 // Actually sets it to 26.67MHz = 80/3 33 | 34 | // #define SPI_FREQUENCY 40000000 // Maximum to use SPIFFS 35 | // #define SPI_FREQUENCY 80000000 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup2_ST7735.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ST7735_DRIVER 4 | 5 | 6 | #define TFT_WIDTH 128 7 | #define TFT_HEIGHT 160 8 | 9 | 10 | #define ST7735_REDTAB 11 | 12 | 13 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 14 | #define TFT_CS PIN_D8 // Chip select control pin D8 15 | #define TFT_DC PIN_D3 // Data Command control pin 16 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 17 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 18 | 19 | 20 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 21 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 22 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 23 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 24 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 25 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 26 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 27 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 28 | 29 | #define SMOOTH_FONT 30 | 31 | 32 | // #define SPI_FREQUENCY 20000000 33 | #define SPI_FREQUENCY 27000000 34 | // #define SPI_FREQUENCY 40000000 35 | 36 | #define SPI_TOUCH_FREQUENCY 2500000 37 | 38 | 39 | // #define SUPPORT_TRANSACTIONS 40 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup30_ILI9341_Parallel_STM32.h: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////// 2 | // Setup for Nucleo-F446/767 and ILI9341 display // 3 | /////////////////////////////////////////////////// 4 | 5 | // See SetupX_Template.h for all options available 6 | 7 | // Define STM32 to invoke optimised processor support 8 | #define STM32 9 | 10 | // Defining the board allows the library to optimise the performance 11 | // for UNO compatible "MCUfriend" style shields 12 | #define NUCLEO_64_TFT 13 | //#define NUCLEO_144_TFT 14 | 15 | // Tell the library to use 8 bit parallel mode(otherwise SPI is assumed) 16 | #define TFT_PARALLEL_8_BIT 17 | 18 | // Define the display driver chip type 19 | #define ILI9341_DRIVER 20 | //#define ILI9481_DRIVER 21 | 22 | // Define the Nucleo 64/144 pins used for the parallel interface TFT 23 | // The pins can be changed here but these are the ones used by the 24 | // common "MCUfriend" shields 25 | #define TFT_CS A3 // Chip select control pin 26 | #define TFT_DC A2 // Data Command control pin 27 | #define TFT_RST A4 // Reset pin 28 | 29 | #define TFT_WR A1 // Write strobe control pin 30 | #define TFT_RD A0 // Read pin 31 | 32 | #define TFT_D0 D8 // 8 bit parallel bus to TFT 33 | #define TFT_D1 D9 34 | #define TFT_D2 D2 35 | #define TFT_D3 D3 36 | #define TFT_D4 D4 37 | #define TFT_D5 D5 38 | #define TFT_D6 D6 39 | #define TFT_D7 D7 40 | 41 | // Fonts to be available 42 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 43 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 44 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 45 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 46 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 47 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 48 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 49 | 50 | // At the moment SMOOTH fonts must be disabled for STM32 processors (due to lack of SPIFFS) 51 | // Support for smooth fonts via SD cards is planned. 52 | //#define SMOOTH_FONT 53 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup3_ILI9163.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9163_DRIVER 4 | 5 | 6 | #define TFT_WIDTH 128 7 | #define TFT_HEIGHT 160 8 | 9 | 10 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 11 | #define TFT_CS PIN_D8 // Chip select control pin D8 12 | #define TFT_DC PIN_D3 // Data Command control pin 13 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 14 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 15 | 16 | 17 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 18 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 19 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 20 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 21 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 22 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 23 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 24 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 25 | 26 | #define SMOOTH_FONT 27 | 28 | 29 | // #define SPI_FREQUENCY 20000000 30 | #define SPI_FREQUENCY 27000000 31 | // #define SPI_FREQUENCY 40000000 32 | 33 | #define SPI_TOUCH_FREQUENCY 2500000 34 | 35 | 36 | // #define SUPPORT_TRANSACTIONS 37 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup43_ST7735.h: -------------------------------------------------------------------------------- 1 | // Setup for ESP32 and ST7735 80 x 160 TFT 2 | 3 | // See SetupX_Template.h for all options available 4 | 5 | #define ST7735_DRIVER 6 | 7 | 8 | #define TFT_WIDTH 80 9 | #define TFT_HEIGHT 160 10 | 11 | 12 | #define ST7735_GREENTAB160x80 13 | 14 | #ifdef ESP32 15 | #define TFT_MISO 19 16 | #define TFT_MOSI 23 17 | #define TFT_SCLK 18 18 | #define TFT_CS 15 // Chip select control pin 19 | #define TFT_DC 2 // Data Command control pin 20 | #define TFT_RST 4 // Reset pin (could connect to RST pin) 21 | //#define TFT_RST -1 // Set TFT_RST to -1 if display RESET is connected to ESP32 board RST 22 | #else 23 | // Display GND to NodeMCU pin GND (0V) 24 | // Display VCC to NodeMCU 5V or 3.3V 25 | // Display SCK to NodeMCU pin D5 26 | // Display SDI/MOSI to NodeMCU pin D7 27 | // Display BLK to NodeMCU pin VIN 28 | #define TFT_CS PIN_D8 // Chip select control pin D8 29 | #define TFT_DC PIN_D3 // Data Command control pin 30 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 31 | #endif 32 | 33 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 34 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 35 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 36 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 37 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 38 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 39 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 40 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 41 | 42 | #define SMOOTH_FONT 43 | 44 | 45 | //#define SPI_FREQUENCY 20000000 46 | #define SPI_FREQUENCY 27000000 // Actually sets it to 26.67MHz = 80/3 47 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup4_S6D02A1.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define S6D02A1_DRIVER 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | 13 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 14 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 15 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 16 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 17 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 18 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 19 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 20 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 21 | 22 | #define SMOOTH_FONT 23 | 24 | 25 | // #define SPI_FREQUENCY 20000000 26 | #define SPI_FREQUENCY 27000000 27 | // #define SPI_FREQUENCY 40000000 28 | 29 | #define SPI_TOUCH_FREQUENCY 2500000 30 | 31 | 32 | // #define SUPPORT_TRANSACTIONS 33 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup5_RPi_ILI9486.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define RPI_ILI9486_DRIVER // 20MHz maximum SPI 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | 13 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 14 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 15 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 16 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 17 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 18 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 19 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 20 | 21 | #define SMOOTH_FONT 22 | 23 | 24 | #define SPI_FREQUENCY 20000000 25 | 26 | #define SPI_TOUCH_FREQUENCY 2500000 27 | 28 | 29 | // #define SUPPORT_TRANSACTIONS 30 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup6_RPi_Wr_ILI9486.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define RPI_ILI9486_DRIVER // 20MHz maximum SPI 4 | 5 | 6 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 7 | #define TFT_CS PIN_D8 // Chip select control pin D8 8 | #define TFT_DC PIN_D3 // Data Command control pin 9 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 10 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 11 | 12 | #define TFT_WR PIN_D2 // Write strobe for modified Raspberry Pi TFT only 13 | 14 | 15 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 16 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 17 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 18 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 19 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 20 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 21 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 22 | 23 | #define SMOOTH_FONT 24 | 25 | 26 | #define SPI_FREQUENCY 20000000 27 | 28 | #define SPI_TOUCH_FREQUENCY 2500000 29 | 30 | 31 | // #define SUPPORT_TRANSACTIONS 32 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup7_ST7735_128x128.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ST7735_DRIVER 4 | 5 | 6 | #define TFT_WIDTH 128 7 | #define TFT_HEIGHT 128 8 | 9 | 10 | #define ST7735_GREENTAB128 // For 128 x 128 display 11 | 12 | 13 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 14 | #define TFT_CS PIN_D8 // Chip select control pin D8 15 | #define TFT_DC PIN_D3 // Data Command control pin 16 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 17 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 18 | 19 | 20 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 21 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 22 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 23 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 24 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 25 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 26 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 27 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 28 | 29 | 30 | #define SMOOTH_FONT 31 | 32 | 33 | // #define SPI_FREQUENCY 20000000 34 | #define SPI_FREQUENCY 27000000 35 | 36 | #define SPI_TOUCH_FREQUENCY 2500000 37 | 38 | 39 | // #define SUPPORT_TRANSACTIONS 40 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup8_ILI9163_128x128.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ILI9163_DRIVER 4 | 5 | 6 | #define TFT_WIDTH 128 7 | #define TFT_HEIGHT 128 8 | 9 | 10 | // For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation 11 | #define TFT_CS PIN_D8 // Chip select control pin D8 12 | #define TFT_DC PIN_D3 // Data Command control pin 13 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 14 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 15 | 16 | 17 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 18 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 19 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 20 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 21 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 22 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 23 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 24 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 25 | 26 | #define SMOOTH_FONT 27 | 28 | 29 | // #define SPI_FREQUENCY 20000000 30 | #define SPI_FREQUENCY 27000000 // Actually sets it to 26.67MHz = 80/3 31 | 32 | #define SPI_TOUCH_FREQUENCY 2500000 33 | 34 | 35 | // #define SUPPORT_TRANSACTIONS 36 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/Setup9_ST7735_Overlap.h: -------------------------------------------------------------------------------- 1 | // See SetupX_Template.h for all options available 2 | 3 | #define ST7735_DRIVER 4 | 5 | 6 | #define TFT_WIDTH 128 7 | #define TFT_HEIGHT 160 8 | 9 | 10 | #define ST7735_REDTAB 11 | 12 | // Overlap mode shares the ESP8266 FLASH SPI bus with the TFT so has a performance impact 13 | // but saves pins for other functions. It is best not to connect MISO as some displays 14 | // do not tristate that line wjen chip select is high! 15 | // On NodeMCU 1.0 SD0=MISO, SD1=MOSI, CLK=SCLK to connect to TFT in overlap mode 16 | // On NodeMCU V3 S0 =MISO, S1 =MOSI, S2 =SCLK 17 | // In ESP8266 overlap mode the following must be defined 18 | #define TFT_SPI_OVERLAP 19 | 20 | // In ESP8266 overlap mode the TFT chip select MUST connect to pin D3 21 | #define TFT_CS PIN_D3 22 | #define TFT_DC PIN_D5 // Data Command control pin 23 | #define TFT_RST PIN_D4 // Reset pin (could connect to NodeMCU RST, see next line) 24 | //#define TFT_RST -1 // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V 25 | 26 | 27 | 28 | 29 | #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH 30 | #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters 31 | #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters 32 | #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm 33 | #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:. 34 | #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. 35 | //#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT 36 | #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts 37 | 38 | #define SMOOTH_FONT 39 | 40 | 41 | // #define SPI_FREQUENCY 20000000 42 | #define SPI_FREQUENCY 27000000 43 | 44 | #define SPI_TOUCH_FREQUENCY 2500000 45 | 46 | 47 | // #define SUPPORT_TRANSACTIONS 48 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/User_Setups/User_Custom_Fonts.h: -------------------------------------------------------------------------------- 1 | 2 | // Custom "Adafruit" compatible font files can be added to the "TFT_eSPI/Fonts/Custom" folder 3 | // Fonts in a suitable format can be created using a Squix blog web based tool here: 4 | /* 5 | https://blog.squix.org/2016/10/font-creator-now-creates-adafruit-gfx-fonts.html 6 | */ 7 | 8 | // Note: At the time of writing there is a last character code definition bug in the 9 | // Squix font file format so do NOT try and print the tilda (~) symbol (ASCII 0x7E) 10 | // Alternatively look at the end of the font header file and edit: 0x7E to read 0x7D 11 | /* e.g. vvvv 12 | (uint8_t *)Orbitron_Light_32Bitmaps,(GFXglyph *)Orbitron_Light_32Glyphs,0x20, 0x7D, 32}; 13 | ^^^^ 14 | */ 15 | 16 | // When font files are placed in the Custom folder (TFT_eSPI\Fonts\Custom) then they must 17 | // also be #included here: 18 | 19 | // The CF_OL24 etc are a shorthand reference, but this is not essential to use the fonts 20 | 21 | #ifdef LOAD_GFXFF 22 | 23 | // New custom font file #includes 24 | #include // CF_OL24 25 | #include // CF_OL32 26 | #include // CF_RT24 27 | #include // CF_S24 28 | #include // CF_Y32 29 | 30 | #endif 31 | 32 | // Shorthand references - any coding scheme can be used, here CF_ = Custom Font 33 | // The #defines below MUST be added to sketches to use shorthand references, so 34 | // they are only put here for reference and copy+paste purposes! 35 | /* 36 | #define CF_OL24 &Orbitron_Light_24 37 | #define CF_OL32 &Orbitron_Light_32 38 | #define CF_RT24 &Roboto_Thin_24 39 | #define CF_S24 &Satisfy_24 40 | #define CF_Y32 &Yellowtail_32 41 | */ 42 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/160 x 128/TFT_Ellipse/TFT_Ellipse.ino: -------------------------------------------------------------------------------- 1 | /* 2 | Ellipse drawing example 3 | 4 | This sketch does not use any fonts. 5 | */ 6 | 7 | #include // Hardware-specific library 8 | #include 9 | 10 | TFT_eSPI tft = TFT_eSPI(); // Invoke custom library 11 | 12 | void setup(void) { 13 | tft.init(); 14 | 15 | tft.setRotation(1); 16 | 17 | } 18 | 19 | void loop() { 20 | 21 | tft.fillScreen(TFT_BLACK); 22 | 23 | // Draw some random filled elipses 24 | for (int i = 0; i < 20; i++) 25 | { 26 | int rx = random(40); 27 | int ry = random(40); 28 | int x = rx + random(160 - rx - rx); 29 | int y = ry + random(128 - ry - ry); 30 | tft.fillEllipse(x, y, rx, ry, random(0xFFFF)); 31 | } 32 | 33 | delay(2000); 34 | tft.fillScreen(TFT_BLACK); 35 | 36 | // Draw some random outline elipses 37 | for (int i = 0; i < 20; i++) 38 | { 39 | int rx = random(40); 40 | int ry = random(40); 41 | int x = rx + random(160 - rx - rx); 42 | int y = ry + random(128 - ry - ry); 43 | tft.drawEllipse(x, y, rx, ry, random(0xFFFF)); 44 | } 45 | 46 | delay(2000); 47 | } 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/160 x 128/TFT_SPIFFS_Jpeg/SPIFFS_functions.ino: -------------------------------------------------------------------------------- 1 | /*==================================================================================== 2 | This sketch contains support functions for the ESP6266 SPIFFS filing system 3 | 4 | Created by Bodmer 15th Jan 2017 5 | ==================================================================================*/ 6 | 7 | //==================================================================================== 8 | // Print a SPIFFS directory list (root directory) 9 | //==================================================================================== 10 | 11 | void listFiles(void) { 12 | Serial.println(); 13 | Serial.println("SPIFFS files found:"); 14 | 15 | fs::Dir dir = SPIFFS.openDir("/"); // Root directory 16 | String line = "====================================="; 17 | 18 | Serial.println(line); 19 | Serial.println(" File name Size"); 20 | Serial.println(line); 21 | 22 | while (dir.next()) { 23 | String fileName = dir.fileName(); 24 | Serial.print(fileName); 25 | int spaces = 25 - fileName.length(); // Tabulate nicely 26 | while (spaces--) Serial.print(" "); 27 | fs::File f = dir.openFile("r"); 28 | Serial.print(f.size()); Serial.println(" bytes"); 29 | } 30 | 31 | Serial.println(line); 32 | Serial.println(); 33 | delay(1000); 34 | } 35 | //==================================================================================== 36 | 37 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/320 x 240/TFT_Ellipse/TFT_Ellipse.ino: -------------------------------------------------------------------------------- 1 | /* 2 | Ellipse drawing example 3 | 4 | This sketch does not use any fonts. 5 | */ 6 | 7 | #include // Hardware-specific library 8 | #include 9 | 10 | TFT_eSPI tft = TFT_eSPI(); // Invoke custom library 11 | 12 | void setup(void) { 13 | tft.init(); 14 | 15 | tft.setRotation(1); 16 | 17 | } 18 | 19 | void loop() { 20 | 21 | tft.fillScreen(TFT_BLACK); 22 | 23 | // Draw some random ellipses 24 | for (int i = 0; i < 40; i++) 25 | { 26 | int rx = random(60); 27 | int ry = random(60); 28 | int x = rx + random(320 - rx - rx); 29 | int y = ry + random(240 - ry - ry); 30 | tft.fillEllipse(x, y, rx, ry, random(0xFFFF)); 31 | } 32 | 33 | delay(2000); 34 | tft.fillScreen(TFT_BLACK); 35 | 36 | for (int i = 0; i < 40; i++) 37 | { 38 | int rx = random(60); 39 | int ry = random(60); 40 | int x = rx + random(320 - rx - rx); 41 | int y = ry + random(240 - ry - ry); 42 | tft.drawEllipse(x, y, rx, ry, random(0xFFFF)); 43 | } 44 | 45 | delay(2000); 46 | } 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/320 x 240/TFT_Starfield/TFT_Starfield.ino: -------------------------------------------------------------------------------- 1 | // Animates white pixels to simulate flying through a star field 2 | 3 | #include 4 | #include 5 | 6 | // Use hardware SPI 7 | TFT_eSPI tft = TFT_eSPI(); 8 | 9 | // With 1024 stars the update rate is ~65 frames per second 10 | #define NSTARS 1024 11 | uint8_t sx[NSTARS] = {}; 12 | uint8_t sy[NSTARS] = {}; 13 | uint8_t sz[NSTARS] = {}; 14 | 15 | uint8_t za, zb, zc, zx; 16 | 17 | // Fast 0-255 random number generator from http://eternityforest.com/Projects/rng.php: 18 | uint8_t __attribute__((always_inline)) rng() 19 | { 20 | zx++; 21 | za = (za^zc^zx); 22 | zb = (zb+za); 23 | zc = (zc+(zb>>1)^za); 24 | return zc; 25 | } 26 | 27 | void setup() { 28 | za = random(256); 29 | zb = random(256); 30 | zc = random(256); 31 | zx = random(256); 32 | 33 | Serial.begin(115200); 34 | tft.init(); 35 | tft.setRotation(1); 36 | tft.fillScreen(TFT_BLACK); 37 | 38 | // fastSetup() must be used immediately before fastPixel() to prepare screen 39 | // It must be called after any other graphics drawing function call if fastPixel() 40 | // is to be called again 41 | //tft.fastSetup(); // Prepare plot window range for fast pixel plotting 42 | } 43 | 44 | void loop() 45 | { 46 | unsigned long t0 = micros(); 47 | uint8_t spawnDepthVariation = 255; 48 | 49 | for(int i = 0; i < NSTARS; ++i) 50 | { 51 | if (sz[i] <= 1) 52 | { 53 | sx[i] = 160 - 120 + rng(); 54 | sy[i] = rng(); 55 | sz[i] = spawnDepthVariation--; 56 | } 57 | else 58 | { 59 | int old_screen_x = ((int)sx[i] - 160) * 256 / sz[i] + 160; 60 | int old_screen_y = ((int)sy[i] - 120) * 256 / sz[i] + 120; 61 | 62 | // This is a faster pixel drawing function for occassions where many single pixels must be drawn 63 | tft.drawPixel(old_screen_x, old_screen_y,TFT_BLACK); 64 | 65 | sz[i] -= 2; 66 | if (sz[i] > 1) 67 | { 68 | int screen_x = ((int)sx[i] - 160) * 256 / sz[i] + 160; 69 | int screen_y = ((int)sy[i] - 120) * 256 / sz[i] + 120; 70 | 71 | if (screen_x >= 0 && screen_y >= 0 && screen_x < 320 && screen_y < 240) 72 | { 73 | uint8_t r, g, b; 74 | r = g = b = 255 - sz[i]; 75 | tft.drawPixel(screen_x, screen_y, tft.color565(r,g,b)); 76 | } 77 | else 78 | sz[i] = 0; // Out of screen, die. 79 | } 80 | } 81 | } 82 | unsigned long t1 = micros(); 83 | //static char timeMicros[8] = {}; 84 | 85 | // Calcualte frames per second 86 | Serial.println(1.0/((t1 - t0)/1000000.0)); 87 | } 88 | 89 | 90 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/480 x 320/TFT_Ellipse/TFT_Ellipse.ino: -------------------------------------------------------------------------------- 1 | /* 2 | Ellipse drawing example 3 | 4 | This sketch does not use any fonts. 5 | */ 6 | 7 | #include 8 | 9 | #include // Hardware-specific library 10 | 11 | TFT_eSPI tft = TFT_eSPI(); // Invoke custom library 12 | 13 | 14 | void setup(void) { 15 | tft.init(); 16 | 17 | tft.setRotation(1); 18 | 19 | } 20 | 21 | void loop() { 22 | 23 | tft.fillScreen(TFT_BLACK); 24 | 25 | // Draw some random circles 26 | for (int i = 0; i < 40; i++) 27 | { 28 | int rx = random(60); 29 | int ry = random(60); 30 | int x = rx + random(480 - rx - rx); 31 | int y = ry + random(320 - ry - ry); 32 | tft.fillEllipse(x, y, rx, ry, random(0xFFFF)); 33 | } 34 | 35 | delay(2000); 36 | tft.fillScreen(TFT_BLACK); 37 | 38 | for (int i = 0; i < 40; i++) 39 | { 40 | int rx = random(60); 41 | int ry = random(60); 42 | int x = rx + random(480 - rx - rx); 43 | int y = ry + random(320 - ry - ry); 44 | tft.drawEllipse(x, y, rx, ry, random(0xFFFF)); 45 | } 46 | 47 | delay(2000); 48 | } 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/480 x 320/Touch_Controller_Demo/Touch_Controller_Demo.ino: -------------------------------------------------------------------------------- 1 | #include "FS.h" 2 | #include 3 | #include 4 | TFT_eSPI tft = TFT_eSPI(); 5 | 6 | #define CALIBRATION_FILE "/calibrationData" 7 | 8 | void setup(void) { 9 | uint16_t calibrationData[5]; 10 | uint8_t calDataOK = 0; 11 | 12 | Serial.begin(115200); 13 | Serial.println("starting"); 14 | 15 | tft.init(); 16 | 17 | tft.setRotation(3); 18 | tft.fillScreen((0xFFFF)); 19 | 20 | tft.setCursor(20, 0, 2); 21 | tft.setTextColor(TFT_BLACK, TFT_WHITE); tft.setTextSize(1); 22 | tft.println("calibration run"); 23 | 24 | // check file system 25 | if (!SPIFFS.begin()) { 26 | Serial.println("formating file system"); 27 | 28 | SPIFFS.format(); 29 | SPIFFS.begin(); 30 | } 31 | 32 | // check if calibration file exists 33 | if (SPIFFS.exists(CALIBRATION_FILE)) { 34 | File f = SPIFFS.open(CALIBRATION_FILE, "r"); 35 | if (f) { 36 | if (f.readBytes((char *)calibrationData, 14) == 14) 37 | calDataOK = 1; 38 | f.close(); 39 | } 40 | } 41 | if (calDataOK) { 42 | // calibration data valid 43 | tft.setTouch(calibrationData); 44 | } else { 45 | // data not valid. recalibrate 46 | tft.calibrateTouch(calibrationData, TFT_WHITE, TFT_RED, 15); 47 | // store data 48 | File f = SPIFFS.open(CALIBRATION_FILE, "w"); 49 | if (f) { 50 | f.write((const unsigned char *)calibrationData, 14); 51 | f.close(); 52 | } 53 | } 54 | 55 | tft.fillScreen((0xFFFF)); 56 | 57 | } 58 | 59 | void loop() { 60 | uint16_t x, y; 61 | static uint16_t color; 62 | 63 | if (tft.getTouch(&x, &y)) { 64 | 65 | tft.setCursor(5, 5, 2); 66 | tft.printf("x: %i ", x); 67 | tft.setCursor(5, 20, 2); 68 | tft.printf("y: %i ", y); 69 | 70 | tft.drawPixel(x, y, color); 71 | color += 155; 72 | } 73 | } 74 | 75 | 76 | 77 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/Baboon40.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/Baboon40.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/EagleEye.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/EagleEye.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/Mouse480.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/Mouse480.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/lena20k.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Generic/ESP32_SDcard_jpeg/Data/lena20k.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/TFT_SPIFFS_BMP/TFT_SPIFFS_BMP.ino: -------------------------------------------------------------------------------- 1 | // This sketch draws BMP images pulled from SPIFFS onto the TFT. It is an 2 | // an example from this library: https://github.com/Bodmer/TFT_eSPI 3 | 4 | // Images in SPIFFS must be put in the root folder (top level) to be found 5 | // Use the SPIFFS library example to verify SPIFFS works! 6 | 7 | // The example image used to test this sketch can be found in the sketch 8 | // Data folder, press Ctrl+K to see this folder. Use the IDE "Tools" menu 9 | // option to upload the sketches data folder to the SPIFFS 10 | 11 | // This sketch has been tested on the ESP32 and ESP8266 12 | 13 | //---------------------------------------------------------------------------------------------------- 14 | 15 | //==================================================================================== 16 | // Libraries 17 | //==================================================================================== 18 | // Call up the SPIFFS FLASH filing system this is part of the ESP Core 19 | #define FS_NO_GLOBALS 20 | #include 21 | 22 | #ifdef ESP32 23 | #include "SPIFFS.h" // For ESP32 only 24 | #endif 25 | 26 | // Call up the TFT library 27 | #include // Hardware-specific library for ESP8266 28 | 29 | // Invoke TFT library 30 | TFT_eSPI tft = TFT_eSPI(); 31 | 32 | //==================================================================================== 33 | // Setup 34 | //==================================================================================== 35 | void setup() 36 | { 37 | Serial.begin(115200); 38 | 39 | if (!SPIFFS.begin()) { 40 | Serial.println("SPIFFS initialisation failed!"); 41 | while (1) yield(); // Stay here twiddling thumbs waiting 42 | } 43 | Serial.println("\r\nSPIFFS initialised."); 44 | 45 | // Now initialise the TFT 46 | tft.begin(); 47 | tft.setRotation(0); // 0 & 2 Portrait. 1 & 3 landscape 48 | tft.fillScreen(TFT_BLACK); 49 | } 50 | 51 | //==================================================================================== 52 | // Loop 53 | //==================================================================================== 54 | void loop() 55 | { 56 | int x = random(tft.width() - 128); 57 | int y = random(tft.height() - 160); 58 | 59 | drawBmp("/parrot.bmp", x, y); 60 | 61 | delay(1000); 62 | } 63 | //==================================================================================== 64 | 65 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/TFT_SPIFFS_BMP/data/parrot.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Generic/TFT_SPIFFS_BMP/data/parrot.bmp -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Generic/drawXBitmap/drawXBitmap.ino: -------------------------------------------------------------------------------- 1 | // Example sketch to demonstrate the drawing of X BitMap (XBM) 2 | // format image onto the display. 3 | 4 | // Information on the X BitMap (XBM) format can be found here: 5 | // https://en.wikipedia.org/wiki/X_BitMap 6 | 7 | // This example is part of the TFT_eSPI library: 8 | // https://github.com/Bodmer/TFT_eSPI 9 | 10 | // Created by Bodmer 23/04/18 11 | 12 | #include "xbm.h" // Sketch tab header for xbm images 13 | 14 | #include // Hardware-specific library 15 | 16 | TFT_eSPI tft = TFT_eSPI(); // Invoke library 17 | 18 | 19 | void setup() 20 | { 21 | tft.begin(); // Initialise the display 22 | tft.fillScreen(TFT_BLACK); // Black screen fill 23 | } 24 | 25 | void loop() 26 | { 27 | 28 | // Example 1 29 | // ========= 30 | // Random x and y coordinates 31 | int x = random(tft.width() - logoWidth); 32 | int y = random(tft.height() - logoHeight); 33 | 34 | // Draw bitmap with top left corner at x,y with foreground only color 35 | // Bits set to 1 plot as the defined color, bits set to 0 are not plotted 36 | // x y xbm xbm width xbm height color 37 | tft.drawXBitmap(x, y, logo, logoWidth, logoHeight, TFT_WHITE); 38 | 39 | delay(500); 40 | 41 | // Erase old one by drawing over with background colour 42 | tft.drawXBitmap(x, y, logo, logoWidth, logoHeight, TFT_BLACK); 43 | 44 | 45 | // Example 2 46 | // ========= 47 | // New random x and y coordinates 48 | x = random(tft.width() - logoWidth); 49 | y = random(tft.height() - logoHeight); 50 | 51 | // Draw bitmap with top left corner at x,y with foreground and background colors 52 | // Bits set to 1 plot as the defined fg color, bits set to 0 are plotted as bg color 53 | // x y xbm xbm width xbm height fg color bg color 54 | tft.drawXBitmap(x, y, logo, logoWidth, logoHeight, TFT_WHITE, TFT_RED); 55 | 56 | delay(500); 57 | 58 | // Erase old one by drawing over with background colour 59 | tft.drawXBitmap(x, y, logo, logoWidth, logoHeight, TFT_BLACK, TFT_BLACK); 60 | 61 | } 62 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/ESP32_Smooth_Font_SD/data/Final-Frontier-28.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/ESP32_Smooth_Font_SD/data/Final-Frontier-28.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_1/Notes.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Information notes only: 4 | ====================== 5 | 6 | //These are the text plotting alignment (reference datum point) 7 | 8 | TL_DATUM = Top left (default) 9 | TC_DATUM = Top centre 10 | TR_DATUM = Top right 11 | 12 | ML_DATUM = Middle left 13 | MC_DATUM = Middle centre 14 | MR_DATUM = Middle right 15 | 16 | BL_DATUM = Bottom left 17 | BC_DATUM = Bottom centre 18 | BR_DATUM = Bottom right 19 | 20 | L_BASELINE = Left character baseline (Line the 'A' character would sit on) 21 | C_BASELINE = Centre character baseline 22 | R_BASELINE = Right character baseline 23 | 24 | // Basic colours already defined: 25 | 26 | TFT_BLACK 0x0000 27 | TFT_NAVY 0x000F 28 | TFT_DARKGREEN 0x03E0 29 | TFT_DARKCYAN 0x03EF 30 | TFT_MAROON 0x7800 31 | TFT_PURPLE 0x780F 32 | TFT_OLIVE 0x7BE0 33 | TFT_LIGHTGREY 0xC618 34 | TFT_DARKGREY 0x7BEF 35 | TFT_BLUE 0x001F 36 | TFT_GREEN 0x07E0 37 | TFT_CYAN 0x07FF 38 | TFT_RED 0xF800 39 | TFT_MAGENTA 0xF81F 40 | TFT_YELLOW 0xFFE0 41 | TFT_WHITE 0xFFFF 42 | TFT_ORANGE 0xFDA0 43 | TFT_GREENYELLOW 0xB7E0 44 | TFT_PINK 0xFC9F 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | */ 57 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_1/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_1/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_1/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_1/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_2/Notes.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Information notes only: 4 | ====================== 5 | 6 | //These are the text plotting alignment (reference datum point) 7 | 8 | TL_DATUM = Top left (default) 9 | TC_DATUM = Top centre 10 | TR_DATUM = Top right 11 | 12 | ML_DATUM = Middle left 13 | MC_DATUM = Middle centre 14 | MR_DATUM = Middle right 15 | 16 | BL_DATUM = Bottom left 17 | BC_DATUM = Bottom centre 18 | BR_DATUM = Bottom right 19 | 20 | L_BASELINE = Left character baseline (Line the 'A' character would sit on) 21 | C_BASELINE = Centre character baseline 22 | R_BASELINE = Right character baseline 23 | 24 | // Basic colours already defined: 25 | 26 | TFT_BLACK 0x0000 27 | TFT_NAVY 0x000F 28 | TFT_DARKGREEN 0x03E0 29 | TFT_DARKCYAN 0x03EF 30 | TFT_MAROON 0x7800 31 | TFT_PURPLE 0x780F 32 | TFT_OLIVE 0x7BE0 33 | TFT_LIGHTGREY 0xC618 34 | TFT_DARKGREY 0x7BEF 35 | TFT_BLUE 0x001F 36 | TFT_GREEN 0x07E0 37 | TFT_CYAN 0x07FF 38 | TFT_RED 0xF800 39 | TFT_MAGENTA 0xF81F 40 | TFT_YELLOW 0xFFE0 41 | TFT_WHITE 0xFFFF 42 | TFT_ORANGE 0xFDA0 43 | TFT_GREENYELLOW 0xB7E0 44 | TFT_PINK 0xFC9F 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | */ 57 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_2/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_2/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_2/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_2/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/Notes.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Information notes only: 4 | ====================== 5 | 6 | Note: it is best to use drawNumber() and drawFloat() for numeric values 7 | this reduces digit position movement when the value changes 8 | drawNumber() and drawFloat() functions behave like drawString() and are 9 | supported by setTextDatum() and setTextPadding() 10 | 11 | //These are the text plotting alignment (reference datum point) 12 | 13 | TL_DATUM = Top left (default) 14 | TC_DATUM = Top centre 15 | TR_DATUM = Top right 16 | 17 | ML_DATUM = Middle left 18 | MC_DATUM = Middle centre 19 | MR_DATUM = Middle right 20 | 21 | BL_DATUM = Bottom left 22 | BC_DATUM = Bottom centre 23 | BR_DATUM = Bottom right 24 | 25 | L_BASELINE = Left character baseline (Line the 'A' character would sit on) 26 | C_BASELINE = Centre character baseline 27 | R_BASELINE = Right character baseline 28 | 29 | // Basic colours already defined: 30 | 31 | TFT_BLACK 0x0000 32 | TFT_NAVY 0x000F 33 | TFT_DARKGREEN 0x03E0 34 | TFT_DARKCYAN 0x03EF 35 | TFT_MAROON 0x7800 36 | TFT_PURPLE 0x780F 37 | TFT_OLIVE 0x7BE0 38 | TFT_LIGHTGREY 0xC618 39 | TFT_DARKGREY 0x7BEF 40 | TFT_BLUE 0x001F 41 | TFT_GREEN 0x07E0 42 | TFT_CYAN 0x07FF 43 | TFT_RED 0xF800 44 | TFT_MAGENTA 0xF81F 45 | TFT_YELLOW 0xFFE0 46 | TFT_WHITE 0xFFFF 47 | TFT_ORANGE 0xFDA0 48 | TFT_GREENYELLOW 0xB7E0 49 | TFT_PINK 0xFC9F 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | */ 62 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansMonoSCB20.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_3/data/NotoSansMonoSCB20.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_4/Notes.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Information notes only: 4 | ====================== 5 | 6 | //These are the text plotting alignment (reference datum point) 7 | 8 | TL_DATUM = Top left (default) 9 | TC_DATUM = Top centre 10 | TR_DATUM = Top right 11 | 12 | ML_DATUM = Middle left 13 | MC_DATUM = Middle centre 14 | MR_DATUM = Middle right 15 | 16 | BL_DATUM = Bottom left 17 | BC_DATUM = Bottom centre 18 | BR_DATUM = Bottom right 19 | 20 | L_BASELINE = Left character baseline (Line the 'A' character would sit on) 21 | C_BASELINE = Centre character baseline 22 | R_BASELINE = Right character baseline 23 | 24 | // Basic colours already defined: 25 | 26 | TFT_BLACK 0x0000 27 | TFT_NAVY 0x000F 28 | TFT_DARKGREEN 0x03E0 29 | TFT_DARKCYAN 0x03EF 30 | TFT_MAROON 0x7800 31 | TFT_PURPLE 0x780F 32 | TFT_OLIVE 0x7BE0 33 | TFT_LIGHTGREY 0xC618 34 | TFT_DARKGREY 0x7BEF 35 | TFT_BLUE 0x001F 36 | TFT_GREEN 0x07E0 37 | TFT_CYAN 0x07FF 38 | TFT_RED 0xF800 39 | TFT_MAGENTA 0xF81F 40 | TFT_YELLOW 0xFFE0 41 | TFT_WHITE 0xFFFF 42 | TFT_ORANGE 0xFDA0 43 | TFT_GREENYELLOW 0xB7E0 44 | TFT_PINK 0xFC9F 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | */ 57 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_4/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_4/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_4/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Font_Demo_4/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Print_Smooth_Font/data/Final-Frontier-28.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Print_Smooth_Font/data/Final-Frontier-28.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_gradient/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_gradient/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_gradient/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_gradient/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_reading_TFT/data/NotoSansBold15.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_reading_TFT/data/NotoSansBold15.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_reading_TFT/data/NotoSansBold36.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Smooth_font_reading_TFT/data/NotoSansBold36.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Final-Frontier-28.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Final-Frontier-28.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Latin-Hiragana-24.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Latin-Hiragana-24.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Unicode-Test-72.vlw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Smooth Fonts/Unicode_test/data/Unicode-Test-72.vlw -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Sprite/Rotated_Sprite_3/data/EagleEye.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Sprite/Rotated_Sprite_3/data/EagleEye.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Sprite/Rotated_Sprite_3/data/Eye_80x64.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/Sprite/Rotated_Sprite_3/data/Eye_80x64.jpg -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/Test and diagnostics/Test_Touch_Controller/Test_Touch_Controller.ino: -------------------------------------------------------------------------------- 1 | // This sketch is to test the touch controller, nothing is displayed 2 | // on the TFT. The TFT_eSPI library must be configured to suit your 3 | // pins used. Make sure both the touch chip select and the TFT chip 4 | // select are correctly defined to avoid SPI bus contention. 5 | 6 | // Make sure you have defined a pin for the touch controller chip 7 | // select line in the user setup file or you will see "no member" 8 | // compile errors for the touch functions! 9 | 10 | // It is a support and diagnostic sketch for the TFT_eSPI library: 11 | // https://github.com/Bodmer/TFT_eSPI 12 | 13 | // The "raw" (unprocessed) touch sensor outputs are sent to the 14 | // serial port. Touching the screen should show changes to the x, y 15 | // and z values. x and y are raw ADC readings, not pixel coordinates. 16 | 17 | #include 18 | #include 19 | TFT_eSPI tft = TFT_eSPI(); 20 | 21 | //==================================================================== 22 | 23 | void setup(void) { 24 | Serial.begin(115200); 25 | Serial.println("\n\nStarting..."); 26 | 27 | tft.init(); 28 | } 29 | 30 | //==================================================================== 31 | 32 | void loop() { 33 | 34 | uint16_t x, y; 35 | 36 | tft.getTouchRaw(&x, &y); 37 | 38 | Serial.printf("x: %i ", x); 39 | 40 | Serial.printf("y: %i ", y); 41 | 42 | Serial.printf("z: %i \n", tft.getTouchRawZ()); 43 | 44 | delay(250); 45 | 46 | } 47 | 48 | //==================================================================== 49 | 50 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/ePaper/Floyd_Steinberg/data/TestCard.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/ePaper/Floyd_Steinberg/data/TestCard.bmp -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/examples/ePaper/Floyd_Steinberg/data/Tiger.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rosmianto/gamebuino-esp32/a1bf1769d1cda3ff58f0e96c1ab868b0611a97e2/lib/TFT_eSPI-master/examples/ePaper/Floyd_Steinberg/data/Tiger.bmp -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "TFT_eSPI", 3 | "version": "1.5.0", 4 | "keywords": "Arduino, tft, ePaper, display, STM32, ESP8266, NodeMCU, ESP32, M5Stack, ILI9341, ST7735, ILI9163, S6D02A1, ILI9486, ST7789, RM68140", 5 | "description": "A TFT and ePaper SPI graphics library with optimisation for ESP8266, ESP32 and STM32", 6 | "repository": 7 | { 8 | "type": "git", 9 | "url": "https://github.com/Bodmer/TFT_eSPI" 10 | }, 11 | "authors": 12 | [ 13 | { 14 | "name": "Bodmer", 15 | "email": "bodmer@anola.net", 16 | "maintainer": true 17 | } 18 | ], 19 | "frameworks": "arduino", 20 | "platforms": "espressif8266, espressif32, ststm32" 21 | } 22 | -------------------------------------------------------------------------------- /lib/TFT_eSPI-master/library.properties: -------------------------------------------------------------------------------- 1 | name=TFT_eSPI 2 | version=1.5.0 3 | author=Bodmer 4 | maintainer=Bodmer 5 | sentence=TFT graphics library for Arduino processors with performance optimisation for STM32, ESP8266 and ESP32 6 | paragraph=Supports TFT displays using drivers (ILI9341 etc) that operate with hardware SPI or 8 bit parallel. 7 | category=Display 8 | url=https://github.com/Bodmer/TFT_eSPI 9 | architectures=* 10 | includes=TFT_eSPI.h 11 | 12 | -------------------------------------------------------------------------------- /platformio.ini: -------------------------------------------------------------------------------- 1 | ;PlatformIO Project Configuration File 2 | ; 3 | ; Build options: build flags, source filter 4 | ; Upload options: custom upload port, speed and extra flags 5 | ; Library options: dependencies, extra library storages 6 | ; Advanced options: extra scripting 7 | ; 8 | ; Please visit documentation for the other options and examples 9 | ; https://docs.platformio.org/page/projectconf.html 10 | 11 | [env:esp32doit-devkit-v1] 12 | platform = espressif32 13 | board = esp32doit-devkit-v1 14 | framework = arduino 15 | upload_speed = 921600 16 | monitor_speed = 115200 17 | build_flags = 18 | ; -DDEBUG_ESP_CORE -------------------------------------------------------------------------------- /src/config-gamebuino.h: -------------------------------------------------------------------------------- 1 | //enable one of the display modes 2 | //if no config-gamebuino.h is present, it defaults to RGB 3 | 4 | #define DISPLAY_MODE DISPLAY_MODE_RGB565 5 | //#define DISPLAY_MODE DISPLAY_MODE_INDEX 6 | //#define DISPLAY_MODE DISPLAY_MODE_INDEX_HALFRES 7 | --------------------------------------------------------------------------------