Intro
Hardware
Screen Layout
Screen Setup
Button Logic
Core Algorithm
How does compute work (with example)
Error Handling
Final Thoughts

Published December 6, 2025 © GPL3+

Arduino Touch Screen Calculator

A touch-screen calculator that works on the Arduino, great for beginners.

BeginnerFull instructions provided1 hour70

Things used in this project

Hardware components

Arduino UNO

2.4in TFT Display

Software apps and online services

Arduino IDE

Story

Intro

Calculators are everywhere, but building your own touchscreen algebraic calculator is a completely different kind of satisfaction. This project uses an Arduino-compatible TFT display with a resistive touchscreen to create a full expression calculator — including parentheses, operation precedence, negative numbers, decimals, exponentiation, and an ANS memory function.

What makes this calculator unique is the backend: instead of evaluating expressions left-to-right, this project builds a proper stack-based expression parser just like real programming languages do.

Hardware

The display for this project is resistive so touch sensing works through analog measurements of voltage rather than capacitive (like real phones or tablets).

When you press on the screen, it physically bends and the computer marks the average point of this region as the point that is detected. Pressure is estimated by sampling and averaging raw values of how much this screen bends.

Credit: MICROE Embedded Systems

Screen Layout

Top 80px: Display text region where expressions and answers appear.
Bottom area: Grid of 22, buttons, each with label and box.
Buttons include digits, operators, parentheses, ANS, equals, AC, and, CE.

Screen Setup

Download the MCUFRIEND_kbv library (link) and import it into the Arduino IDE.

Also install the Adafruit Touchscreen library from the Arduino library manager.

Go to File > Examples > MCUFRIEND_kbv > TouchScreen_Calibr_native.

Run the code and follow the instructions on the screen (see below):

Calibration Screen

After this, copy and paste the FIRST 2 LINES from the serial monitor (see below) onto the main code (replace the lines already there).

Serial Output

Button Logic

A Button struct stores:

Position (x, y), width, height
Text label
Button character (what is displayed on button)
Display character (what is printed in expression)
State flags for touch debouncing

A global array of 22 button objects defines the keypad layout.

Touch detection works like this:

read touchscreen -> check if touched -> map XY to screen coordinates

Then, for each button:

if XY inside button and wasn’t touched previously, mark pressed and update the expression (the output of on the calculator).

Note: Debouncing is solved using alreadyTouched, meaning a finger staying on a button won’t spam multiple inputs.

Core Algorithm

This is the real heart of the project.

It uses two stacks:

numbers[]    → holds floating-point values
operators[]  → holds operators: + - x / ^ ( ) and unary negative (~)

The logic is based on classic infix expression evaluation in stack calculators (this article explains this concept very well). This is also how most coding languages parse mathematics expressions.

Main Functions:

computeResult() = Parse entire expression string
precedence() = Gives priority to each operator
applyOp() = Pops values and applies an operator

How does compute work (with example)?

Let's say we have the expression 5*(22+4)

Step 1: Read 5

Token is a number -> add to buffer

Number Buffer: "5"
Number Stack: []
Operator Stack: []

Step 2: Read *

Token is an operator
Convert Number Buffer to float and push to Number Stack
Clear Number Buffer
Since Operator Stack is empty, push * to Operator Stack

Number Buffer: ""
Number Stack: [5f]
Operator Stack: ['*']

Step 3: Read (

Token is a left parenthesis
Push '(' directly to Operator Stack

Number Buffer: ""
Number Stack: [5f]
Operator Stack: ['*', '(']

Step 4: Read 2

Token is a number -> add to buffer

Number Buffer: "2"
Number Stack: [5f]
Operator Stack: ['*', '(']

Step 5: Read 2

Token is a number -> add to buffer

Number Buffer: "22"
Number Stack: [5f]
Operator Stack: ['*', '(']

Step 6: Read +

Token is an operator
Convert Number Buffer to float and push to Number Stack
Clear Number Buffer
Since top of Operator Stack is '(', push '+'

Number Buffer: ""
Number Stack: [5f, 22f]
Operator Stack: ['*', '(', '+']

Step 7: Read 4

Token is a number -> add to buffer

Number Buffer: "4"
Number Stack: [5f, 22f]
Operator Stack: ['*', '(', '+']

Step 8: Read )

Token is a right parenthesis
Convert Number Buffer to float and push to Number Stack
Clear Number Buffer
Pop operators from Operator Stack & Do Operations until '(' is found
Discard '('
Push Result of operation back to Number Stack

Number Buffer: ""
Number Stack: [5f, 26f]
Operator Stack: ['*']

