In this chapter, we’ll explore the most commonly used **arithmetic operators in Arduino programming**: **addition**, **subtraction**, **multiplication**, **division**, **modulus**, **increment**, and **decrement**. These Arduino Arithmetic Operators are essential for performing mathematical operations and manipulating values within your Arduino code. We’ll also provide examples to help you understand how each operator works and its potential pitfalls.

**Syntax Table: Key Arduino Arithmetic Operators**

Operator |
Syntax |
Simple Example |

Addition (+) | result = operand1 + operand2; |
int sum = 10 + 5; |

Subtraction (-) | result = operand1 – operand2; |
int difference = 15 – 5; |

Multiplication (*) | result = operand1 * operand2; |
int product = 6 * 7; |

Division (/) | result = operand1 / operand2; |
int quotient = 20 / 4; |

Modulus (%) | result = operand1 % operand2; |
int remainder = 10 % 3; |

Increment (++) | variable++; or ++variable; |
int counter = 0; counter++; |

Decrement (–) | variable–; or –variable; |
int counter = 10; counter–; |

**Addition Operator in Arduino**

The addition operator (+) in Arduino is used to add two numbers or variables. It is one of the basic arithmetic operators in Arduino programming and works with integers, floating-point numbers, and even String objects for concatenation.

**Use purpose****
**The addition operator is used for:

**Mathematical operations**: Adding numerical values or variables.**Updating variables**: Increasing the value of a variable by a certain amount.**String concatenation**: Combining two String objects into one.

**Arduino Syntax use**

*result = operand1 + operand2;*

Where:

*result*: The variable that stores the result of the addition.*operand1*: The first number or variable to be added.*operand2*: The second number or variable to be added.

**Arduino Syntax Explanation**

*result*: Stores the result of the addition.*operand1*and*operand2*: These can be numbers, variables, or expressions that are added together. Both integers and floating-point numbers are supported.- The + operator adds the two operands and assigns the result to the variable on the left-hand side.

**Arduino code Example**

```
int num1 = 10;
int num2 = 5;
int sum;
void setup() {
Serial.begin(9600);
sum = num1 + num2; // Add num1 and num2
Serial.print("The sum is: ");
Serial.println(sum); // Output the result
}
void loop() {
// Nothing needed here
}
```

Code Explanation

- In this example, the integers
*num1*and*num2*are added using the addition operator (+), and the result is stored in the variable*sum*. - The result is then printed to the serial monitor, displaying “The sum is: 15.”

**Notes**

- The addition operator can be used with different data types, such as int, float, and String.
- In Arduino, adding String objects with the + operator will concatenate (combine) them into a single string.

**Warnings**

- Be cautious of overflow when adding large numbers, especially when using data types like byte or int. For example, adding two numbers that exceed the range of int (32,767) can cause overflow and lead to incorrect results.
- When adding float numbers, the result might not be exact due to the limitations of floating-point precision.

**Subtraction Operator in Arduino**

The subtraction operator (–) in Arduino is used to subtract one number from another. It is one of the basic arithmetic operators and works with integers, floating-point numbers, and even variables.

**Use purpose****
**The subtraction operator is used for:

**Mathematical operations**: Subtracting one value from another.**Updating variables**: Decreasing the value of a variable by a specific amount.**Calculating differences**: Determining the difference between two numbers or measurements.

**Arduino Syntax use**

*result = operand1 – operand2;*

Where:

*result*: The variable that stores the result of the subtraction.*operand1*: The number or variable from which the second operand is subtracted.*operand2*: The number or variable to be subtracted.

**Arduino Syntax Explanation**

*result*: Stores the result of the subtraction.*operand1*: The first value, from which the second value is subtracted.*operand2*: The second value, which is subtracted from the first.

**Arduino code Example**

```
int num1 = 15;
int num2 = 5;
int difference;
void setup() {
Serial.begin(9600);
difference = num1 - num2; // Subtract num2 from num1
Serial.print("The difference is: ");
Serial.println(difference); // Output the result
}
void loop() {
// Nothing needed here
}
```

**Code Explanation**

