Lesson 3: Variables & Data Types

What Are Data Types?

Data types tell the Arduino what kind of information you're storing and how much memory to use. Choosing the right data type is important for efficient programming and avoiding errors.

Common Arduino Data Types

Data Type Examples

// Integer examples
int temperature = 25;           // Room temperature
byte ledBrightness = 128;       // LED brightness (0-255)
long milliseconds = 1234567;    // Large time value
unsigned int sensorReading = 1023;  // Sensor value (always positive)

// Decimal examples
float voltage = 3.3;            // Precise voltage reading
float pi = 3.14159;             // Mathematical constant

// Boolean examples
bool ledState = true;           // LED is on
bool buttonPressed = false;     // Button is not pressed

// Character and String examples
char grade = 'A';               // Single letter grade
String robotName = "miniAuto";  // Robot's name
String message = "Hello, World!";  // Text message

// Special Arduino types
unsigned long currentTime = millis();  // Time since startup

Variable Declaration and Initialization

Variables are containers that store data values. You need to declare them before use and can initialize them with starting values.

// Basic syntax: dataType variableName = initialValue;

// Declaration only (value is undefined)
int counter;
float temperature;
bool isRunning;

// Declaration with initialization (recommended)
int ledPin = 13;                    // Pin number for LED
float sensorVoltage = 0.0;          // Starting voltage
bool systemReady = false;           // System status
String deviceName = "Arduino";      // Device identifier

// Multiple variables of same type
int redPin = 9, greenPin = 10, bluePin = 11;
float x = 0.0, y = 0.0, z = 0.0;

// Constants (values that never change)
const int BUTTON_PIN = 2;           // Pin number (won't change)
const float MAX_VOLTAGE = 5.0;      // Maximum voltage
const String DEVICE_ID = "ROBOT_001";  // Device identifier

Variable Naming Best Practices

Variable Scope and Lifetime

Understanding where variables can be used (scope) and how long they exist (lifetime) is crucial for effective programming.

// Global variables (declared outside functions)
int globalCounter = 0;        // Available everywhere in the program
String robotStatus = "Ready"; // Can be used in setup() and loop()

void setup() {
  // Local variables (declared inside functions)
  int setupCounter = 0;       // Only available inside setup()
  Serial.begin(9600);
  
  // Can access global variables
  globalCounter = 10;
  Serial.println(robotStatus);
  
  // setupCounter goes away when setup() ends
}

void loop() {
  // Local variables in loop()
  int loopCounter = 0;        // Only available inside loop()
  
  // Can access global variables
  globalCounter++;
  
  // Cannot access setupCounter here - it doesn't exist!
  // setupCounter++; // This would cause an error
  
  // Block scope example
  if (globalCounter > 5) {
    int blockVariable = 100;  // Only exists inside this if block
    Serial.println(blockVariable);
  }
  // blockVariable doesn't exist here
  
  delay(1000);
}

Basic Arithmetic Operators

Arduino supports all standard mathematical operations. Understanding these is essential for calculations involving sensors, timing, and control logic.

// Mathematical operations examples
int a = 10;
int b = 3;
int result;

// Basic arithmetic
result = a + b;        // result = 13
result = a - b;        // result = 7
result = a * b;        // result = 30
result = a / b;        // result = 3 (integer division!)
result = a % b;        // result = 1 (remainder)

// Assignment operators
int counter = 0;
counter += 5;          // counter = 5 (same as counter = counter + 5)
counter -= 2;          // counter = 3
counter *= 4;          // counter = 12
counter /= 3;          // counter = 4

// Increment and decrement
counter++;             // counter = 5 (add 1)
counter--;             // counter = 4 (subtract 1)
++counter;             // counter = 5 (pre-increment)
--counter;             // counter = 4 (pre-decrement)

// Working with floats for precise division
float voltage = 3.3;
float current = 0.02;
float resistance = voltage / current;  // resistance = 165.0

// Converting between types
int sensorValue = 512;
float percentage = (float)sensorValue / 1023.0 * 100.0;  // Convert to percentage

Practical Math Examples

/*
  Practical Mathematical Operations
  Real-world examples for robotics and sensor applications
*/

void setup() {
  Serial.begin(9600);
  Serial.println("=== Mathematical Operations Demo ===");
  
  // Example 1: Converting sensor readings to voltage
  int sensorReading = 512;      // Raw ADC value (0-1023)
  float voltage = sensorReading * (5.0 / 1023.0);  // Convert to voltage
  Serial.print("Sensor reading: ");
  Serial.print(sensorReading);
  Serial.print(" = ");
  Serial.print(voltage);
  Serial.println(" volts");
  
  // Example 2: Calculating LED brightness percentage
  int brightness = 128;         // PWM value (0-255)
  float percentage = (brightness / 255.0) * 100.0;
  Serial.print("LED brightness: ");
  Serial.print(percentage);
  Serial.println("%");
  
  // Example 3: Distance calculation from time
  long duration = 2000;         // Microseconds from ultrasonic sensor
  float distance = (duration * 0.034) / 2;  // Convert to centimeters
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  // Example 4: Temperature conversion
  float celsius = 25.0;
  float fahrenheit = (celsius * 9.0 / 5.0) + 32.0;
  Serial.print(celsius);
  Serial.print("°C = ");
  Serial.print(fahrenheit);
  Serial.println("°F");
}

void loop() {
  // Example 5: Cycling through values with modulo
  static int counter = 0;
  
  int ledValue = (counter % 256);  // Cycles 0-255 repeatedly
  Serial.print("Counter: ");
  Serial.print(counter);
  Serial.print(", LED value: ");
  Serial.println(ledValue);
  
  counter++;
  delay(500);
}

Activity Instructions