Arduino Data Types: A Comprehensive Guide

Arduino data types play a critical role in programming an Arduino. Without Arduino data types, you can't know the number of memory bites allocated to a variable and the kind of data stored in the variable.

In addition, since the Arduino computer accepts data in whatever manner you feed it, you need to understand data types for effective project performance.

In this post, you will learn about the various Arduino data types with examples, so you can know exactly where to use any of them.

Read on to learn more.  

What are Data types in Arduino?

Arduino

A data type is a categorization that allows the identification of variables and functions.

In essence, a data type shows you the value (storage space) of a variable or a function and the operations you can run on either.  

Arduino Data Types: Round Numbers

Round numbers fall into three categories. Namely

• byte
• Int
• long

Let us have a closer look at each.  

byte

The byte is the least round number Arduino data type you can use when programming an Arduino. One byte constitutes 8 bits (unsigned data types).

A byte's lowest value is 0, and the highest is 255, which is relatively small. Hence you should pay a lot of attention when using it and only employ discounts of no more than 255.

When you store a value of more than 255, you will initiate a variable overflow. Meaning that after the value hits 255, it will revert to 0.

Consequently, your system will compile, but you will realize plenty of application errors when you run it.  

Example code

Int

Also known as Integers, int is the primary data type for storing numbers, as they are the most commonly used.

Int sizes vary depending on the type of Arduino board. For instance, Nano, Mega, or Arduino Uno boards utilize a 2-byte (16bit) int storage ranging between -32768 to +32767.

On the other hand, Due and SAMD based Arduino boards utilize a 4-byte (32bit) int memory ranging from -2147483648 to +2147483647.  

Example code

long

Long variables are size variables that utilize 32bit (4byte) memory ranging between – 2147483 648 and +2147483647.  

Example code

Arduino data types: Unsigned

They include

• The unsigned int
• unsigned long

unsigned int

The Unsigned int is similar to the int in that they also utilize 2-byte storage.

However, unlike the int, the unsigned int does not store negative numbers. They only store positive digits ranging between 0 and +65 535.

Likewise, to int, the size of the unsigned int depends on the type of Arduino board. AT mega Arduino boards such as Uno and Nano utilize 16-bit (2byte) memory.

SAMD and DMD Arduino boards use 32bit (4-byte) memory ranging between 0 and 4294967295.

Here, the earlier stated overflow rule applies; you should thus use only positive values in the variable.  

Example code

unsigned long

Unsigned long shares similar characteristics with the Long variable; the only difference is they do not store negative numbers.

They use 32-bit (4-byte) storage ranging between 0 and +4294967295  

Example code

Arduino data types: Bool/Boolean

A Boolean or bool constitutes binary information, true or false (1 or 0). In addition, a bool uses an 8bit (1byte) memory.

You can use a Boolean variable in applications that provide Yes or No answers. In some cases, you can use the regular C++ bool; however, experts recommend using bool.  

Example code

Arduino data types: Float Numbers

float

A floating-point number is a figure that constitutes a decimal point. The ability to store decimal figures puts the float data type among the principle Arduino data types.

You can use floating-point numbers when approximating analog and continuous values since they provide better resolution than integers.

Even so, it is worth noting that a float does not provide 100% precision. For instance, when you try to place 3.00 in a float number, you may get 3.0000001 as the actual value.  

Example code

double

The double data type occupies a 32-bit (4byte) in Uno and Nano boards. You can also call it the double-precision floating-point number; dual implementation is similar to the float but with no precision gain.

Nevertheless, SAMD and DUE-based Arduino boards have double the bit and byte amount at 64bit and (8byte).

The extra space allows you to store more significant numbers.  

Example code

Arduino data types: Text Data types

You have looked at the various ways you can store numbers, now let us look at how you can store text.

Keeping text is essential; as you can easily share it with people (people understand text easier compared to numbers)

The text data types include

• char
• unsigned char
• String

char

Char consumes one byte of memory and stores the value of a character (A, B, C).

You can write Multiple character literals using single quotes ;('A'), whereas strings use double quotations; ("ABC").

Since char saves characters as numbers, you will need an ASCII chart to find their values. For instance, the value of 'A’+1 is 66 since, in ASCII, the letter A equals 65.

Also, note that the char data type is ideal for transferring information due to its small storage consumption and easier comprehension.  

Example code

unsigned char

The unsigned char data type occupies 8bit/ 1byte memory and shares likewise characteristics with the byte data type.

One such similarity is that they can encode numbers between 0 and 255.

Nevertheless, experts recommend using byte rather than Unsigned char when programming your Arduino for consistency.  

Example code

String

The String is not essentially an Arduino data type but a class. Also, note that the variable is String with a capital 'S' and not a small case 's.'

Moreover, you can only find the string data type in Arduino and not in a standard C/C++, and to make a String, you will need plenty of chars.  

Example code

Array of variables

As shown below, you can store all of the above-stated Arduino data types in an array.  

Remember only to use one data type in an array.  

Which Data Type do you Choose to use When Programming Your Arduino?

When programming, the data type you employ doesn't affect much. However, you must pick the best data type when dealing with speed and size.

Hence, it would be best always to employ the most minute data type that can comprehensively accommodate the figure you want to store.

For example, when you seek to store a pin figure, and the board you are using has less than 128 pins, then utilizing a char or byte type would be best suited.

Whereas your board has over 128 pins but no more than 255 pins, you can utilize the unsigned data type.

Simply put, smaller data types are the best to work with when programming your Arduino. They provide faster speeds and need fewer memory leads.  

Conclusion

This post has learned about the most commonly used Arduino data types in programming.

To conclude, here are a few tips;

• To avoid faulty results, always make sure you know the minimum and maximum values a variable can handle.

• When working with round numbers, utilize the unsigned data type version for a more precise and less complex project.

• Avoid premature optimization in your program. It would help if you only optimized when things move slower than expected.