arduino tft lcd gui made in china

STONE Technologies is a proud manufacturer of superior quality TFT LCD modules and LCD screens. The company also provides intelligent HMI solutions that perfectly fit in with its excellent hardware offerings.

There is also a downloadable design software called STONE Designer. This is a completely free GUI design software you can use to create responsive digital module-ready user interfaces.

STONE TFT LCD modules come with a microcontroller unit that has a 1GHz Cortex-A8 CPU. Such a module can easily be transformed into an HMI screen. Simple hexadecimal instructions can be used to control the module through the UART port. Furthermore, you can seamlessly develop STONE TFT LCD color user interface modules and add touch control, features to them.

The famous china LCD display manufacturers. It is the world’s leading semiconductor display technology, products, and services provider. Products are widely used in mobile phones, tablets, laptops, monitors, televisions, cars, digital information displays, and other display fields.

Focus on the development and production of china HMI (Intelligent TFT LCD Module) LCD display manufacturers, production, and sales of LCD display modules for 16 years. The company master TFT LCD technology and software system. The main products are industrial electronic series, advanced series, and civil and commercial series. Application scenarios include automation systems, medical beauty equipment, vending machines, smart lockers, energy, and power equipment (refueling machines, charging piles), elevators, smart homes, and offices, measuring instruments, public transportation, etc.

Mainly committed to the r&d, production, and sales of TFT-LCD/stn-LCD /OLED display modules, it is a modern high-tech enterprise that provides a full range of product LCD module technology and manufacturing support services for TCL group member enterprises and international electronic enterprises.

Set an LCD display module (LCM), capacitive touch screen (CTP), fully integrated touch display module (TDM), LCD thin technology development, production, and service in one national high-tech company.

Domestic size of the top four small and medium-sized flat panel display manufacturers. The products cover medium and small-size TFT-LCD display modules and high-precision miniature cameras, which have been widely used in the fields of smartphones, medical treatment, and industrial display.

The LCD business division is specialized in the r&d, production, and sales of the LCD display (LCD) and LCD module (LCM) series of products. It has ten semi-automatic COG production lines, 1.5KK of monthly COG products, covering COG, TAB, COB, and other LCD module products, TFT, CSTN, and other color LCD display products, and OLED display products. touch screen manufacturers.

Byd IT products and business mainly include the establishment of rechargeable batteries, plastic parts, metal parts, hardware, and electronic products, mobile phone keys, microelectronics, LCD display module, optoelectronic products, flexible circuit board, chargers, connectors, uninterruptible power supply, dc power supply, solar energy products, mobile phone decoration, mobile phones ODM, mobile phone test, assembly operations, laptop, ODM, manufacturing, testing and assembly operations, etc.

Star source products cover backlight, LCD, optical diaphragm, etc., widely used in LCD modules, photo frames, tablets, portable, instruments, and meters.

The company has long invested in the research and development of the TFT-lcm LCD module, focusing on consumer products and industrial control products. Currently, 3.5-11.6 inch modules are available, among which 4.0, 4.3, 5, 6, and 10.1-inch products have reached the leading level in the industry. Products are mainly used in vehicles, mobile TV, PMP, DVD, EPC, security, and industrial control products.

Professional development, design, production, and sales of LCD display module (LCM), products cover COB, TAB, COG, and other LCD module products, TFT, CSTN, and other color LCD display products, as well as OLED display products. Products are widely used in mobile phones, communications, digital products, household appliances, industrial control, instrumentation, vehicle display, color screen display, and other fields.

Mainly engaged in research and development, manufacturing, and sales of the LCD display and LCD display module. Products are widely used in all kinds of electronic products and equipment HMI interface, such as medical equipment, instruments and meters, audio, household appliances, telephone and clocks, game machines, and other different types and use.

Focusing on the LCD module industry, is a collection of research and development, manufacturing, sales as one of the high-tech enterprises. TFT module size from 1.44 to 7 inches, product specifications cover QVGA, WVGA, qHD, HD, etc., the market prospects are broad.

The display manufacturers company mainly researches and develops the LCD display, charger, battery, and other products of mobile communication mobile phone, telephone, MP3, and other high-tech products.

The company integrates research and development, design, production, sales, and service into one, and provides comprehensive touch and display integrated solutions for the complete machine touch screen manufacturer of smartphones, specializing in the development and manufacture of Sensor sensors, capacitive touch screens (GFF/OGS/GG), small and medium-sized LCD (TN/HTN/STN/CSTN/TFT) and corresponding modules and glass cover plate products. The company’s products are widely used in communication terminals (smartphone, tablet computer, etc.), household appliances, car electronics, digital products, and other industries, exported to Europe and America, Japan and South Korea, Singapore, and other countries.

Mainly produces medium and small-size LCD display module (LCM), multi-point capacitive touch screen (CTP), and other high-tech products. At present, more than 1000 models of 1.2-12.1 inch products have been developed. Products are widely used in mobile phones, GPS, mobile TV, tablet computers, digital photo frames, e-books, and other consumer electronics.

It is a professional development and production of small and medium-sized flat panel display upstream materials manufacturers. The company’s main products include LCD display panels, color filter, ITO conductive glass (CF), TFT LCD panel, and capacitive touch screen with multi-touch control functions (sensor and the final module), can provide complete medium and small size flat-panel display device using the solution of raw materials, product specifications varieties complete, widely used in 10.4 inches below the smartphone, tablet, PMP, digital camera, digital camera, GPS and other products of the display panel.

Now it is divided into mobile phone business division: the main products are (2.8-6) inch and the LCD screen and capacitive screen all fit together.MID tablet computer and ultrabook computer division: the main production product size is (7-15) inch capacitive touch screen.

Committed to 3.5~4.3 inches, 5 inches, 5.88 inches, 6.2 inches, 7.0 inches, 8.0 inches, 9.7 inches, 10.1 inches, 12.1 inches medium size FOG, backlight process production, products should be widely used in high-end communication phones, tablets, notebook computers, car TV, navigator, and other display products. automotive LCD display touch screen manufacturers.

The company has an injection molding business division, SMT business division, FPC business division, backlight business division, irrigation crystal business division, TFT module business division, SIN module business division, products involving touch screen, LCD display module, backlight, black and white screen, flexible circuit board.

Engaged in the laptop, tablet, smartphone, computer high-performance board card, LCD module, and other electronic products research and development, production, and sales of high-tech private enterprises.