Note: 22 and 4 get popped, added and 26 is pushed back so everything inside the parenthesis are evaluated first.

Step 9: End of Expression

Pop remaining operators & do remaining operations.
Push result back into Number Stack.

Number Buffer: ""
Number Stack: [130f]
Operator Stack: []

Step 10: End of Expression

Pop result from Number Stack and store in global variable answer.
Display answer with 4 decimal points of precision.

Error Handling

Code    Meaning
E1      Divide by zero
E2	Parenthesis mismatch
E3	Invalid ANS usage
E4	Invalid formatting
E0	Catch-all failure

Instead of crashing, error messages are printed directly on screen instead of answer. There are checks in the code at every step of the parsing.

Final Thoughts

This project demonstrates a genuinely sophisticated calculator system on an Arduino:

Custom touch UI
Dynamic expression entry
Full PRECEDENCE parsing
Robust stack handling and input validation
Screen text formatting

Most Arduino calculator examples evaluate left-to-right or cheat using eval() libraries. Here, we implemented an algorithm used in compilers, which is the backbone of most programming languages.

Code

Main Code

#include <MCUFRIEND_kbv.h>
#include <TouchScreen.h>

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

// Replace These Lines
const int XP = 8, XM = A2, YP = A3, YM = 9;
const int TS_LEFT = 115, TS_RT = 938, TS_TOP = 74, TS_BOT = 909;

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

int maxLength = 15;
int currentLength = 0;
char expression[24] = "\0";

// Button struct
struct Button 
{
  int x, y, w, h;        // button rectangle
  bool state;            // button state
  bool alreadyTouched;   // for toggle debounce
  const char* buttonLabel;   // label for button
  const char* displayLabel;  // label for character
};

// Define your buttons
#define NUM_BUTTONS 22
int size = 48;

Button buttons[NUM_BUTTONS] = 
{

  {  0, 224, size, size, false, false, "0", "0"},
  {  0,  80, size, size, false, false, "1", "1"},
  { 48,  80, size, size, false, false, "2", "2"},
  { 96,  80, size, size, false, false, "3", "3"},
  {  0, 128, size, size, false, false, "4", "4"},
  { 48, 128, size, size, false, false, "5", "5"},
  { 96, 128, size, size, false, false, "6", "6"},
  {  0, 176, size, size, false, false, "7", "7"},
  { 48, 176, size, size, false, false, "8","8"},
  { 96, 176, size, size, false, false, "9", "9"},

  {144, 128, size, size, false, false, "+", "+"},
  {192, 128, size, size, false, false, "-", "-"},
  {144, 176, size, size, false, false, "x", "x"},
  {192, 176, size, size, false, false, "/", "/"},
  { 48, 224, size, size, false, false, "^", "^"},
  { 96, 224, size, size, false, false, ".", "."},
  {144, 224, size, size, false, false, "(", "("},
  {192, 224, size, size, false, false, ")", ")"},
  {0, 272, size*2, size, false, false, "ANS", "A"},

  
  {96, 272, size*3, size, false, false, "=", "="},
  {144, 80, size, size, false, false, "AC", "AC"},
  {192, 80, size, size, false, false, "CE", "CE"},
};

// Define Stack
template <typename T, int SIZE>
class Stack 
{
  private:
    T data[SIZE];
    int topIndex = -1;

  public:
    bool push(T value) 
    {
      if (topIndex >= SIZE - 1) return false;
      data[++topIndex] = value;
      return true;
    }

    T pop() 
    {
      return data[topIndex--];
    }

    T peek() 
    {
      return data[topIndex];
    }

    bool isEmpty() 
    {
      return topIndex < 0;
    }

    bool isFull() 
    {
      return topIndex >= SIZE - 1;
    }
};

Stack<float, 64> numbers;
Stack<char, 64> operators;

// Text Display Region
int displayX = 0;
int displayY = 0;
int displayW = 240;
int displayH = 80;

float answer = 1.0f;

// 0 - Error, 1 - Divide By Zero, 2 - Check (), 3 - Invalid Use ANS, 4 - Invalid Format
int errorCode = 0;

int averagePressure(TouchScreen &ts, int samples);
int precedence(char op);
bool applyOp();
bool computeResult(char* expression);
void drawButton(const Button &b);
void updateButtons();
void drawText(const Button &b, int buttonNumber);

void setup() 
{
  Serial.begin(9600);
  tft.begin();
  tft.fillScreen(BLACK);
  tft.setRotation(0);

  for (int i = 0; i < NUM_BUTTONS; i++) 
  {
    drawButton(buttons[i]);
  }
}