- The integers
*num1*and*num2*are subtracted using the subtraction operator (–), and the result is stored in the variable*difference*. - The result is then printed to the serial monitor, displaying “The difference is: 10.”

**Notes**

- The subtraction operator can be used with different data types, such as int and float.
- Subtraction can also be used to reduce the value of a variable, for example: counter = counter – 1; or counter–; for shorthand.

**Warnings**

- When subtracting unsigned data types like unsigned int or byte, be cautious of underflow (when the result is negative). In such cases, the result will “wrap around” and give an unexpected value.
- Be aware of precision issues when subtracting floating-point numbers (float), as small differences may not always be represented accurately due to floating-point limitations.

**Multiplication Operator in Arduino**

The multiplication operator (*) in Arduino is used to multiply two numbers or variables. It is a basic arithmetic operator that works with integers, floating-point numbers, and other numeric types.

**Use purpose****
**The multiplication operator is used for:

**Mathematical operations**: Calculating the product of two numbers.**Scaling values**: Multiplying sensor values or other readings by a scaling factor.**Adjusting variables**: Changing a variable’s value by multiplying it with another number.

**Arduino Syntax use**

*result = operand1 * operand2;*

Where:

*result*: The variable that stores the result of the multiplication.*operand1*: The first number or variable to be multiplied.*operand2*: The second number or variable to be multiplied.

**Arduino Syntax Explanation**

*result*: Stores the result of multiplying operand1 and operand2.*operand1*and*operand2*: These can be numbers, variables, or expressions to be multiplied together.

**Arduino code Example**

```
int num1 = 6;
int num2 = 7;
int product;
void setup() {
Serial.begin(9600);
product = num1 * num2; // Multiply num1 and num2
Serial.print("The product is: ");
Serial.println(product); // Output the result
}
void loop() {
// Nothing needed here
}
```

**Code Explanation**

- The integers
*num1*and*num2*are multiplied using the multiplication operator (*), and the result is stored in the variable*product*. - The result is then printed to the serial monitor, displaying “The product is: 42.”

**Notes**

- The multiplication operator works with different data types, such as int, float, and long.
- Be careful when multiplying large numbers with small data types like byte or int, as overflow can occur if the result exceeds the range of the data type.

**Warnings**

- When multiplying large numbers with smaller data types like int or byte, ensure that the result doesn’t exceed the maximum value of the data type to avoid overflow.
- When using float for multiplication, be aware of possible precision limitations, as floating-point arithmetic can sometimes lead to small errors due to the way numbers are stored.

**Division Operator in Arduino**

The division operator (/) in Arduino is used to divide one number by another. It performs standard division for both integer and floating-point numbers, allowing you to compute quotients. When dividing integers, any remainder is discarded (integer division), while dividing floating-point numbers provides more precise results.

**Use purpose****
**The division operator is used for:

**Mathematical operations**: Calculating the quotient of two numbers.**Scaling down values**: Dividing sensor readings or other data by a factor.**Converting units**: Often used to convert measurements or normalize values.

**Arduino Syntax use**

*result = operand1 / operand2;*

Where:

*result*: The variable that stores the result of the division.*operand1*: The number to be divided (the numerator).*operand2*: The number by which the first is divided (the denominator).

**Arduino Syntax Explanation**

*result*: Stores the result of the division.*operand1*: The number being divided (numerator).*operand2*: The number that divides the first (denominator). Ensure this value is not zero, as division by zero is undefined and will cause errors.

**Arduino code Example**

```
int num1 = 20;
int num2 = 4;
int quotient;
void setup() {
Serial.begin(9600);
quotient = num1 / num2; // Divide num1 by num2
Serial.print("The quotient is: ");
Serial.println(quotient); // Output the result
}
void loop() {
// Nothing needed here
}
```

**Code Explanation**

- The integers
*num1*and*num2*are divided using the division operator (/), and the result is stored in the variable*quotient*. - The result is printed to the serial monitor, displaying “The quotient is: 5.”

**Notes**

**Integer Division**: When dividing two integers, the result is also an integer, and any remainder is discarded. For example, 7 / 2 will return 3, not 3.5.**Floating-Point Division**: When dividing two float values, the result includes the fractional part. For example, 7.0 / 2.0 returns 3.5.