Is a professional engaged in LCD display module, electronic components, production, design, research and development, sales as one of the high-tech enterprises. Products are widely used in mobile phones, game consoles, PDA, portable DVDs, video phones, intercom doorbells, car video, industrial control medical, and other fields.

STONE provides a full range of 3.5 inches to 15.1 inches of small and medium-size standard quasi TFT LCD module, LCD display, TFT display module, display industry, industrial LCD screen, under the sunlight visually highlight TFT LCD display, industrial custom TFT screen, TFT LCD screen-wide temperature, industrial TFT LCD screen, touch screen industry. The TFT LCD module is very suitable for industrial control equipment, medical instruments, POS system, electronic consumer products, vehicles, and other products.

In this Arduino touch screen tutorial we will learn how to use TFT LCD Touch Screen with Arduino. You can watch the following video or read the written tutorial below.

As an example I am using a 3.2” TFT Touch Screen in a combination with a TFT LCD Arduino Mega Shield. We need a shield because the TFT Touch screen works at 3.3V and the Arduino Mega outputs are 5 V. For the first example I have the HC-SR04 ultrasonic sensor, then for the second example an RGB LED with three resistors and a push button for the game example. Also I had to make a custom made pin header like this, by soldering pin headers and bend on of them so I could insert them in between the Arduino Board and the TFT Shield.

Here’s the circuit schematic. We will use the GND pin, the digital pins from 8 to 13, as well as the pin number 14. As the 5V pins are already used by the TFT Screen I will use the pin number 13 as VCC, by setting it right away high in the setup section of code.

I will use the UTFT and URTouch libraries made by Henning Karlsen. Here I would like to say thanks to him for the incredible work he has done. The libraries enable really easy use of the TFT Screens, and they work with many different TFT screens sizes, shields and controllers. You can download these libraries from his website, RinkyDinkElectronics.com and also find a lot of demo examples and detailed documentation of how to use them.

After we include the libraries we need to create UTFT and URTouch objects. The parameters of these objects depends on the model of the TFT Screen and Shield and these details can be also found in the documentation of the libraries.

So now I will explain how we can make the home screen of the program. With the setBackColor() function we need to set the background color of the text, black one in our case. Then we need to set the color to white, set the big font and using the print() function, we will print the string “Arduino TFT Tutorial” at the center of the screen and 10 pixels  down the Y – Axis of the screen. Next we will set the color to red and draw the red line below the text. After that we need to set the color back to white, and print the two other strings, “by HowToMechatronics.com” using the small font and “Select Example” using the big font.

In order the code to work and compile you will have to include an addition “.c” file in the same directory with the Arduino sketch. This file is for the third game example and it’s a bitmap of the bird. For more details how this part of the code work  you can check my particular tutorial. Here you can download that file:

In this article, you will learn how to use TFT LCDs by Arduino boards. From basic commands to professional designs and technics are all explained here.

There are several components to achieve this. LEDs,  7-segments, Character and Graphic displays, and full-color TFT LCDs. The right component for your projects depends on the amount of data to be displayed, type of user interaction, and processor capacity.

TFT LCD is a variant of a liquid-crystal display (LCD) that uses thin-film-transistor (TFT) technology to improve image qualities such as addressability and contrast. A TFT LCD is an active matrix LCD, in contrast to passive matrix LCDs or simple, direct-driven LCDs with a few segments.

In Arduino-based projects, the processor frequency is low. So it is not possible to display complex, high definition images and high-speed motions. Therefore, full-color TFT LCDs can only be used to display simple data and commands.

There are several components to achieve this. LEDs,  7-segments, Character and Graphic displays, and full-color TFT LCDs. The right component for your projects depends on the amount of data to be displayed, type of user interaction, and processor capacity.

TFT LCD is a variant of a liquid-crystal display (LCD) that uses thin-film-transistor (TFT) technology to improve image qualities such as addressability and contrast. A TFT LCD is an active matrix LCD, in contrast to passive matrix LCDs or simple, direct-driven LCDs with a few segments.

In Arduino-based projects, the processor frequency is low. So it is not possible to display complex, high definition images and high-speed motions. Therefore, full-color TFT LCDs can only be used to display simple data and commands.

After choosing the right display, It’s time to choose the right controller. If you want to display characters, tests, numbers and static images and the speed of display is not important, the Atmega328 Arduino boards (such as Arduino UNO) are a proper choice. If the size of your code is big, The UNO board may not be enough. You can use Arduino Mega2560 instead. And if you want to show high resolution images and motions with high speed, you should use the ARM core Arduino boards such as Arduino DUE.

In electronics/computer hardware a display driver is usually a semiconductor integrated circuit (but may alternatively comprise a state machine made of discrete logic and other components) which provides an interface function between a microprocessor, microcontroller, ASIC or general-purpose peripheral interface and a particular type of display device, e.g. LCD, LED, OLED, ePaper, CRT, Vacuum fluorescent or Nixie.

The LCDs manufacturers use different drivers in their products. Some of them are more popular and some of them are very unknown. To run your display easily, you should use Arduino LCDs libraries and add them to your code. Otherwise running the display may be very difficult. There are many free libraries you can find on the internet but the important point about the libraries is their compatibility with the LCD’s driver. The driver of your LCD must be known by your library. In this article, we use the Adafruit GFX library and MCUFRIEND KBV library and example codes. You can download them from the following links.

You must add the library and then upload the code. If it is the first time you run an Arduino board, don’t worry. Just follow these steps:Go to www.arduino.cc/en/Main/Software and download the software of your OS. Install the IDE software as instructed.

First you should convert your image to hex code. Download the software from the following link. if you don’t want to change the settings of the software, you must invert the color of the image and make the image horizontally mirrored and rotate it 90 degrees counterclockwise. Now add it to the software and convert it. Open the exported file and copy the hex code to Arduino IDE. x and y are locations of the image. sx and sy are sizes of image. you can change the color of the image in the last input.

Upload your image and download the converted file that the UTFT libraries can process. Now copy the hex code to Arduino IDE. x and y are locations of the image. sx and sy are size of the image.

In this template, We converted a .jpg image to .c file and added to the code, wrote a string and used the fade code to display. Then we used scroll code to move the screen left. Download the .h file and add it to the folder of the Arduino sketch.

In this template, We used sin(); and cos(); functions to draw Arcs with our desired thickness and displayed number by text printing function. Then we converted an image to hex code and added them to the code and displayed the image by bitmap function. Then we used draw lines function to change the style of the image. Download the .h file and add it to the folder of the Arduino sketch.