void loop() 
{
  updateButtons(7);
  delay(33);
}

void updateButtons(int padding) 
{
  TSPoint p = ts.getPoint();
  int z = averagePressure(ts, 20);

  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);

  bool pressed = z > ts.pressureThreshhold;

  int x = -1, y = -1;

  if (pressed) 
  {
    x = map(p.x, TS_LEFT, TS_RT, 0, tft.width());
    y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
  }

  for (int i = 0; i < NUM_BUTTONS; i++) 
  {
    Button &b = buttons[i];
    bool isInside = pressed && x >= (b.x + padding) && x <= (b.x + b.w - padding) && (y >= b.y + padding) && y <= (b.y + b.h - padding);

    if (isInside && !b.alreadyTouched) 
    {
      b.state = !b.state;
      b.alreadyTouched = true;
      drawButton(b);
      drawText(b, i);
    } 
    else if (!isInside) 
    {
      b.alreadyTouched = false;
    }
  }
}

void drawText(const Button &b, int buttonNumber)
{
  if (buttonNumber >= 0 && buttonNumber <= 18)
  {
    if (currentLength < maxLength-1)
    {
      strcat(expression, b.displayLabel);
      currentLength++;
    }
  }

  // = : compute and display answer
  else if (buttonNumber == 19)
  {
    if (computeResult(expression)) 
    {
      dtostrf(answer, -6, 4, expression);
      currentLength = strlen(expression);
    }
    else 
    {
      if (errorCode == 1) strcpy(expression, "E1: DIVIDE BY 0");
      else if (errorCode == 2) strcpy(expression, "E2: CHECK ()");
      else if (errorCode == 3) strcpy(expression, "E3: Invalid ANS");
      else if (errorCode == 4) strcpy(expression, "E4: Invalid FORMAT");
      else strcpy(expression, "E0: UNKNOWN ERROR");

      currentLength = 1;
    }

  }

  // AC : clear everything
  else if (buttonNumber == 20)
  {
    expression[0] = '\0';
    currentLength = 0;
  }

  // CE : remove last character
  else if (buttonNumber == 21)
  {
    if (currentLength > 0)
    {
      expression[currentLength - 1] = '\0';
      currentLength--;
    }
  }

  //Display Text
  tft.fillRect(displayX, displayY, displayW, displayH, BLACK);

  tft.setTextSize(2);

  int16_t x1, y1;
  uint16_t w, h;
  tft.getTextBounds(expression, 0, 0, &x1, &y1, &w, &h);

  int cursorX = displayW - w - 10;
  if (cursorX < 5) cursorX = 5;

  int cursorY = displayY + (displayH - h) / 2;

  tft.setCursor(cursorX, cursorY);
  tft.print(expression);
  
  tft.setTextColor(WHITE);
}


void drawButton(const Button &b) 
{
  tft.fillRect(b.x, b.y, b.w, b.h, RED);
  tft.drawRect(b.x, b.y, b.w, b.h, BLACK);

  tft.setTextSize(2);
  tft.setTextColor(0xFFFF);

  const char* txt = b.buttonLabel;

  int16_t x1, y1;
  uint16_t w, h;
  tft.getTextBounds(txt, 0, 0, &x1, &y1, &w, &h);

  int textX = b.x + (b.w - w) / 2;
  int textY = b.y + (b.h - h) / 2;

  tft.setCursor(textX, textY);
  tft.print(txt);
}

int averagePressure(TouchScreen &ts, int samples) 
{
  long sum = 0;

  for (int i = 0; i < samples; i++) 
  {
    TSPoint p = ts.getPoint();
    sum += p.z;
    delay(1);
  }

  return (int) sum / samples;
}

