I bought online this LCD Touchscreen Kuman SC3A-NEW-UK. It uses ILI9486 drivers, but it didn't include any instructions manual, and kumantech.com seems to be devoid of complete technical documentation about SC3A-NEW-UK model.

I am trying to figure out:

  • Which are the minimum connections I have to make between Arduino UNO and the LCD screen.
  • Which "Arduino's C++" (AKA G++ ?) library I need to use in order to display stuff programatically

Arduino UNO & Kuman LCD Touchscreen --> PinSets

To summarize

Just in case it wasn't noticable: I am trying to make a "Hello World" for my SC3A-NEW-UK's LCD Touchscreen from an Arduino UNO board. In other words: just print "Hello World" to see if it works.

What I tried so far

Searching on the Internet wasn't enough. Searching "ILI9486" on Google led me to this Github project:


To see if I can use it, I tried downloading a whole ZIP from this Github project, and inside the Arduino IDE, I tried adding the downloaded library using the option "Include .ZIP library". If I copy-paste the code example provided within README.md (the following) and compile:

#include "Arduino.h"
#include "SPI.h"
#include "tft.h"

// defaults can be changed in tft.begin
// CS=22, DC=21, MOSI=23, MISO=19, SCK=18

TFT tft;
void setup() {
    tft.setRotation(1); //landscape
    tft.print("Hello World!");
void loop(void) {
    for(uint8_t rotation=0; rotation<4; rotation++) {
        tft.print("Hello World!");

...it results in this compile error:

In file included from C:\Users\MyUser\ArduinoProjects\test_external_library\test_external_library.ino:3:0:

C:\Users\MyUser\Documents\Arduino\libraries\Arduino-TFT-Library-ILI9486-master\src/tft.h:5:16: fatal error: FS.h: No such file or directory

compilation terminated.

exit status 1
Error compiling for board Arduino/Genuino Uno.

Line 5 at tft.h says:

#include "FS.h"

...and I have no idea what this FS library is supposed to be, so I don't think I can use that Github project at all... I am tempted to assume that Github's project is dead.

So, perhaps I am fine just using the IDES's built-in TFT library, perhaps like this? I don't know...:

#include <SPI.h>
#include <TFT.h>
#define CS   10
#define DC   9
#define RESET  8 

#define TFT_CYAN    0x07FF
#define TFT_BLACK   0x0000

// Initialization inspired in code example found at
// https://www.arduino.cc/en/Guide/TFT
int dummy_second_cnt = 0;

void setup() {
    // I don't know what's SPI for, anyway...
    // just found it in the code example present at GitHub's library's README.md
    // ...(which I am not trying to use at this point, so it's useless in this code example... commented-out for reference, just in case)

    tft.print("Hello LCD Screen");


void loop() {
    tft.print("Seconds: ");

This compiled in Arduino IDE, no problem, but I still don't know if it will work well with my screen. I am also confused about initialization of the TFT object and how would I have to wire the LCD screen to the Arduino depending on this initialization:


...i mean, my LCD screen has CS and RESET pins, but what is DC supposed to be here? (in this context, I don't think it stands for "Direct Current"... but there's no DC pin reference in my LCD screen written "AS IS"... ?? This brings me more confusion...

...specially having in mind that I don't know how am I supposed to wire the LCD screen to the Arduino yet. It seems the LCD pins have been designed to fit in directly to the Arduino board without thinking too much about it (like the shape is the same), but that would make the screen getting all the Arduino UNO's pins for itself, so I don't think so...

These are the LCD_* pins present at my LCD screen:

  • LCD_RST (Reset I guess)
  • LCD_CS
  • LCD_RS
  • LCD_WR (Write I guess)
  • LCD_RD (Read I guess)

(and the following I guess are 8-bit digital pins):

  • LCD_D0
  • LCD_D1
  • LCD_D2
  • LCD_D3
  • LCD_D4
  • LCD_D5
  • LCD_D6
  • LCD_D7

It also has 5V, 3V3 and GND pins (Which I guess are for power)

...so, powering the screen shouldn't be a big deal, but, how am I supposed to connect everything else? I am completely misguided about how am I supposed to interact with the screen from Arduino code... what is RS pin for? Should I use 4-bit or 8-bit mode? (I think 4-bit would imply connecting 4 digital pins for the screen, and 8-bit the whole 8 pins from screen to the Arduino UNO board)? Should I use LCD_RD and LCD_WR? Well you have a picture of my confusion.

Searching for documentation in the internet only leads me to partial examples. Not even using the model Ref ( SC3A-NEW-UK ) or the driver's ref ( ILI9486 ) as keywords for searching in Google leads me to clear documentation about howto wire stuff, or which specific libraries should I use...

Even though I know how to control Input/Output in Arduino code to interact with analog/digital input and output pins at will with C++ in Arduino code (but even so, I think I'm still an Arduino n00b), this LCD screen's physical interface is very confusing to me...

Can you help me to overcome this confusion, please? I'd rather have my mind clear before making any physical wiring and fry something...

PD: I have read somewhere that this SC3A-NEW-UK Touchscreen is made to shield Arduino MEGA boards (by fitting the PINs directly into it), but mine is an Arduino UNO Board! (perhaps I shouldn't have bought This LCD model, then?)... but I have sets of wires, pinboards and stuff... I don't want to give up the idea of harnessing this LCD screen using an Arduino UNO. I don't care about shielding feature, I just want to wire it and make it work. I will figure out how to shield electronics later on.

EDIT: Based on VE7JRO's answer, I managed to map the connections by seeing where the connections would go if I just fit the connections shielding the Arduino UNO, the way VE7JRO suggested:

| Arduino UNO  |    LCD Screen    |
|     GND      |        GND       |
|      5V      |         5V       |
|     3.3V     |       3.3V       |
|      A0      |      LCD_RD      |
|      A1      |      LCD_WR      |
|      A2      |      LCD_RS      |
|      A3      |      LCD_CS      |
|      A4      |      LCD_RST     |
|      A5      |       NONE       |
|       8      |      LCD_D0      |
|       9      |      LCD_D1      |
|    2 TO 7    | LCD_D2 TO LCD_D7 |
|      10      |       SD_SS      |
|      11      |       SD_DI      |
|      12      |       SD_DO      |
|      13      |      SD_SCK      |

I put NONE for A5 input, because that pin of LCD screen doesn't have any name on it. There are another ones without name as well, that I didn't include in this table. I believe (perhaps I'm wrong believing it, I don't know) that those pins without name have no use.

The bad thing about this layout is that it consumes almost all the Arduino pins, so I would not be able to attach additional circuits. However, perhaps I should not be worrying about earning connections yet, before testing the screen.

I still don't know much of the details about what pins do what for the screen, but I have read somewhere that LCD_D0 to LCD_D7 are meant to receive digital data in some kind of 8-bit parallel mode. But I also heard that there is a 4-bit mode. If I could use that mode with this screen, I would be able to have 4 free digital pins for anything else...

Ok, I got the connections mapped. Next step would be trying those three libraries that VE7JRO suggested.

EDIT2: I tested VE7JRO's code. LCD Screen did draw the interface as expected. But buttons didn't respond. I found out the code sample needs further calibration.

So, I started printing through the Serial the coordinates of the object TSPoint p, to find out if there was something wrong with the z coordinate. And indeed, there was: setting MINPRESSURE and MAXPRESSURE according to what I saw in Serial Monitor while I pressed and I didn't pressed, fixed this. However, there's another more issue...

...when I tell Serial to print if the boolean operation down && on_btn.contains(pixel_x, pixel_y) results in either true or false, it prints it is false... while I am touching ON button. down is true for sure (after I calibrated MINPRESSURE and MAXPRESSURE constants); so that must mean on_btn.contains(pixel_x, pixel_y) is returning false for some reason. If I figure out why, I will be able to accomplish that the ON Button does what it's supposed to when I press it. And that will mean I will have completed calibration process. I would bet perhaps pixel_x and pixel_y need calibration as I already did with pressure detection based on z; or perhaps contains method is not reliable and I have to figure out some other methodology... I will tell you after I try

All stroken through is based on assumption that Z is depth, and Y is height; Actually, it seems to be the other way around...

After somemore trial-and-error research, it seems that Z is height, and Y is depth (at least within the TSPoint object's properties x, y and z, which values seem way more reliable than the pixel_x and pixel_y values, which purpose seems to be if the pixel is contained in the button's squares and nothing else)... I still don't get why is there the need to use this within the function Touch_getXY(void):

if (pressed) {
    pixel_x = map(p.x, TS_LEFT, TS_RT, 0, tft.width()); //.kbv makes sense to me
    pixel_y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());

...because their values when I touch the screen with the touchpen are very weird. I tried to guess which ranges they go, and they don't make sense when I move around the screen. Perhaps it's because this strange "Z instead of Y" mapping from the TSPoint object. Perhaps pixel_x and pixel_y don't need to make an intuitive sense, perhaps it's just some intrincated in-bound logic that only makes sense within electronics' low-level scope, or within Adafruit_GFX_Button.press method, I don't know... but x, y and z readings from TSPoint object seem very accurate, despite Y being Z and Z being Y...

...perhaps reading any documentation I can find about Adafruit_GFX_Button class, its properties and methods (specially contains) will lead me to comprehend clearly what's wrong...

...also, it might be time to focus on searching those test sketches that VE7JRO talked me about:

There are 22 test sketches that come with the MCUFRIEND_kbv library. One of them scans your display and outputs configuration information (sorry, it's been a while since I tested my screen). Another sketch will draw little boxes in each corner and sides. This is used to get the x y coordinates of the edges of your particular screen (it might be called TouchScreen_Calibr_native.ino).


X is Y? Y is Z? Z is X? I don't know what to think anymore! The last I tried, changing the formula for pixel_x and pixel_y to:

pixel_x = map(p.x, 1023, 0, 0, tft.width());
pixel_y = map(p.y, 1023, 0, 0, tft.height());

...and the constants for the pins:

const int XP = 6, XM = A2, YP = A1, YM = 7;

This seems to make z the pressure axis within TSPoint object, but ends up in strange behaviours:

  • x seems numb (no matter if I press the touchscreen with touchpen or not, neither it's position: it always prints 65 to 70!
  • z seems indeed sensitive to touch pressure, but it's like its sensitivity is different depending on the touchpen's position on screen (altough I'm not a robot, I think I was using more or less the same amount of force with my hand). It prints 0 when i do not touch the screen.
  • y seems sensible to both horizontal and vertical position at the same time! This blows my head.

I don't know what to think anymore...

  • Did I short-circuit something for not paying attention to the script's constants in my previous tests?
  • Was the screen broken from the begginning?
  • Is it a calibration error with values in the script?
  • Might the libraries I am using be broken, or have some kind of bug with my TFT?

This is becoming overwhelmingly more difficult than I thought...

...according to some article I found(in Spanish, sorry), the Touchscreen's initialization's params:

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
  • XP is supposed to be the pin for LCD_D6: 6 in the Arduino.
  • YP is supposed to be the pin for LCD_WR: A1 in the Arduino.
  • XM is supposed to be the pin for LCD_RS: A2 in the Arduino.
  • YM is supposed to be the pin for LCD_D7: 7 in the Arduino.
  • The fifth parameter is supposed to be the resistance measured between LCD_D6 and LCD_RS with the screen unplugged. Unfortunately, my multimeter can't measure it for some reason (I put it in 2000 Ohms mode for reading resistance: I always get '1', the same than when I don't connect anything... like if multimeter's contacts aren't working well, I don't know)... so I left the default 300 value.

I did initializate it well, as far as I know... except the fifth parameter. Would a wrong resistence value make such a big difference in calibration, up to the point this strange behaviours I have seen do happen?

Damn, I am so close... what am I doing wrong?

  • Well, I suceeded compiling @VE7JRO♦ 's code example. Could I just plug the screen shielding the Arduino, load the sketch into the Arduino, and test it right away? Or perhaps it requires a bit more preparations (like resistances or other stuff)? Perhaps should I check the constants for the PINs match my screen before loading the sketch and power everything up? – SebasSBM Dec 28 '19 at 21:38
  • One more thing. This is the first time I'm gonnna test sketches in a physical Arduino. I have done some scripts in a simulator similar to the one in tinkercad.com (this one doesn't let you write the code for Arduino simulation, but lets you sketch some logic with a WYSIWYG interface, and retrieve the code later; there was another as good for electronic simulation years ago on the web, but it seems it's not anymore), but first time I'm gonna plug a real Arduino. If I have the Smart USB serial connected to my computer, do I need the 220AC-DC power unit for testing, or rather not? – SebasSBM Dec 28 '19 at 21:53
  • Well, about the powering while testing stuff: I have read at some forum website, that Arduino's electronics are smart enough to choose which power source to use (either Smart USB or AC converter) by itself. So it can use Smart USB as power source... idk if that power will be enough to power as well the LCD screen, but in case it's not, I guess I can add extra power plugging in the AC Power Unit (but perhaps it's not that simple; specially having in mind the overheating issue)... – SebasSBM Dec 30 '19 at 11:22
  • Perhaps I should stop overthinking it, just plug the screen in, load the compiled code and see what happens? I think I am hesitating too much... – SebasSBM Dec 30 '19 at 11:30
  • What I said about tinkercad.com didn't let you write the script, was wrong. At first it shows the annoying begginner-friendly WYSIWYG logic, but there was an option to switch to scripting mode. Wow, actually tinkercad.com has an awesome electronics/Arduino simulator... – SebasSBM Jan 14 '20 at 17:09

Which are the minimum connections I have to make between Arduino UNO and the LCD screen.

The TFT screen plugs right on top of your Arduino Uno. I have a "cheaper" model with the same size screen and identical pins as your screen (exact same text printed beside the pins).

Before you plug it in, I have a few pieces of advise.

  • It's possible to install the screen one or 2 pins "out of proper alignment", so plug it in before you apply power. Verify the correct pins are in the correct "holes", using the location of the 5V, 3V3 and GND pins as a guide.
  • This screen used lots of power, especially when you are using a test sketch that turns all the pixels on / off and cycles through various graphics / text output to the screen. My Uno's voltage regulator was getting pretty warm after 10 minutes, and I was suppling it with 8 VDC to the barrel jack power input. Using a 12 VDC supply would exacerbate the heat issue, so please be careful.

Which "Arduino's C++" (AKA G++ ?) library I need to use in order to display stuff programatically?

I used the MCUFRIEND_kbv library, Adafruit_GFX library and the Adafruit TouchScreen library, all available in the Arduino IDE Library manager.

There are 22 test sketches that come with the MCUFRIEND_kbv library. One of them scans your display and outputs configuration information (sorry, it's been a while since I tested my screen). Another sketch will draw little boxes in each corner and sides. This is used to get the x y coordinates of the edges of your particular screen (it might be called TouchScreen_Calibr_native.ino).

Getting the screen to display anything is step 1. Step 2 is to calibrate the edges of the screen. Step 3 is to get the touch screen part of it to work.

Here is a sketch I used to test the screen by changing the color of a "box". Touching each of the 2 buttons on the screen changes the "box" color. I've left in all the config data I saved (see the end of this sketch). Your screen is different than mine, so running the test sketches from the library first is where I would start.

#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#include <TouchScreen.h>
#define MINPRESSURE 200
#define MAXPRESSURE 1000

// ALL Touch panels and wiring is DIFFERENT
// copy-paste results from TouchScreen_Calibr_native.ino
// OEM: const int XP = 6, XM = A2, YP = A1, YM = 7; //ID=0x9341
// OEM: const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
const int XP = 7, XM = A1, YP = A2, YM = 6; //320x480 ID=0x9488
const int TS_LEFT = 929, TS_RT = 204, TS_TOP = 963, TS_BOT = 213;

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

Adafruit_GFX_Button on_btn, off_btn;

int pixel_x, pixel_y;     //Touch_getXY() updates global vars
bool Touch_getXY(void)
    TSPoint p = ts.getPoint();
    pinMode(YP, OUTPUT);      //restore shared pins
    pinMode(XM, OUTPUT);
    digitalWrite(YP, HIGH);   //because TFT control pins
    digitalWrite(XM, HIGH);
    bool pressed = (p.z > MINPRESSURE && p.z < MAXPRESSURE);
    if (pressed) {
        pixel_x = map(p.x, TS_LEFT, TS_RT, 0, tft.width()); //.kbv makes sense to me
        pixel_y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
    return pressed;

#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

void setup(void)
    uint16_t ID = tft.readID();
    Serial.print("TFT ID = 0x");
    Serial.println(ID, HEX);
    Serial.println("Calibrate for your Touch Panel");
    if (ID == 0xD3D3) ID = 0x9486; // write-only shield
    tft.setRotation(0);            //PORTRAIT
    on_btn.initButton(&tft,  60, 200, 100, 40, WHITE, CYAN, BLACK, "ON", 2);
    off_btn.initButton(&tft, 180, 200, 100, 40, WHITE, CYAN, BLACK, "OFF", 2);
    tft.fillRect(40, 80, 160, 80, RED);

/* two buttons are quite simple
void loop(void)
    bool down = Touch_getXY();
    on_btn.press(down && on_btn.contains(pixel_x, pixel_y));
    off_btn.press(down && off_btn.contains(pixel_x, pixel_y));
    if (on_btn.justReleased())
    if (off_btn.justReleased())
    if (on_btn.justPressed()) {
        tft.fillRect(40, 80, 160, 80, GREEN);
    if (off_btn.justPressed()) {
        tft.fillRect(40, 80, 160, 80, RED);

Read Registers on MCUFRIEND UNO shield
controllers either read as single 16-bit
e.g. the ID is at readReg(0)
or as a sequence of 8-bit values
in special locations (first is dummy)

reg(0x0000) 00 00  ID: ILI9320, ILI9325, ILI9335, ...
reg(0x0004) 00 54 80 66 Manufacturer ID
reg(0x0009) 00 00 61 00 00  Status Register
reg(0x000A) 00 08 Get Power Mode
reg(0x000C) 00 06 Get Pixel Format
reg(0x0061) 00 00 RDID1 HX8347-G
reg(0x0062) 00 00 RDID2 HX8347-G
reg(0x0063) 00 00 RDID3 HX8347-G
reg(0x0064) 00 00 RDID1 HX8347-A
reg(0x0065) 00 00 RDID2 HX8347-A
reg(0x0066) 00 00 RDID3 HX8347-A
reg(0x0067) 00 00 RDID Himax HX8347-A
reg(0x0070) 00 00 Panel Himax HX8347-A
reg(0x00A1) 00 93 30 93 30  RD_DDB SSD1963
reg(0x00B0) 00 00 RGB Interface Signal Control
reg(0x00B4) 00 02 Inversion Control
reg(0x00B6) 00 02 02 3B 3B  Display Control
reg(0x00B7) 00 06 Entry Mode Set
reg(0x00BF) 00 00 00 00 00 00 ILI9481, HX8357-B
reg(0x00C0) 00 0E 0E 0E 0E 0E 0E 0E 0E  Panel Control
reg(0x00C8) 00 B0 B0 B0 B0 B0 B0 B0 B0 B0 B0 B0 B0  GAMMA
reg(0x00CC) 00 03 Panel Control
reg(0x00D0) 00 00 00  Power Control
reg(0x00D2) 00 00 00 00 05  NVM Read
reg(0x00D3) 00 00 94 88 ILI9341, ILI9488
reg(0x00D4) 00 97 00 00 Novatek ID
reg(0x00DA) 00 54 RDID1
reg(0x00DB) 00 80 RDID2
reg(0x00DC) 00 66 RDID3
reg(0x00E0) 00 00 07 0C 05 13 09 36 AA 46 09 10 0D 1A 1E 0F GAMMA-P
reg(0x00E1) 00 00 20 23 04 10 06 37 56 49 04 0C 0A 33 37 0F GAMMA-N
reg(0x00EF) 00 00 00 00 00 00 ILI9327
reg(0x00F2) 00 58 04 12 02 22 22 FF 0A 90 14 88 Adjust Control 2
reg(0x00F6) 00 00 00 00 Interface Control


TouchScreen.h GFX Calibration
Making all control and bus pins INPUT_PULLUP
Typical 30k Analog pullup with corresponding pin
would read low when digital is written LOW
e.g. reads ~25 for 300R X direction
e.g. reads ~30 for 500R Y direction

Testing : (A1, D7) = 23
Testing : (A2, D6) = 34
Diagnosing as:-
XM,XP:  (A1, D7) = 23
YP,YM:  (A2, D6) = 34
ID = 0x9488

cx=904 cy=951 cz=418 LEFT, TOP, Pressure
cx=907 cy=584 cz=535 LEFT, MIDH, Pressure
cx=910 cy=229 cz=504 LEFT, BOT, Pressure
cx=554 cy=948 cz=608 MIDW, TOP, Pressure
cx=563 cy=230 cz=674 MIDW, BOT, Pressure
cx=228 cy=947 cz=946 RT, TOP, Pressure
cx=228 cy=583 cz=1038 RT, MIDH, Pressure
cx=225 cy=230 cz=929 RT, BOT, Pressure
MCUFRIEND_kbv ID=0x9488  320 x 480

const int XP=7,XM=A1,YP=A2,YM=6; //320x480 ID=0x9488
const int TS_LEFT=929,TS_RT=204,TS_TOP=963,TS_BOT=213;
x = map(p.x, LEFT=929, RT=204, 0, 320)
y = map(p.y, TOP=963, BOT=213, 0, 480)
Touch Pin Wiring XP=7 XM=A1 YP=A2 YM=6
x = map(p.y, LEFT=963, RT=213, 0, 480)
y = map(p.x, TOP=204, BOT=929, 0, 320)
  • Well, I did test the program... the screen works, nice! It draws the ON and OFF buttons and a red rectangle. Looking closer to your code, it seems that buttons ON/OFF are supposed to draw GREEN/RED rectangles respectively. I tried it out (taking off the plastic protector first) even with the plastic pen, it didn't work for some reason... – SebasSBM Jan 14 '20 at 15:36
  • ...from the Serial Monitor, I got: TFT ID = 0x9486 Calibrate for your Touch Panel – SebasSBM Jan 14 '20 at 15:39
  • ...the more I try, the more confused I get. I have been tweaking variables here and there in your script, hoping to be able to calibrate everything up. But the results I get from Serial Monitor are too weird in any experiment I try, it blows my imagination. I though I would succeed with exhaustive trial-and-error, but no... do I actually need to compile and execute TouchScreen_Calibr_native.ino to get the correct constants? – SebasSBM Jan 19 '20 at 13:25
  • I am seriously thinking on opening another question for the Touchscreen sensors issue (see EDIT3 in my question)... to give it a more focused approach... – SebasSBM Jan 19 '20 at 14:38

You sound very much the same as me when I got this screen, it took me a while, There is one of 'Dronebot's sessions on Youtube where he is connecting this screen which may get you started. I got drivers and information on lcdwiki.com with examples in the library folder. I believe you get either a Uno to Mega version of this screen as the pinout is different for each, if you have the box for the screen, under the bar code it has the item description tell you which version you have.Uno or Mega. On the lcdwiki site you'll find drivers for both under the pics of each screen and for of loads of other screens LCD OLED and TFT's. there is in the library folder when you download /install a fair few examples to have a play with and get the hang of this DRONEBOT, and LCDWIKI sites have a fair bit of info and both worth a visit. As of yet I can't get any of Adafruits examples going because of driver differences

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.