**Warnings**

**Division by zero**: Ensure that the denominator (operand2) is not zero, as this will cause an error or undefined behavior.**Integer division**: Be cautious when dividing integers, as the result discards the decimal part. If you need more precise results, use float or double data types for the operands.

**Modulus Operator in Arduino**

The modulus operator (%) in Arduino is used to find the remainder after dividing one number by another. This operator works with integer values and is commonly used in tasks where you need to check divisibility, handle cyclic behavior, or extract parts of numbers.

**Use purpose****
**The modulus operator is used for:

**Finding remainders**: When you want to know the remainder after division.**Checking divisibility**: For example, checking if a number is even or odd.**Creating loops with cycles**: Useful for repeating actions after a certain count or for cyclic behavior in animations, timers, or counters.

**Arduino Syntax use**

*result = operand1 % operand2;*

Where:

*result*: The variable that stores the remainder.*operand1*: The number to be divided (the numerator).*operand2*: The number by which the first is divided (the denominator).

**Arduino Syntax Explanation**

*result*: Stores the remainder after dividing operand1 by operand2.*operand1*: The number being divided.*operand2*: The divisor. It must be a non-zero integer, as dividing by zero will cause an error.

**Arduino code Example**

```
int num1 = 10;
int num2 = 3;
int remainder;
void setup() {
Serial.begin(9600);
remainder = num1 % num2; // Find the remainder of num1 divided by num2
Serial.print("The remainder is: ");
Serial.println(remainder); // Output the result
}
void loop() {
// Nothing needed here
}
```

**Code Explanation**

- The integers
*num1*and*num2*are divided, and the remainder of this division is calculated using the modulus operator (%). The result is stored in*remainder*. - The result is printed to the serial monitor, showing “The remainder is: 1” because 10 % 3 equals 1.

**Notes**

- The modulus operator works only with integer values in Arduino. It does not work with floating-point numbers.
- A common use of the modulus operator is to determine if a number is even or odd. For example, if (num % 2 == 0) checks if a number is even.

**Warnings**

**Division by zero**: Just like with the division operator, make sure the denominator (operand2) is not zero, as it will cause an error.**Integer operands only**: The modulus operator only works with integers. If you need to use it with floating-point numbers, you’ll need to cast or handle the numbers differently.

**Increment Operator in Arduino**

The increment operator (++) in Arduino is used to increase the value of a variable by 1. It is a shorthand for adding one to a variable, making your code more concise and easier to read. The increment operator can be used in two forms: **prefix** (++variable) and **postfix** (variable++).

**Use purpose****
**The increment operator is used for:

**Counting**: Increasing a counter in loops or functions.**Loop iterations**: Often used to control how many times a loop should execute.**Shorthand notation**: Instead of writing variable = variable + 1;, you can use variable++.

**Arduino Syntax use**

*variable++;*

*++variable;*

Where:

*variable++*: The variable is incremented after its value is used (postfix).*++variable*: The variable is incremented before its value is used (prefix).

**Arduino Syntax Explanation**

*variable++*(Postfix): The variable is incremented by 1, but the original value is used in the current statement before the increment takes effect.*++variable*(Prefix): The variable is incremented by 1, and the incremented value is used in the current statement.

**Arduino code Example**

```
int counter = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
counter++; // Increment counter by 1
Serial.print("The counter is: ");
Serial.println(counter); // Output the counter value
delay(1000); // Wait for 1 second
}
```

**Code Explanation**

- The variable
*counter*starts at 0 and is incremented by 1 using the increment operator (++). - The incremented value is printed to the serial monitor every second, showing the increasing counter value.

**Notes**

- The increment operator works with integers and other numeric data types.
- The prefix (++variable) and postfix (variable++) forms behave differently in complex expressions, but in simple usage like loops, they are essentially the same.

**Warnings**

- The increment operator should only be used with variables that can be incremented, such as integers, floats, or other numeric types.
- Using the increment operator on variables that have reached their maximum value (for example, an unsigned int close to 65,535) may result in overflow, which could cause unexpected behavior.

**Decrement Operator in Arduino**