In this template, We added a converted image to code and then used two black and white arcs to create the pointer of volumes.  Download the .h file and add it to the folder of the Arduino sketch.

In this template, We added a converted image and use the arc and print function to create this gauge.  Download the .h file and add it to folder of the Arduino sketch.

while (a < b) { Serial.println(a); j = 80 * (sin(PI * a / 2000)); i = 80 * (cos(PI * a / 2000)); j2 = 50 * (sin(PI * a / 2000)); i2 = 50 * (cos(PI * a / 2000)); tft.drawLine(i2 + 235, j2 + 169, i + 235, j + 169, tft.color565(0, 255, 255)); tft.fillRect(200, 153, 75, 33, 0x0000); tft.setTextSize(3); tft.setTextColor(0xffff); if ((a/20)>99)

while (b < a) { j = 80 * (sin(PI * a / 2000)); i = 80 * (cos(PI * a / 2000)); j2 = 50 * (sin(PI * a / 2000)); i2 = 50 * (cos(PI * a / 2000)); tft.drawLine(i2 + 235, j2 + 169, i + 235, j + 169, tft.color565(0, 0, 0)); tft.fillRect(200, 153, 75, 33, 0x0000); tft.setTextSize(3); tft.setTextColor(0xffff); if ((a/20)>99)

In this template, We display simple images one after each other very fast by bitmap function. So you can make your animation by this trick.  Download the .h file and add it to folder of the Arduino sketch.

In this template, We just display some images by RGBbitmap and bitmap functions. Just make a code for touchscreen and use this template.  Download the .h file and add it to folder of the Arduino sketch.

Nextion is a Human Machine Interface （HMI） solution combining an onboard processor and memory touch display with Nextion Editor software for HMI GUI project development.

Using the Nextion Editor software, you can quickly develop the HMI GUI by drag-and-drop components (graphics, text, button, slider, etc.) and ASCII text-based instructions for coding how components interact on the display side.

RTT-GUIis an open source GUI framework for embedded system. The project is forked fromRT-Thread Package -- GUI Engineand has been heavily refactored for Arduino.

RTT-GUI is built on top of the. The later provides low-level device drivers for the former through common and graphic device operations./* common device operations (RT-Thread: "rtdef.h") */struct rt_device_ops {rt_err_t (*init)(rt_device_t dev);rt_err_t (*open)(rt_device_t dev, rt_uint16_t oflag);rt_err_t (*close)(rt_device_t dev);rt_size_t (*read)(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);rt_size_t (*write)(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);rt_err_t (*control)(rt_device_t dev, int cmd, void *args);};

/* graphic device operations (RTT-GUI: "driver.h") */struct rtgui_graphic_driver_ops {void (*set_pixel)(rtgui_color_t *c, int x, int y);void (*get_pixel)(rtgui_color_t *c, int x, int y);void (*draw_hline)(rtgui_color_t *c, int x1, int x2, int y);void (*draw_vline)(rtgui_color_t *c, int x , int y1, int y2);void (*draw_raw_hline)(rt_uint8_t *pixels, int x1, int x2, int y);};

RTT-GUI provides a set of basic graphic functions./* graphic functions (RTT-GUI: "dc.h") */void rtgui_dc_draw_point(rtgui_dc_t *dc, int x, int y);void rtgui_dc_draw_vline(rtgui_dc_t *dc, int x, int y1, int y2);void rtgui_dc_draw_hline(rtgui_dc_t *dc, int x1, int x2, int y);void rtgui_dc_draw_line(rtgui_dc_t *dc, int x1, int y1, int x2, int y2);void rtgui_dc_draw_rect(rtgui_dc_t *dc, rtgui_rect_t *rect);void rtgui_dc_fill_rect(rtgui_dc_t *dc, rtgui_rect_t *rect);void rtgui_dc_draw_round_rect(rtgui_dc_t *dc, rtgui_rect_t *rect, int r);void rtgui_dc_fill_round_rect(rtgui_dc_t *dc, rtgui_rect_t *rect, int r);void rtgui_dc_draw_annulus(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r1, rt_int16_t r2, rt_int16_t start, rt_int16_t end);void rtgui_dc_draw_pie(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end);void rtgui_dc_fill_pie(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end);void rtgui_dc_draw_polygon(rtgui_dc_t *dc, const int *vx, const int *vy, int count);void rtgui_dc_fill_polygon(rtgui_dc_t *dc, const int *vx, const int *vy, int count);void rtgui_dc_draw_circle(rtgui_dc_t *dc, int x, int y, int r);void rtgui_dc_fill_circle(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r);void rtgui_dc_draw_arc(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t r, rt_int16_t start, rt_int16_t end);void rtgui_dc_draw_ellipse(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t rx, rt_int16_t ry);void rtgui_dc_fill_ellipse(rtgui_dc_t *dc, rt_int16_t x, rt_int16_t y, rt_int16_t rx, rt_int16_t ry);

When finished drawing,rtgui_dc_end_drawing()should be involved to releasedevice contextand trigger rendering process./* device context functions (RTT-GUI: "dc.h") */rtgui_dc_t *rtgui_dc_begin_drawing(rtgui_widget_t *owner);void rtgui_dc_end_drawing(rtgui_dc_t *dc, rt_bool_t update);

RTT-GUI currently supports displaying ASCII and simplified Chinese (Unicode) characters. Two size of fonts are available, 12 and 16 pixel points, for each character set (asc12,asc16,hz12andhz16).

If the SD card driver is available, it is recommended to store the font data (here) in SD card to save space (setCONFIG_USING_FONT_FILE == 1). RTT-GUI by default checks/font/directory for fonts./* font config (RTT-GUI: "guiconfig.h") */#define CONFIG_USING_FONT_12 (0)#define CONFIG_USING_FONT_16 (1)#define CONFIG_USING_FONT_HZ (0)#define CONFIG_USING_FONT_FILE (1)

RTT-GUI currently supports decoding images with the following format:BMPPNG(experimental support), based onLode Vandevenne"s LodePNG projectXPM, RTT-GUI internal used format

All the decoder are optional and configurable./* image decoder config (RTT-GUI: "guiconfig.h") */#define CONFIG_USING_IMAGE_XPM (1)#define CONFIG_USING_IMAGE_BMP (1)#define CONFIG_USING_IMAGE_JPEG (1)#define CONFIG_USING_IMAGE_PNG (0)

/* image functions (RTT-GUI: "image.h") */rtgui_image_t *rtgui_image_create_from_file(const char *type, const char *fn, rt_int32_t scale, rt_bool_t load);rtgui_image_t *rtgui_image_create_from_mem(const char *type, const rt_uint8_t *data, rt_size_t size, rt_int32_t scale, rt_bool_t load);void rtgui_image_destroy(rtgui_image_t *image);void rtgui_image_get_rect(rtgui_image_t *image, rtgui_rect_t *rect);void rtgui_image_blit(rtgui_image_t *image, rtgui_dc_t *dc, rtgui_rect_t *rect);

The most interesting functions are here!RTT-GUI is aclient-serverkind of framework. The server thread starts automatically, which dispatches events to clients. The clients are widgets, which handle events.

Very similar to other event propagation mechanism, a RTT-GUI event is propagating from the topmost widget (a mainWindow) to the deepest widget and the propagation will stop once the event been handled.

EveryRTT-GUI application has to attach to a thread and each thread can be attached byonly one RTT-GUI application.Therefore whenCREATE_APP_INSTANCE()been involved, the new application will attach to the thread that created it. If there is another application already attached,CREATE_APP_INSTANCE()will fail (if so,app == RT_NULL).

The next step is to create a mainWindowholding all other widgets.main_win = CREATE_MAIN_WIN(win_event_handler, "Demo Window",RTGUI_WIN_STYLE_DEFAULT);

Inside the event handler function, we could also involve the defaultWindowevent handler (by involvingDEFAULT_HANDLER(obj)()) and only do something special with the interested events (e.g.PAINT).rt_bool_t win_event_handler(void *obj, rtgui_evt_generic_t *evt) {rt_bool_t done = RT_FALSE;if (DEFAULT_HANDLER(obj)) {done = DEFAULT_HANDLER(obj)(obj, evt);}if (IS_EVENT_TYPE(evt, PAINT)) {done = show_demo(TO_WIN(obj));}return done;}

The parameters ofCREATE_LABEL_INSTANCE():Pointer to parent widget.Pointer to event handler function.Pointer to position and size structure (type:rtgui_rect_t).Label text.

CREATE_BUTTON_INSTANCE()does"t provide the parameter to set position and size. However for any widget, those can be changed by involvingrtgui_widget_set_rect().

A good news is we could use sizer (Box) to automate it.sizer = CREATE_BOX_INSTANCE(main_win, RTGUI_HORIZONTAL, 0);WIDGET_ALIGN_SET(label, STRETCH);WIDGET_ALIGN_SET(btn, STRETCH);rtgui_box_layout(sizer);

The parameters ofCREATE_BOX_INSTANCE():Pointer to parent widget. The parent widget must be aContaineror widget "inherited" fromContainer(e.g.Window).Sizer style,RTGUI_HORIZONTALorRTGUI_VERTICAL.Border size.

When creation complete, the sizer is attached to its parent.rtgui_box_layout()triggers the rearrangement of the positions and sizes of the immediate children of the sizer"s parent.

The final step is to show the mainWindowand spin up the RTT-GUI application.rtgui_win_show(main_win, RT_FALSE);rtgui_app_run(app);DELETE_WIN_INSTANCE(main_win);rtgui_app_uninit(app);

rtgui_app_run()involves theapplication event handlerand doesn"t return until the mainWindowclosed.DELETE_WIN_INSTANCE()andrtgui_app_uninit()then destroy the children widgets and release resources.

Beside programmatical design, a JSON like, text based GUI configuration is also available. The same design in last section can be transformed into the following script.APP: {PARAM: {// name, handler"Demo App", NULL,},MWIN: {PARAM: {// title, handler"Demo Window", hdl,},BOX: {PARAM: {// orient, border size// orient: 1, HORIZONTAL; 2, VERTICAL1, 0,},ID: 0,},LABEL: {PARAM: {// size, handler, textNULL, NULL, "Label Demo",},// CENTER_HORIZONTALTEXTALIGN: 0x01,// RTGUI_ALIGN_STRETCHALIGN: 0x20,},BUTTON: {PARAM: {// handler, type, text// type: 0x00, NORMAL; 0x10, PUSHNULL, 0, "Button Demo",},// RTGUI_ALIGN_STRETCHALIGN: 0x20,},},}

MWINrepresents the mainWindow. There is another element --WIN, represents the normalWindow. One RTT-GUI application can have multiple normalWindows but only one mainWindow.

In sketch side, the first step is involvingrtgui_design_init()to setup parser.design_contex_t ctx;const hdl_tbl_entr_t hdl_tbl[] = {{ "hdl", (void *)win_event_handler },{ RT_NULL, RT_NULL },};obj_tbl_entr_t obj_tbl[1];rtgui_design_init(&ctx, design_read, hdl_tbl, obj_tbl, 1));

The parameters ofrtgui_design_init():Pointer to parser context (value assigned by callee).Pointer to design reading function.Pointer to handler function table.Pointer to object table.Object table size.

When script stored as text file, the function may be defined as below.#define DESIGN_FILE "/design/demo.gui"char buf[512];rt_err_t design_read(char **_buf, rt_uint32_t *sz) {*sz = (rt_uint32_t)read(designFile, buf, sizeof(buf));*_buf = buf;return RT_EOK;}

The next step is paring the design by involvingrtgui_design_parse(). The following example assumes the script is stored as text file.int designFile = -1;designFile = open(DESIGN_FILE, O_RDONLY);rtgui_design_parse(&ctx);close(designFile);

When parsing completed, the requested widget pointers can then be accessed from object table.sizer = (rtgui_box_t *)obj_tbl[0];rtgui_box_layout(sizer);

The RTT-GUI application and mainWindowpointers are available inparser context.rtgui_win_show(ctx.win, RT_FALSE);rtgui_app_run(ctx.app);DELETE_WIN_INSTANCE(ctx.win);rtgui_app_uninit(ctx.app);

You may observe a difference on display after run both demos: For the dynamic design demo, there is no title bar on the mainWindow. The reason is when creating mainWindow, the design parser uses the default style,RTGUI_WIN_STYLE_MAINWIN. However in the other demo, we explicitly use the styleRTGUI_WIN_STYLE_DEFAULT(to show the mainWindowas a normalWindow).

Adafruit 2.8" TFT Touch Shield v2ILI9341 (LCD) with SPI interfaceFT6206 (touch screen) with IIC interfaceSSD1331 (LCD) with SPI interfaceHardware buttons

Generic 0.96" OLED moduleSSD1306 (LCD) with SPI interface/* hardware config (RT-Thread: "rtconfig.h") */// #define CONFIG_USING_ADAFRUIT_TFT_CAPACITIVE// #define CONFIG_USING_TINYSCREEN// #define CONFIG_USING_SSD1306_SPI4

/* RT-Thread device name (RTT-GUI: "guiconfig.h") */#define CONFIG_GUI_DEVICE_NAME "ILI9341" // RGB565#define CONFIG_TOUCH_DEVICE_NAME "FT6206"// #define CONFIG_GUI_DEVICE_NAME "SSD1331" // RGB565// #define CONFIG_KEY_DEVICE_NAME "BTN"// #define CONFIG_GUI_DEVICE_NAME "SSD1306" // MONO/* color */#define CONFIG_USING_MONO (0)#define CONFIG_USING_RGB565 (1)#define CONFIG_USING_RGB565P (0)#define CONFIG_USING_RGB888 (0)

/* RT-Thread device name (RTT-GUI: "guiconfig.h") */#define CONFIG_GUI_DEVICE_NAME "ILI9341"#define CONFIG_TOUCH_DEVICE_NAME "FT6206"/* color */#define CONFIG_USING_MONO (0)#define CONFIG_USING_RGB565 (1)#define CONFIG_USING_RGB565P (0)#define CONFIG_USING_RGB888 (0)/* hardware config (RT-Thread: "rtconfig.h") */#define CONFIG_USING_TINYSCREEN

/* RT-Thread device name (RTT-GUI: "guiconfig.h") */#define CONFIG_GUI_DEVICE_NAME "SSD1331"#define CONFIG_KEY_DEVICE_NAME "BTN"/* color */#define CONFIG_USING_MONO (0)#define CONFIG_USING_RGB565 (1)#define CONFIG_USING_RGB565P (0)#define CONFIG_USING_RGB888 (0)

/* RT-Thread device name (RTT-GUI: "guiconfig.h") */#define CONFIG_GUI_DEVICE_NAME "SSD1306"/* color */#define CONFIG_USING_MONO (1)#define CONFIG_USING_RGB565 (0)#define CONFIG_USING_RGB565P (0)#define CONFIG_USING_RGB888 (0)

I changed the Adafruit libraries for TFT: GFX , TFTLCD and TouchScreen. I join all in this one library, the library SPFD5408, to avoid problems with duplicate libraries and enables also have the original library Adafruit ready for use in other projects with another TFT hardware.

I bought a cheap LCD screen for a project I"m working on to get my feet wet with programming LCD touch screens before buying a "full-size" screen. But i can not find any libraries or code to get it to display anything. Ive downloaded the new ILI9341 library along with 4-5 other ones and can not get it to display or do anything.

Arduino has always helped to build projects easily and make them look more attractive.  Programming an LCD screen with touch screen option might sound as a complicated task, but the Arduino libraries and shields had made it really easy. In this project we will use a 2.4” Arduino TFT LCD screen to build our own Arduino Touch Screen calculator that could perform all basic calculations like Addition, Subtraction, Division and Multiplication.

Before we actually dive into the project it is important to know, how this 2.4” TFT LCD Module works and what are the types present in it. Let us take a look at the pinouts of this 2.4” TFT LCD screen module.

As you can see there are 28 pins which will perfectly fit into any Arduino Uno / Arduino Mega Board. A small classification of these pins is given in the table below.

As you can see the pins can be classified in to four main classifications such as LCD Command Pins, LCD Data Pins, SD Card Pins and Power Pins, We need not know much about the detailed working of these pins since they will be take care by our Arduino Library.

You can also find an SD card slot at the bottom of the module shown above, which can be used to load an SD card with bmp image files, and these images can be displayed in our TFT LCD screen using the Arduino Program.

Another important thing to note is your Interface IC. There are many types of TFT modules available in the market starting from the original Adafruit TFT LCD module to cheap Chinese clones. A program which works perfectly for your Adafruit shield might not work the same for Chinese breakout boards. So, it is very important to know which types of LCD display your are holding in hand. This detail has to be obtained from the vendor. If you are having a cheap clone like mine then it is most probably using the ili9341 driver IC.You can follow this TFT LCD interfacing with Arduino tutorial to try out some basic example programs and get comfortable with the LCD screen. Also check out our other TFT LCD projects with Arduino here:

If you planning to use the touch screen function of your TFT LCD module, then you have to calibrate it to make it work properly.  A LCD screen without calibration might work unlikely, for instance you might touch at one place and the TFT might respond for a touch at some other place. These calibrations results will not be similar for all boards and hence you are left on your own to do this.

The 2.4” TFT LCD screen is a perfect Arduino Shield. You can directly push the LCD screen on top of the Arduino Uno and it will perfectly match with the pins and slid in through. However, as matters of safety cover the Programming terminal of your Arduino UNO with a small insulation tape, just in case if the terminal comes in contact with your TFT LCD screen. The LCD assembled on UNO will look something like this below.

We are using the SPFD5408 Library to get this arduino calculator code working. This is a modified library of Adafruit and can work seamlessly with our LCD TFT Module. You can check the complete program at the end of this Article.

Now, open Arduino IDE and select Sketch -> Include Librarey -> Add .ZIP library. A browser window will open navigate to the ZIP file and click “OK”. You should notice “Library added to your Libraries” on the bottom-left corner of Arduino, if successful. A detailed guide to do the same is given in the Interfacing Tutorial.

Now, you can use the code below in your Arduino IDE and upload it to your Arduino UNO for the Touch Screen Calculator to work. Further down, I have explained the code into small segments.

As said earlier we need to calibrate the LCD screen to make it work as expected, but don’t worry the values given here are almost universal. The variables TS_MINX, TS_MINY, TS_MAXX, and TS_MAXY decide the calibration of the Screen. You can toy around them if you feel the calibration is not satisfactory.

As we know the TFT LCD screen can display a lot of colours, all these colours have to be entered in hex value. To make it more human readable we assign these values to a variable as shown below.

The final step is to calculate the result and display them on TFT LCD Screen. This arduino calculator can perform operation with 2 numbers only. These two numbers are named as variables “Num1” and “Num2”. The variable “Number” gives and takes value from Num1 and Num2 and also bears the result.

The working of this Arduino Touch Screen Calculator is simple. You have to upload the below given code on your Arduino and fire it up. You get the calculator displayed on your LCD screen.

Has anyone explored XOD support for LittlevGL (https://littlevgl.com)? - an open-source embedded gui library that allows simple construction of touchscreen interfaces.

This would complement the excellent 4D Systems libraries built for XOD - by gabbapeople/4d-ulcd/ and bradzilla84/visi-genie-extra-library. These tools are hugely enabling - providing a code-free development environment for building sophisticated user interfaces for low cost, DIY instrumentation - and we’ve been using these for training in the international Biomaker programme (https://www.biomaker.org).

LittlevGL offers support for constructing new interfaces - with support for a wide range of low cost touchscreens. For our African programme, we’d like to support integrated Arduino-touchscreen devices like: https://www.aliexpress.com/item/32964204802.html

This post is an introduction to the Nextion display with the Arduino. We’re going to show you how to configure the display for the first time, download the needed resources, and how to integrate it with the Arduino UNO board. We’ll also make a simple graphical user interface to control the Arduino pins.

Nextion is a Human Machine Interface (HMI) solution. Nextion displays are resistive touchscreens that makes it easy to build a Graphical User Interface (GUI). It is a great solution to monitor and control processes, being mainly applied to IoT applications.

To design the GUI, you use the Nextion Editor, in which you can add buttons, gauges, progress bars, text labels, and more to the user interface in an easy way. We have the 2.8” Nextion display basic model, that is shown in the following figure.

Connecting the Nextion display to the Arduino is very straightforward. You just need to make four connections: GND, RX, TX, and +5V. These pins are labeled at the back of your display, as shown in the figure below.

You can power up the Nextion display directly from the Arduino 5V pin, but it is not recommended. Working with insufficient power supply may damage the display. So, you should use an external power source. You should use a 5V/1A power adaptor with a micro USB cable. Along with your Nextion display, you’ll also receive a USB to 2 pin connector, useful to connect the power adaptor to the display.

The best way to get familiar with a new software and a new device is to make a project example. Here we’re going to create a user interface in the Nextion display to control the Arduino pins, and display data.

The user interface has two pages: one controls two LEDs connected to the Arduino pins, and the other shows data gathered from the DHT11 temperature and humidity sensor;

We won’t cover step-by-step how to build the GUI in the Nextion display. But we’ll show you how to build the most important parts, so that you can learn how to actually build the user interface. After following the instructions, you should be able to complete the user interface yourself.

All components have an attribute called objname. This is the name of the component. Give good names to your components because you’ll need them later for the Arduino code. Also note that each component has one id number that is unique to that component in that page. The figure below shows the objname and id for the slider.

You should trigger an event for the touchable components (the buttons and the slider) so that the Arduino knows that a component was touched. You can trigger events when you press or when you release a component.

Adding more pages to your GUI is really simple. On the top right corner, in the Page area, select the Add button to add a new page. A new page will be created. In this case, page1.

Notice that we have labels to hold the units like “ºC”, “ºF” and “%”, and empty labels that will be filled with the readings when we have our Arduino code running.

Once the GUI is ready, you need to write the Arduino code so that the Nextion can interact with the Arduino and vice-versa. Writing code to interact with the Nextion display is not straightforward for beginners, but it also isn’t as complicated as it may seem.

A good way to learn how to write code for the Arduino to interact with the Nextion display is to go to the examples folder in the Nextion library folder and explore. You should be able to copy and paste code to make the Arduino do what you want.

The first thing you should do is to take note of your components in the GUI that will interact with the Arduino and take note of their ID, names and page. Here’s a table of all the components the code will interact to (your components may have a different ID depending on the order you’ve added them to the GUI).

In this post we’ve introduced you to the Nextion display. We’ve also created a simple application user interface in the Nextion display to control the Arduino pins. The application built is just an example for you to understand how to interface different components with the Arduino – we hope you’ve found the instructions as well as the example provided useful.

The 1.54inch LCD uses the PH2.0 8PIN interface, which can be connected to the Raspberry Pi according to the above table: (Please connect according to the pin definition table. The color of the wiring in the picture is for reference only, and the actual color shall prevail.)

The built-in controller used in this LCD is ST7789VW, which is an LCD controller with 240 x RGB x 320 pixels, while the pixels of this LCD itself is 135 (H)RGB x 240(V). There are two types of horizontal and vertical screens, so the internal RAM of the LCD is not fully used.

The LCD supports 12-bit, 16-bit, and 18-bit input color formats per pixel, namely RGB444, RGB565, and RGB666 three color formats, this routine uses RGB565 color format, which is also a commonly used RGB format

If you need to draw pictures, or display Chinese and English characters, we provide some basic functions here about some graphics processing in the directory RaspberryPi\c\lib\GUI\GUI_Paint.c(.h).

Set points of the display position and color in the buffer: here is the core GUI function, processing points display position and color in the buffer.

2. The module_init() function is automatically called in the INIT () initializer on the LCD, but the module_exit() function needs to be called by itself

Python has an image library PIL official library link, it do not need to write code from the logical layer like C, can directly call to the image library for image processing. The following will take 1.54inch LCD as an example, we provide a brief description for the demo.

Now you should test my new library against the PCgraphicstest.zip that doesn"t use GUIslice. This will show you the best times you can get. If then you test my library against GUIslice and its much slower then I would guess the touch handling for the Capacitive chip is what is the problem. If so, you can confirm its the problem by turning off touch in ard-shld-eastrising_35_ili9488_cap.h as so:

This library enables you to use Hardware-based PWM channels on Arduino AVR ATtiny-based boards (ATtiny3217, etc.), using megaTinyCore, to create and output PWM to pins.

This library enables you to use ISR-based PWM channels on Arduino AVR ATtiny-based boards (ATtiny3217, etc.), using megaTinyCore, to create and output PWM any GPIO pin.

Small low-level classes and functions for Arduino: incrementMod(), decToBcd(). strcmp_PP(), PrintStr, PrintStrN, printPad{N}To(), printIntAsFloat(), TimingStats, formUrlEncode(), FCString, KString, hashDjb2(), binarySearch(), linearSearch(), isSorted(), reverse(), and so on.

Cyclic Redundancy Check (CRC) algorithms (crc8, crc16ccitt, crc32) programmatically converted from C99 code generated by pycrc (https://pycrc.org) to Arduino C++ using namespaces and PROGMEM flash memory.

Various sorting algorithms for Arduino, including Bubble Sort, Insertion Sort, Selection Sort, Shell Sort (3 versions), Comb Sort (4 versions), Quick Sort (3 versions).

Date, time, timezone classes for Arduino supporting the full IANA TZ Database to convert epoch seconds to date and time components in different time zones.

Clock classes for Arduino that provides an auto-incrementing count of seconds since a known epoch which can be synchronized from external sources such as an NTP server, a DS3231 RTC chip, or an STM32 RTC chip.

Useful Arduino utilities which are too small as separate libraries, but complex enough to be shared among multiple projects, and often have external dependencies to other libraries.

Fast and compact software I2C implementations (SimpleWireInterface, SimpleWireFastInterface) on Arduino platforms. Also provides adapter classes to allow the use of third party I2C libraries using the same API.

Enables Bluetooth® Low Energy connectivity on the Arduino MKR WiFi 1010, Arduino UNO WiFi Rev.2, Arduino Nano 33 IoT, Arduino Nano 33 BLE and Nicla Sense ME.

ESP32 + LwIP ENC28J60, including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

ESP32 + LwIP W5500 / ENC28J60, including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

ESP32 + LwIP W5500, including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

(ESP8266 + LwIP W5500 / W5100(S) / ENC28J60) Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

Fully Asynchronous UDP Library for RASPBERRY_PI_PICO_W using CYW43439 WiFi with arduino-pico core. The library is easy to use and includes support for Unicast, Broadcast and Multicast environments.

ESP32 + LwIP LAN8720, including WT32-S1, ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

The last hope for the desperate AVR programmer. A small (344 bytes) Arduino library to have real program traces and to find the place where your program hangs.

An Arduino library that takes input in degrees and output a string or integer for the 4, 8, 16, or 32 compass headings (like North, South, East, and West).

DSpotterSDK_Maker_33BLE provides offline speech recognition function for developers on Arduino Nano 33 BLE Sense, which can recognize trigger words and command words.

DSpotterSDK_Maker_PortentaH7 provides offline speech recognition function for developers on Arduino Portenta H7, which can recognize trigger words and command words.

DSpotterSDK_Maker_RP2040 provides offline speech recognition function for developers on Arduino Nano RP2040 Connect, which can recognize trigger words and command words.

Directly interface Arduino, esp8266, and esp32 to DSC PowerSeries and Classic security systems for integration with home automation, remote control apps, notifications on alarm events, and emulating DSC panels to connect DSC keypads.

This library enables you to use Hardware-based PWM channels on Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.), using DxCore, to create and output PWM.

This library enables you to use ISR-based PWM channels on Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.), using DxCore, to create and output PWM any GPIO pin.

Small and easy to use Arduino library for using push buttons at INT0/pin2 and / or any PinChangeInterrupt pin.Functions for long and double press detection are included.Just connect buttons between ground and any pin of your Arduino - that"s itNo call of begin() or polling function like update() required. No blocking debouncing delay.

Arduino library for controlling standard LEDs in an easy way. EasyLed provides simple logical methods like led.on(), led.toggle(), led.flash(), led.isOff() and more.

OpenTherm Library to control Central Heating (CH), HVAC (Heating, Ventilation, Air Conditioning) or Solar systems by creating a thermostat using Arduino IDE and ESP32 / ESP8266 hardware.

ESP32 (including ESP32-S2, ESP32-S3 and ESP32-C3), ESP8266 WiFi Connection Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

ESP32 + LwIP ENC28J60, including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

(ESP32 + LwIP W5500 / ENC28J60), including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager, with enhanced GUI and fallback Web ConfigPortal.

ESP32 + LwIP W5500, including ESP32-S2, ESP32-S3 and ESP32-C3, Connection and Credentials Manager using AsyncWebServer, with enhanced GUI and fallback Web ConfigPortal.

WizFi360/ESP8266/ESP32-AT library for Arduino providing an easy-to-use way to control WizFi360/ESP8266-AT/ESP32-AT WiFi shields using AT-commands. For AVR, Teensy, SAM DUE, SAMD21, SAMD51, STM32, nRF52, SIPEED_MAIX_DUINO and RP2040-based (Nano_RP2040_Connect, RASPBERRY_PI_PICO, etc.) boards using WizFi360/ESP8266/ESP32 AT-command shields.

Library to configure MultiWiFi/Credentials at runtime for ESP32 (including ESP32-S2, ESP32-S3 and ESP32-C3) and ESP8266 boards. With enhanced GUI and fallback web ConfigPortal.

ezTime - pronounced "Easy Time" - is a very easy to use Arduino time and date library that provides NTP network time lookups, extensive timezone support, formatted time and date strings, user events, millisecond precision and more.

ESP32 VGA, PAL/NTSC Color Composite, SSD1306 ILI9341 ST7789 Controller, PS/2 Mouse and Keyboard Controller, Graphics Library, Graphical User Interface (GUI), Sound Engine, Game Engine and ANSI/VT Terminal

A library for implementing fixed-point in-place Fast Fourier Transform on Arduino. It sacrifices precision and instead it is way faster than floating-point implementations.

The GCodeParser library is a lightweight G-Code parser for the Arduino using only a single character buffer to first collect a line of code (also called a "block") from a serial or file input and then parse that line into a code block and comments.

Arduino library for the Flysky/Turnigy RC iBUS protocol - servo (receive) and sensors/telemetry (send) using hardware UART (AVR, ESP32 and STM32 architectures)

An Arduino library to control the Iowa Scaled Engineering I2C-IRSENSE ( https://www.iascaled.com/store/I2C-IRSENSE ) reflective infrared proximity sensor.

Convinient way to map a push-button to a keyboard key. This library utilize the ability of 32u4-based Arduino-compatible boards to emulate USB-keyboard.

This library allows you to easily create light animations from an Arduino board or an ATtiny microcontroller (traffic lights, chaser, shopkeeper sign, etc.)

LiquidCrystal fork for displays based on HD44780. Uses the IOAbstraction library to work with i2c, PCF8574, MCP23017, Shift registers, Arduino pins and ports interchangably.

This library enables you to use ISR-based PWM channels on RP2040-based boards, such as Nano_RP2040_Connect, RASPBERRY_PI_PICO, with Arduino-mbed (mbed_nano or mbed_rp2040) core to create and output PWM any GPIO pin.

Arduino library for MCP4728 quad channel, 12-bit voltage output Digital-to-Analog Convertor with non-volatile memory and I2C compatible Serial Interface

This library enables you to use ISR-based PWM channels on an Arduino megaAVR board, such as UNO WiFi Rev2, AVR_Nano_Every, etc., to create and output PWM any GPIO pin.

Replace Arduino methods with mocked versions and let you develop code without the hardware. Run parallel hardware and system development for greater efficiency.

A library package for ARDUINO acting as ModBus slave communicating through UART-to-RS485 converter. Originally written by Geabong github user. Improved by Łukasz Ślusarczyk.

This library enables you to use ISR-based PWM channels on an nRF52-based board using Arduino-mbed mbed_nano core such as Nano-33-BLE to create and output PWM any GPIO pin.

This library enables you to use ISR-based PWM channels on an nRF52-based board using Adafruit_nRF52_Arduino core such as Itsy-Bitsy nRF52840 to create and output PWM any GPIO pin.

An Arduino library for the Nano 33 BLE Sense that leverages Mbed OS to automatically place sensor measurements in a ring buffer that can be integrated into programs in a simple manner.

his library enables you to use Hardware-based PWM channels on RP2040-based boards, such as Nano_RP2040_Connect, RASPBERRY_PI_PICO, with either Arduino-mbed (mbed_nano or mbed_rp2040) or arduino-pico core to create and output PWM to any GPIO pin.

This library enables you to use SPI SD cards with RP2040-based boards such as Nano_RP2040_Connect, RASPBERRY_PI_PICO using either RP2040 Arduino-mbed or arduino-pico core.

This library enables you to use ISR-based PWM channels on RP2040-based boards, such as ADAFRUIT_FEATHER_RP2040, RASPBERRY_PI_PICO, etc., with arduino-pico core to create and output PWM any GPIO pin.

The most powerful and popular available library for using 7/14/16 segment display, supporting daisy chaining so you can control mass amounts from your Arduino!

Provides methods to retrieve instant and peak values from the ADC input. The Arduino library SensorWLED splits the input from a varying analog signal from the ADC into components, i.e., provides the capability of a sample-and-hold circuit.

Enables smooth servo movement. Linear as well as other (Cubic, Circular, Bounce, etc.) ease movements for servos are provided. The Arduino Servo library or PCA9685 servo expanders are supported.

Enables reading and writing on SD card using SD card slot connected to the SDIO/SDMMC-hardware of the STM32 MCU. For slots connected to SPI-hardware use the standard Arduino SD library.

Menu library for Arduino with IoT capabilities that supports many input and display devices with a designer UI, code generator, CLI, and strong remote control capability.

Adds tcUnicode UTF-8 support to Adafruit_GFX, U8G2, tcMenu, and TFT_eSPI graphics libraries with a graphical font creation utility available. Works with existing libraries

A library for creating Tickers which can call repeating functions. Replaces delay() with non-blocking functions. Recommanded for ESP and Arduino boards with mbed behind.

This library enables you to use Interrupt from Hardware Timers on an Arduino, Adafruit or Sparkfun AVR board, such as Nano, UNO, Mega, Leonardo, YUN, Teensy, Feather_32u4, Feather_328P, Pro Micro, etc.

This library enables you to use Interrupt from Hardware Timers on supported Arduino boards such as AVR, Mega-AVR, ESP8266, ESP32, SAMD, SAM DUE, nRF52, STM32F/L/H/G/WB/MP1, Teensy, Nano-33-BLE, RP2040-based boards, etc.

I2C EEPROM library. Split from uRTCLib https://github.com/Naguissa/uRTCLib - This library controls any I2C EEPROM, independent ones or incorporated on DS1307 or DS3231 RTCs.

Really tiny library to basic RTC functionality on Arduino. DS1307, DS3231 and DS3232 RTCs are supported. See https://github.com/Naguissa/uEEPROMLib for EEPROM support. Temperature, Alarms, SQWG, Power lost and RAM support.

Monochrome LCD, OLED and eInk Library. Display controller: SSD1305, SSD1306, SSD1309, SSD1312, SSD1316, SSD1318, SSD1320, SSD1322, SSD1325, SSD1327, SSD1329, SSD1606, SSD1607, SH1106, SH1107, SH1108, SH1122, T6963, RA8835, LC7981, PCD8544, PCF8812, HX1230, UC1601, UC1604, UC1608, UC1610, UC1611, UC1617, UC1638, UC1701, ST7511, ST7528, ST7565, ST7567, ST7571, ST7586, ST7588, ST75160, ST75256, ST75320, NT7534, ST7920, IST3020, IST3088, IST7920, LD7032, KS0108, KS0713, HD44102, T7932, SED1520, SBN1661, IL3820, MAX7219, GP1287, GP1247, GU800. Interfaces: I2C, SPI, Parallel.

True color TFT and OLED library, Up to 18 Bit color depth. Supported display controller: ST7735, ILI9163, ILI9325, ILI9341, ILI9486,LD50T6160, PCF8833, SEPS225, SSD1331, SSD1351, HX8352C.

RFC6455-based WebSockets Server and Client for Arduino boards, such as nRF52, Portenta_H7, SAMD21, SAMD51, STM32F/L/H/G/WB/MP1, Teensy, SAM DUE, RP2040-based boards, besides ESP8266/ESP32 (ESP32, ESP32_S2, ESP32_S3 and ESP32_C3) and WT32_ETH01. Ethernet shields W5100, W5200, W5500, ENC28J60, Teensy 4.1 NativeEthernet/QNEthernet or Portenta_H7 WiFi/Ethernet. Supporting websocket only mode for Socket.IO. Ethernet_Generic library is used as default for W5x00. Now supporting RP2040W

Enables network connection (local and Internet) and WiFiStorage for SAM DUE, SAMD21, SAMD51, Teensy, AVR (328P, 32u4, 16u4, etc.), Mega, STM32F/L/H/G/WB/MP1, nRF52, NINA_B302_ublox, NINA_B112_ublox, RP2040-based boards, etc. in addition to Arduino MKR WiFi 1010, Arduino MKR VIDOR 4000, Arduino UNO WiFi Rev.2, Nano 33 IoT, Nano RP2040 Connect. Now with fix of severe limitation to permit sending much larger data than total 4K and using new WiFi101_Generic library

Universal Timer with 1 millisecond resolution, based on system uptime (i.e. Arduino: millis() function or STM32: HAL_GetTick() function), supporting OOP principles.