Arduino programming uses several data types derived from C/C++ to store various types of information. Understanding these data types is essential for efficient and effective coding. Here’s an overview of the common data types available in Arduino:

Basic Data Types

1. void

   • Represents the absence of type. It is used for functions that do not return a value.

   cpp
   void setup() {
       // No return value
     }
     

2. boolean

   • Represents a boolean value (true or false).
   • Size: 1 byte.

   cpp
   boolean flag = true;
     

3. char

   • Represents a single character.
   • Size: 1 byte.
   • Range: -128 to 127 or 0 to 255.

   cpp
   char letter = 'A';
     

4. byte

   • Represents an 8-bit unsigned number.
   • Size: 1 byte.
   • Range: 0 to 255.

   cpp
   byte count = 255;
     

5. int

   • Represents a 16-bit signed integer.
   • Size: 2 bytes.
   • Range: -32,768 to 32,767.

   cpp
   int number = 12345;
     

6. unsigned int

   • Represents a 16-bit unsigned integer.
   • Size: 2 bytes.
   • Range: 0 to 65,535.

   cpp
   unsigned int positiveNumber = 60000;
     

7. word

   • Represents a 16-bit unsigned number (alias for unsigned int).
   • Size: 2 bytes.
   • Range: 0 to 65,535.

   cpp
   word value = 1000;
     

8. long

   • Represents a 32-bit signed integer.
   • Size: 4 bytes.
   • Range: -2,147,483,648 to 2,147,483,647.

   cpp
   long bigNumber = 1234567890;
     

9. unsigned long

   • Represents a 32-bit unsigned integer.
   • Size: 4 bytes.
   • Range: 0 to 4,294,967,295.

   cpp
   unsigned long bigPositiveNumber = 3000000000;
     

10. short

    • Represents a 16-bit signed integer.
    • Size: 2 bytes.
    • Range: -32,768 to 32,767.

    cpp
    short smallNumber = 32000;
      

11. float

    • Represents a floating-point number.
    • Size: 4 bytes.
    • Range: 3.4028235E+38 to -3.4028235E+38.
    • Precision: Up to 6-7 decimal places.

    cpp
    float pi = 3.14159;
      

12. double

    • On most Arduino boards, double is the same as float (4 bytes). On some platforms like the Arduino Due, double is 8 bytes.

    cpp
    double largeDecimal = 2.71828;
      

Derived Data Types

1. String (object)

   • Represents a sequence of characters.

   cpp
   String text = "Hello, World!";
     

2. Array

   • Represents a collection of variables of the same type.

   cpp
   int numbers[] = {1, 2, 3, 4, 5};
     

3. Pointer

   • Represents a variable that stores the memory address of another variable.

   cpp
   int value = 42;
     int *ptr = &value; // Pointer to the integer value
     

Example Sketch

Here is an example sketch that uses various data types:

cpp
// Basic data types
  boolean ledState = true;
  char myChar = 'A';
  byte myByte = 255;
  int myInt = -32000;
  unsigned int myUnsignedInt = 60000;
  word myWord = 1000;
  long myLong = 1234567890;
  unsigned long myUnsignedLong = 3000000000;
  short myShort = 32000;
  float myFloat = 3.14159;
  double myDouble = 2.71828;
  
  // String object
  String myString = "Hello, Arduino!";
  
  // Array
  int myArray[5] = {1, 2, 3, 4, 5};
  
  // Pointer
  int myValue = 42;
  int *myPointer = &myValue;
  
  void setup() {
    // Initialize serial communication
    Serial.begin(9600);
  
    // Print values of various data types
    Serial.println(ledState);
    Serial.println(myChar);
    Serial.println(myByte);
    Serial.println(myInt);
    Serial.println(myUnsignedInt);
    Serial.println(myWord);
    Serial.println(myLong);
    Serial.println(myUnsignedLong);
    Serial.println(myShort);
    Serial.println(myFloat);
    Serial.println(myDouble);
    Serial.println(myString);
  
    // Print array elements
    for (int i = 0; i < 5; i++) {
      Serial.println(myArray[i]);
    }
  
    // Print pointer value
    Serial.println(*myPointer);
  }
  
  void loop() {
    // Nothing to do here
  }
  

Tips for Using Data Types

1. Choose the Appropriate Type: Use the smallest data type that fits your needs to save memory.
2. Be Aware of Limits: Understand the range and limits of each data type to avoid overflow and underflow.
3. Use Constants: Use the const keyword to declare variables that should not change, enhancing code safety and readability.
4. Floating Point Precision: Be cautious with floating-point arithmetic due to precision limitations.

Understanding and using the appropriate data types is crucial for writing efficient and effective Arduino programs. This guide covers the basics, but as you dive deeper, you'll encounter more complex uses and manipulations of these types.