The decrement operator (—) in Arduino is used to decrease the value of a variable by 1. It is a shorthand for subtracting one from a variable, which simplifies your code. The decrement operator can be used in two forms: **prefix** (–variable) and **postfix** (variable–).

**Use purpose****
**The decrement operator is used for:

**Counting down**: Reducing the value of a counter in loops or functions.**Loop control**: Often used to control loops that need to decrease in value.**Shorthand notation**: Instead of writing variable = variable – 1;, you can use variable– to decrease the value of a variable by 1.

**Arduino Syntax use**

*variable–*

*–variable*

Where:

*variable–*: The variable is decremented after its value is used (postfix).*–variable*: The variable is decremented before its value is used (prefix).

**Arduino Syntax Explanation**

*variable–*(Postfix): The variable is decremented by 1, but the original value is used in the current statement before the decrement takes effect.*–variable*(Prefix): The variable is decremented by 1, and the decremented value is used in the current statement.

**Arduino code Example**

```
int counter = 10;
void setup() {
Serial.begin(9600);
}
void loop() {
counter--; // Decrement counter by 1
Serial.print("The counter is: ");
Serial.println(counter); // Output the counter value
delay(1000); // Wait for 1 second
}
```

**Code Explanation**

- The variable
*counter*starts at 10 and is decremented by 1 using the decrement operator (—). - The decremented value is printed to the serial monitor every second, showing the decreasing counter value.

**Notes**

- The decrement operator works with integers and other numeric data types.
- Both prefix (–variable) and postfix (variable–) forms exist, but in simple usage like counting down in loops, their behavior is similar.

**Warnings**

- The decrement operator should only be used with variables that can be decremented, such as integers, floats, or other numeric types.

If you continue decrementing a variable that reaches its minimum value (for example, a byte at 0), you may experience underflow, which can result in unexpected behavior.

### Common Problems and Solutions

**Integer Division**

**Problem**: When dividing two integers, the result is also an integer, and any remainder is discarded.

**Solution**: Use*float*for more precise division results.

Example:

*int result = 7 / 2;*→*float result = 7.0 / 2.0;***Overflow and Underflow**

**Problem**: Adding or multiplying large numbers can exceed the storage capacity of the data type, leading to overflow or underflow.

**Solution**: Use larger data types like*long*or*unsigned long*when handling big numbers.

Example:

*int largeSum = 32767 + 1;*→*long largeSum = 32767 + 1;***Division by Zero**

**Problem**: Dividing by zero is undefined and will cause errors in your program.

**Solution**: Always check that the denominator is not zero before performing division.

Example:

*if (operand2 != 0) { quotient = operand1 / operand2; }*

### Chapter Summary

**Addition**(+) adds two values and is commonly used for updating variables or string concatenation.**Subtraction**(-) subtracts one value from another and is often used to calculate differences.**Multiplication**(*) calculates the product of two numbers and is useful for scaling values.**Division**(/) divides one number by another and may require*float*for accurate results with decimal places.**Modulus**(%) returns the remainder after division and is handy for checking divisibility.**Increment**(++) increases a variable’s value by 1, while**decrement**(–) decreases it by 1.

### FAQ

**What is the modulus operator used for in Arduino?**

The modulus operator (%) returns the remainder after division, which is useful for checking if a number is even or odd or for cyclic tasks.**What is the difference between integer division and floating-point division in Arduino?**

Integer division discards the remainder, while floating-point division provides precise results with decimals. Use*float*for more accurate calculations.**Can I use the addition operator with Strings in Arduino?**

Yes, the addition operator (+) can concatenate two String objects, combining them into a single string.

### Simple MCQ Questions and Answers

**What is the result of 15 / 2 in Arduino (using int data type)?**

a) 7.5

b) 8

c) 7

d) 6

**Answer**: c) 7**Which operator is used to find the remainder after division?**

a) /

b) %

c) ++

d) *

**Answer**: b) %**What will happen if you divide a number by zero in Arduino?**

a) The program will continue normally.

b) The result will be zero.

c) It will cause an error or undefined behavior.

d) The result will be infinity.

**Answer**: c) It will cause an error or undefined behavior.