bool computeResult(char* expression)
{
  while (!numbers.isEmpty()) numbers.pop();
  while (!operators.isEmpty()) operators.pop();

  int i = 0;
  char current;
  char numBuf[24] = "";
  int numIndex = 0;

  bool lastWasNum = false;
  bool lastWasANS = false;
  bool lastWasOp = false;
  
  Serial.println("Start");

  while ((current = expression[i]) != '\0')
  {
    // Check for ANS or A
    if (current == 'A')
    {
      // Return error
      if (lastWasNum) 
      {
        errorCode = 3;
        return false;
      }

      numbers.push(answer);
      lastWasANS = true;
      lastWasNum = false;
      lastWasOp = false;
    }

    // Check Number
    else if ((current >= '0' && current <= '9') || current == '.')
    {
      //Return error
      if (lastWasANS) 
      {
        errorCode = 3;
        return false;
      }

      numBuf[numIndex++] = current;
      lastWasNum = true;
      lastWasANS = false;
      lastWasOp = false;
    }

    // Check (
    else if (current == '(')
    {
      operators.push('(');
      lastWasNum = false;
      lastWasANS = false;
      lastWasOp = true;
    }

    // Check )
    else if (current == ')')
    {
      // Push any buffered number
      if (lastWasNum)
      {
        numBuf[numIndex] = '\0';
        numbers.push(atof(numBuf));
        Serial.println(numbers.peek());
        numBuf[0] = '\0';
        numIndex = 0;
        lastWasNum = false;
      }

      // Apply operations until '('
      while (!operators.isEmpty() && operators.peek() != '(')
      {
        if (!applyOp()) 
        {
          return false;
        }
      }

      if (operators.isEmpty()) 
      {
        errorCode = 2;
        return false;
      }

      operators.pop(); // remove '('
      
      lastWasNum = false;
      lastWasANS = false;
      lastWasOp = true;
    }

    // Operator
    else
    {
      char op = current;

      if (op == '-' && (i == 0 || lastWasOp || expression[i-1] == '('))
      {
        op = '~';
        
        if (lastWasNum)
        {
          numBuf[numIndex] = '\0';
          numbers.push(atof(numBuf));
          numBuf[0] = '\0';
          numIndex = 0;
        }

        operators.push('~');

        lastWasOp = true;
        lastWasNum = false;
        lastWasANS = false;

        i++; 
        continue;
      }

      
      if (lastWasNum)
      {
        numBuf[numIndex] = '\0';
        numbers.push(atof(numBuf));
        Serial.println(numbers.peek());
        numBuf[0] = '\0';
        numIndex = 0;
        lastWasNum = false;
      }

      while (!operators.isEmpty() && precedence(operators.peek()) >= precedence(op))
      {
        if (!applyOp()) 
        {
          return false;
        }
      }

      operators.push(op);

      lastWasNum = false;
      lastWasANS = false;
      lastWasOp = true;
    }

    i++;
  }

  Serial.println("End");

  // Push Final Number
  if (lastWasNum)
  {
    numBuf[numIndex] = '\0';
    numbers.push(atof(numBuf)); 
  }

  // Apply Any Operators Left
  while (!operators.isEmpty())
  {
    if (!applyOp()) 
    {
      return false;
    }
  }

  if (numbers.isEmpty()) 
  {
    errorCode = 0;
    return false;
  }

  answer = numbers.pop();

  return true;
}

int precedence(char op)
{
  if (op == '~') return 4;           
  if (op == '^') return 3;
  if (op == 'x' || op == '/') return 2;
  if (op == '+' || op == '-') return 1;
  return 0;
}

bool applyOp()
{
  if (operators.isEmpty()) return false;

  char op = operators.pop();

  if (op == '~')
  {
    if (numbers.isEmpty()) return false;
    float a = numbers.pop();
    numbers.push(-a);
    return true;
  }

  if (numbers.isEmpty()) return false;
  float b = numbers.pop();

  if (numbers.isEmpty()) return false;
  float a = numbers.pop();

  float r = 0.0;

  switch (op)
  {
    case '+': r = a + b; break;
    case '-': r = a - b; break;
    case 'x': r = a * b; break;
    case '/': 
      if (b == 0) 
      {
        errorCode = 1; 
        return false;
      }
      r = a / b; 
      break;
    case '^': r = pow(a, b); break;
    default: 
      errorCode = 4;
      return false;
  }

  numbers.push(r);
  return true;
}

Credits

Uniostar

11 projects • 8 followers

Electrical Engineering Undergrad Student specialized in low-level programming, IoT projects, and microcontroller electronics.

Arduino Touch Screen Calculator

Things used in this project

Hardware components

Software apps and online services

Story

Intro

Hardware

Screen Layout

Screen Setup

Button Logic

Core Algorithm

How does compute work (with example)?

Error Handling

Final Thoughts

Schematics

Top View

Side View

Code

Main Code

Credits

Uniostar

Comments

Embed the widget on your own site

Arduino Touch Screen Calculator

Arduino Touch Screen Calculator

Things used in this project

Hardware components

Software apps and online services

Story

Intro

Hardware

Screen Layout

Screen Setup

Button Logic

Core Algorithm

How does compute work (with example)?

Error Handling

Final Thoughts

Schematics

Top View

Side View

Code

Main Code

Credits

Uniostar

Comments

Related channels and tags