Home Arduino
Category:

Arduino

Arduino Tutorials

Tutorial: Arduino Variables and Constants

by shedboy71
written by shedboy71

Variables and constants are fundamental building blocks of Arduino programming. They allow you to store, modify, and access data throughout your program.

This tutorial introduces variables and constants, their types, how to declare them, and their practical applications.

Table of Contents

1. What Are Variables and Constants?

  • Variables: Storage locations in memory with a name, type, and value that can change during program execution.
  • Constants: Fixed values that do not change throughout the program’s execution.

2. Types of Variables

2.1 Integer (int)

  • Used to store whole numbers.
  • Range: -32,768 to 32,767 (16-bit on Arduino).

Example: Declaring and Using an Integer

void setup() {
  Serial.begin(9600);

  int count = 5;  // Declare and initialize an integer
  Serial.println(count);  // Print the value of count
}

void loop() {
  // Empty
}

2.2 Floating Point (float)

  • Used to store decimal numbers.
  • Precision: Up to 6-7 digits.

Example: Storing and Using a Float

void setup() {
  Serial.begin(9600);

  float pi = 3.14159;  // Declare and initialize a float
  Serial.println(pi);  // Print the value of pi
}

void loop() {
  // Empty
}

2.3 Character (char)

  • Used to store a single character or small integer (1 byte).
  • Range: -128 to 127.

Example: Using char Variables

void setup() {
  Serial.begin(9600);

  char letter = 'A';  // Declare and initialize a character
  Serial.println(letter);  // Print the character
}

void loop() {
  // Empty
}

2.4 Boolean (bool)

  • Used to store true or false.
  • Values: true (1) or false (0).

Example: Using a Boolean

void setup() {
  Serial.begin(9600);

  bool isOn = true;  // Declare a boolean
  if (isOn) {
    Serial.println("The device is ON.");
  } else {
    Serial.println("The device is OFF.");
  }
}

void loop() {
  // Empty
}

2.5 String (String)

  • Used to store sequences of characters.
  • Example: Names, messages.

Example: Using a String

void setup() {
  Serial.begin(9600);

  String message = "Hello, Arduino!";  // Declare a string
  Serial.println(message);  // Print the string
}

void loop() {
  // Empty
}

3. Constants in Arduino

Constants are defined using the const keyword or #define preprocessor directive.

Using const

  • Preferred method for type-safe constants.

Example: Declaring Constants

void setup() {
  const int ledPin = 13;  // Declare a constant
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);  // Turn on LED
}

void loop() {
  // Empty
}

Using #define

  • Preprocessor directive (not type-safe).

Example: Defining Constants

#define LED_PIN 13

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);  // Turn on LED
}

void loop() {
  // Empty
}

4. Variable Scope

4.1 Local Variables

  • Declared inside a function or block.
  • Accessible only within the scope in which they are declared.

Example: Local Variable

void setup() {
  int localVar = 10;  // Local variable
  Serial.begin(9600);
  Serial.println(localVar);  // Accessible here
}

void loop() {
  // localVar is not accessible here
}

4.2 Global Variables

  • Declared outside any function.
  • Accessible throughout the program.

Example: Global Variable

int globalVar = 20;  // Global variable

void setup() {
  Serial.begin(9600);
  Serial.println(globalVar);  // Accessible here
}

void loop() {
  Serial.println(globalVar);  // Accessible here
}

5. Examples of Variables and Constants

Example 5.1: Blink LED Using a Constant

const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);  // Turn LED on
  delay(1000);                 // Wait 1 second
  digitalWrite(ledPin, LOW);   // Turn LED off
  delay(1000);                 // Wait 1 second
}

Example 5.2: Reading Sensor Value into a Variable

const int sensorPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(sensorPin);  // Read sensor value
  Serial.println(sensorValue);             // Print the value
  delay(500);
}

Example 5.3: Using Multiple Data Types

void setup() {
  Serial.begin(9600);

  int count = 10;          // Integer
  float voltage = 3.3;     // Float
  char grade = 'A';        // Character
  bool isActive = true;    // Boolean
  String message = "Done"; // String

  Serial.println(count);
  Serial.println(voltage);
  Serial.println(grade);
  Serial.println(isActive);
  Serial.println(message);
}

void loop() {
  // Empty
}

Example 5.4: Toggle LED with Button Using a Boolean

const int buttonPin = 2;
const int ledPin = 13;

bool ledState = false;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (digitalRead(buttonPin) == HIGH) {
    ledState = !ledState;         // Toggle LED state
    digitalWrite(ledPin, ledState);
    delay(500);                   // Debounce delay
  }
}

6. Best Practices for Using Variables and Constants

  1. Use Descriptive Names:
    • Choose meaningful names to improve code readability.
    int temperatureSensorPin = A0; // Good
int ts = A0;                   // Avoid short names
  2. Use Constants for Fixed Values:
    • Replace magic numbers with constants for clarity and maintainability.
    const int MAX_SPEED = 255;
  3. Minimize Global Variables:
    • Prefer local variables when possible to avoid unexpected behavior.
  4. Initialize Variables:
    • Always initialize variables before use to prevent undefined behavior.
    int counter = 0; // Initialize
  5. Optimize Memory Usage:
    • Use the smallest data type that fits your needs (e.g., byte instead of int).

Conclusion

Variables and constants are crucial for storing and managing data in Arduino programs. By understanding their types, scope, and usage, you can write efficient and maintainable code.

This tutorial covers the fundamentals, along with practical examples to help you get started with Arduino programming.

For more details, visit the official Arduino reference.

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Serial Peripheral Interface (SPI)

by shedboy71
written by shedboy71

Serial Peripheral Interface (SPI) is a communication protocol used to transfer data between microcontrollers and peripheral devices like sensors, SD cards, displays, and more.

It is faster than I2C and uses a master-slave architecture.

This tutorial explains how SPI works, its implementation on Arduino, and provides practical examples.

Table of Contents

1. What Is SPI?

SPI is a synchronous serial communication protocol that uses four main lines:

  1. MOSI (Master Out Slave In): Data sent from master to slave.
  2. MISO (Master In Slave Out): Data sent from slave to master.
  3. SCK (Serial Clock): Clock signal controlled by the master.
  4. SS (Slave Select): Selects which slave device to communicate with.

Key Features:

  • Full-duplex: Data can be sent and received simultaneously.
  • Fast Communication: Suitable for high-speed data transfer.
  • Multiple Slaves: Can connect several slave devices with unique SS pins.

2. How Does SPI Work?

  1. The master generates a clock signal on the SCK line.
  2. Data is sent via MOSI (from master) or MISO (from slave).
  3. The master selects the target slave device using the SS line.
  4. The master and slave exchange data bits on every clock pulse.

3. Setting Up SPI on Arduino

Master Device

The master initiates communication and controls the clock.

Slave Device

The slave responds to the master’s requests and sends data when addressed.

4. Arduino SPI Library

The SPI library simplifies SPI communication in Arduino. You can include it in your project as follows:

#include <SPI.h>

4.1 SPI.begin()

  • Initializes the SPI bus.
  • Use on the master device.

4.2 SPI.transfer(data)

  • Sends data from the master to the slave and simultaneously receives data from the slave.
  • Returns the received byte.

4.3 SPI.end()

  • Disables the SPI bus.

5. SPI Pin Configuration

Board MOSI MISO SCK SS
Arduino Uno 11 12 13 10
Arduino Mega 51 50 52 53
Arduino Nano 11 12 13 10

6. Practical Examples

6.1 Communicating Between Two Arduinos

Master Code

#include <SPI.h>

const int ssPin = 10;

void setup() {
  pinMode(ssPin, OUTPUT);
  digitalWrite(ssPin, HIGH);  // Ensure slave is not selected
  SPI.begin();                // Initialize SPI as master
  Serial.begin(9600);
}

void loop() {
  digitalWrite(ssPin, LOW);           // Select slave
  byte receivedData = SPI.transfer(42); // Send data and receive response
  digitalWrite(ssPin, HIGH);          // Deselect slave

  Serial.print("Received: ");
  Serial.println(receivedData);
  delay(1000);
}

Slave Code

#include <SPI.h>

const int ssPin = 10;

void setup() {
  pinMode(ssPin, INPUT);
  SPI.begin();  // Initialize SPI as slave
  SPI.setBitOrder(MSBFIRST); // Set bit order (default)
}

void loop() {
  if (digitalRead(ssPin) == LOW) {
    byte data = SPI.transfer(0); // Respond with dummy data
    SPI.transfer(data + 1);      // Return data incremented by 1
  }
}

6.2 Interfacing with an SPI Sensor

Use an SPI temperature sensor (e.g., MCP3008).

#include <SPI.h>

const int csPin = 10;

void setup() {
  pinMode(csPin, OUTPUT);
  digitalWrite(csPin, HIGH);  // Deselect sensor
  SPI.begin();
  Serial.begin(9600);
}

void loop() {
  digitalWrite(csPin, LOW);                // Select sensor
  SPI.transfer(0b00000001);                // Start bit
  byte highByte = SPI.transfer(0b10000000); // Send configuration bits
  byte lowByte = SPI.transfer(0);          // Read data
  digitalWrite(csPin, HIGH);               // Deselect sensor

  int value = ((highByte & 0x03) << 8) | lowByte; // Combine bytes
  Serial.print("Sensor Value: ");
  Serial.println(value);

  delay(500);
}

6.3 Controlling an SPI Display

Control an SPI OLED or LCD display (e.g., SSD1306).

  1. Install Adafruit SSD1306 Library:
    • Go to Tools > Manage Libraries and search for “Adafruit SSD1306.”
  2. Connect the Display:
    • Connect MOSI, SCK, CS, and DC to appropriate pins.
  3. Code Example:
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define CS_PIN 10

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &SPI, OLED_RESET, DC, CS_PIN);

void setup() {
  if (!display.begin(SSD1306_I2C_ADDRESS, CS_PIN)) {
    Serial.println("OLED initialization failed");
    while (1);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Hello, SPI Display!");
  display.display();
}

void loop() {
  // Empty
}

7. Best Practices for Using SPI

  1. Use Pull-Up Resistors:
    • Use pull-up resistors on the SS lines to prevent floating states.
  2. Select the Correct Mode:
    • SPI devices operate in different modes (clock polarity and phase). Refer to the device datasheet to configure the correct mode using: 
      SPI.setDataMode(SPI_MODE0);
  3. Handle Shared Buses:
    • If multiple slaves share the SPI bus, ensure only one slave is active at a time by managing the SS lines.
  4. Monitor Clock Speed:
    • Use SPI.setClockDivider() to adjust the speed based on the slave device’s requirements.
  5. Debug with Serial Monitor:
    • Print transmitted and received data to verify communication.

Conclusion

SPI is a versatile and high-speed communication protocol, ideal for connecting Arduino with various peripherals.

By using the built-in SPI library, you can simplify communication and focus on building your project.

This tutorial provided an introduction to SPI, its functions, and practical examples like Arduino-to-Arduino communication, interfacing with a sensor, and controlling a display.

For more details, visit the official Arduino SPI reference.

 

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Loops

by shedboy71
written by shedboy71

In Arduino, loops are essential for running repetitive tasks. Loops allow you to execute a block of code multiple times based on a condition.

This tutorial explores the different types of loops available in Arduino, their syntax, and practical use cases with examples.

Table of Contents

1. What Are Loops?

Loops in Arduino allow you to:

  • Execute a block of code repeatedly.
  • Automate repetitive tasks like blinking an LED or reading sensor data.
  • Check conditions and decide whether to stop or continue looping.

2. Types of Loops in Arduino

2.1 for Loop

The for loop is used when you know the exact number of iterations in advance.

Syntax

for (initialization; condition; increment) {
  // Code to execute
}

Example: Blink LED 5 Times

const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < 5; i++) { // Loop 5 times
    digitalWrite(ledPin, HIGH); // Turn LED on
    delay(500);                 // Wait for 500ms
    digitalWrite(ledPin, LOW);  // Turn LED off
    delay(500);                 // Wait for 500ms
  }

  while (true); // Stop execution after blinking
}

2.2 while Loop

The while loop executes as long as the condition is true.

Syntax

while (condition) {
  // Code to execute
}

Example: Keep LED On While Button Is Pressed

const int buttonPin = 2;
const int ledPin = 13;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  while (digitalRead(buttonPin) == HIGH) { // Loop while button is pressed
    digitalWrite(ledPin, HIGH);           // Turn LED on
  }
  digitalWrite(ledPin, LOW);              // Turn LED off when button is released
}

2.3 do-while Loop

The do-while loop executes the block of code at least once, regardless of the condition.

Syntax

do {
  // Code to execute
} while (condition);

Example: Flash LED Once, Then Check Condition

const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int count = 1;

  do {
    digitalWrite(ledPin, HIGH); // Turn LED on
    delay(500);
    digitalWrite(ledPin, LOW);  // Turn LED off
    delay(500);

    count++;
  } while (count <= 5);         // Loop until count exceeds 5

  while (true); // Stop execution after blinking
}

3. Nested Loops

Loops can be nested inside other loops. This is useful for tasks like controlling multiple LEDs or creating patterns.

Example: Blink Multiple LEDs in a Sequence

const int ledPins[] = {2, 3, 4, 5}; // Define LED pins
const int numLeds = 4;

void setup() {
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT); // Set all pins as OUTPUT
  }
}

void loop() {
  for (int i = 0; i < numLeds; i++) { // Outer loop for LEDs
    for (int j = 0; j < 3; j++) {     // Inner loop to blink each LED 3 times
      digitalWrite(ledPins[i], HIGH);
      delay(300);
      digitalWrite(ledPins[i], LOW);
      delay(300);
    }
  }
}

4. Practical Examples

Example 4.1: Reading Sensor Data Continuously

const int sensorPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Read sensor value
  Serial.println(sensorValue);            // Print value to Serial Monitor
  delay(1000);                            // Wait for 1 second
}

Example 4.2: LED Chase Sequence

const int ledPins[] = {2, 3, 4, 5};
const int numLeds = 4;

void setup() {
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < numLeds; i++) {
    digitalWrite(ledPins[i], HIGH);
    delay(200);
    digitalWrite(ledPins[i], LOW);
  }
}

Example 4.3: Infinite Loop for Monitoring

const int buttonPin = 2;

void setup() {
  pinMode(buttonPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  if (digitalRead(buttonPin) == HIGH) {
    Serial.println("Button Pressed!");
  }
}

5. Break and Continue in Loops

Break Statement

The break statement exits the current loop.

Example: Stop Loop After 3 Iterations

void setup() {
  Serial.begin(9600);

  for (int i = 1; i <= 5; i++) {
    if (i > 3) {
      break; // Exit loop
    }
    Serial.println(i);
  }
}

void loop() {
  // Empty
}

Continue Statement

The continue statement skips the current iteration and proceeds to the next.

Example: Skip Even Numbers

void setup() {
  Serial.begin(9600);

  for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
      continue; // Skip even numbers
    }
    Serial.println(i);
  }
}

void loop() {
  // Empty
}

6. Best Practices for Using Loops

  1. Avoid Infinite Loops in loop():
    • Ensure loop() continues running unless intended (e.g., while (true)).
  2. Use Delays Sparingly:
    • Avoid excessive delay() in loops, as it can block other processes.
  3. Optimize Conditions:
    • Simplify loop conditions for better readability and performance.
  4. Test Nested Loops:
    • Ensure nested loops don’t result in excessive computation.
  5. Use Breakpoints in Debugging:
    • Add Serial.print() statements to understand loop flow during debugging.

Conclusion

Loops are the backbone of Arduino programming, enabling repetitive tasks and controlling the flow of a program.

By mastering the various types of loops (for, while, and do-while) and their use cases, you can build efficient and powerful Arduino projects.

For more details, visit the official Arduino reference.

 

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Tone Library

by shedboy71
written by shedboy71

The Tone Library in Arduino allows you to generate sound waves on a digital pin, making it easy to create melodies, sound effects, or audible alerts using a piezo buzzer or speaker.

This tutorial explains the tone library, its functions, and how to use it with examples.

Table of Contents

1. What Is the Tone Library?

The Tone Library is a built-in feature of Arduino that allows you to generate square waves of varying frequencies on a digital pin. These square waves can produce sounds when connected to a piezo buzzer or speaker.

2. Functions in the Tone Library

2.1 tone()

  • Generates a square wave on a specific pin at a given frequency.
  • Syntax: 
    tone(pin, frequency, duration);
    • pin: Digital pin number.
    • frequency: Frequency of the tone in Hz.
    • duration: (Optional) Duration of the tone in milliseconds.

Example:

tone(8, 440, 500);  // Play a 440 Hz tone on pin 8 for 500 ms

2.2 noTone()

  • Stops the tone being generated on a pin.
  • Syntax: 
    noTone(pin);

Example:

noTone(8);  // Stop tone on pin 8

3. Connecting a Piezo Buzzer or Speaker

Circuit Diagram

  1. Connect the positive pin of the piezo buzzer or speaker to a digital pin (e.g., pin 8).
  2. Connect the negative pin to GND.
  3. Optionally, use a resistor (e.g., 100-1k ohms) in series with the buzzer to limit current.

4. Practical Examples

4.1 Play a Single Note

Play a simple tone for a specific duration.

const int buzzerPin = 8;

void setup() {
  tone(buzzerPin, 440, 1000);  // Play 440 Hz for 1 second
}

void loop() {
  // Empty
}

4.2 Create a Melody

Generate a sequence of tones to create a melody.

const int buzzerPin = 8;

// Notes and their frequencies (in Hz)
const int melody[] = {262, 294, 330, 349, 392, 440, 494, 523};  // C4 to C5
const int noteDuration = 500;  // Duration of each note (ms)

void setup() {
  for (int i = 0; i < 8; i++) {
    tone(buzzerPin, melody[i], noteDuration);  // Play each note
    delay(noteDuration + 100);                // Pause between notes
  }
}

void loop() {
  // Empty
}

4.3 Generate Alarms or Alerts

Create a repeating alert sound with alternating tones.

const int buzzerPin = 8;

void setup() {
  // Empty
}

void loop() {
  tone(buzzerPin, 1000, 200);  // Play 1000 Hz for 200 ms
  delay(300);
  tone(buzzerPin, 500, 200);   // Play 500 Hz for 200 ms
  delay(300);
}

4.4 Play a Scale

Play a musical scale by gradually increasing the frequency.

const int buzzerPin = 8;

void setup() {
  int startFrequency = 262;  // Start frequency (C4)
  for (int i = 0; i < 8; i++) {
    tone(buzzerPin, startFrequency);  // Play the current frequency
    delay(500);
    startFrequency += 50;            // Increase frequency for the next note
  }
  noTone(buzzerPin);  // Stop the tone
}

void loop() {
  // Empty
}

4.5 Play a Custom Song

Play “Twinkle Twinkle Little Star” using predefined notes and durations.

const int buzzerPin = 8;

// Notes for "Twinkle Twinkle Little Star"
const int melody[] = {
  262, 262, 392, 392, 440, 440, 392, 
  349, 349, 330, 330, 294, 294, 262
};

// Note durations (4 = quarter note, 8 = eighth note)
const int noteDurations[] = {
  4, 4, 4, 4, 4, 4, 2,
  4, 4, 4, 4, 4, 4, 2
};

void setup() {
  for (int i = 0; i < 14; i++) {
    int noteDuration = 1000 / noteDurations[i];  // Calculate note duration
    tone(buzzerPin, melody[i], noteDuration);
    delay(noteDuration + 50);  // Pause between notes
  }
}

void loop() {
  // Empty
}

5. Best Practices for Using the Tone Library

  1. Limit Duration:
    • Use the duration parameter to stop tones automatically after a certain time.
  2. Avoid Conflicts:
    • The tone() function blocks PWM output on pins 3 and 11 on some boards (e.g., Arduino Uno).
  3. Use noTone():
    • Always call noTone() to stop the tone when it’s no longer needed.
  4. Combine with Delays:
    • Use delay() between tones to create distinct notes in melodies.
  5. Test with Resistors:
    • Use resistors with speakers to limit current and prevent damage to the Arduino pin.
  6. Optimize for Memory:
    • For complex songs, use arrays for notes and durations instead of hardcoding values.

Conclusion

The Arduino Tone Library is a simple yet powerful tool for generating sounds and melodies.

Whether you’re creating alarms, musical projects, or audio feedback for devices, this library makes it easy to generate tones of varying frequencies and durations.

This tutorial provided a comprehensive overview of tone functions and included practical examples to get you started. For more details, visit the official Arduino reference.

 

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Control Statements

by shedboy71
written by shedboy71

Control statements in Arduino are used to control the flow of execution in a program.

They allow you to make decisions, repeat actions, and manage program logic based on certain conditions or loops.

This tutorial covers the main control statements in Arduino, with examples to illustrate their usage.

Table of Contents

1. What Are Control Statements?

Control statements manage the execution flow of a program. They allow you to:

  • Make decisions based on conditions.
  • Repeat a block of code multiple times.
  • Break or skip iterations in loops.

2. Types of Control Statements

  1. Conditional Statements: Execute code blocks based on specific conditions (if, else, switch).
  2. Looping Statements: Repeat code blocks until a condition is met (for, while, do-while).

3. Conditional Statements

3.1 if and else

The if statement executes a block of code if the condition is true. The else block executes if the condition is false.

Syntax

if (condition) {
  // Code to execute if condition is true
} else {
  // Code to execute if condition is false
}

Example: Turn LED On Based on Button Press

const int buttonPin = 2;
const int ledPin = 13;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == HIGH) {
    digitalWrite(ledPin, HIGH); // Turn LED on
    Serial.println("LED ON");
  } else {
    digitalWrite(ledPin, LOW);  // Turn LED off
    Serial.println("LED OFF");
  }
}

3.2 switch Case

The switch statement selects one of many code blocks to execute based on a variable’s value.

Syntax

switch (variable) {
  case value1:
    // Code to execute for value1
    break;
  case value2:
    // Code to execute for value2
    break;
  default:
    // Code to execute if no case matches
    break;
}

Example: Control LED Brightness Using a Switch

const int ledPin = 9;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int mode = 2; // Change mode for different brightness levels

  switch (mode) {
    case 1:
      analogWrite(ledPin, 64); // Low brightness
      break;
    case 2:
      analogWrite(ledPin, 128); // Medium brightness
      break;
    case 3:
      analogWrite(ledPin, 255); // High brightness
      break;
    default:
      analogWrite(ledPin, 0); // LED off
      break;
  }

  delay(1000);
}

4. Looping Statements

4.1 for Loop

The for loop is used to repeat a block of code a specific number of times.

Syntax

for (initialization; condition; increment) {
  // Code to execute
}

Example: Blink LED 10 Times

const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < 10; i++) {
    digitalWrite(ledPin, HIGH);
    delay(500);
    digitalWrite(ledPin, LOW);
    delay(500);
  }
  while (true); // Stop further execution
}

4.2 while Loop

The while loop executes a block of code as long as the condition is true.

Syntax

while (condition) {
  // Code to execute
}

Example: Blink LED While Button Is Pressed

const int buttonPin = 2;
const int ledPin = 13;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  while (digitalRead(buttonPin) == HIGH) {
    digitalWrite(ledPin, HIGH);
    delay(500);
    digitalWrite(ledPin, LOW);
    delay(500);
  }
}

4.3 do-while Loop

The do-while loop executes the code block at least once before checking the condition.

Syntax

do {
  // Code to execute
} while (condition);

Example: Print Numbers Until 10

void setup() {
  Serial.begin(9600);

  int count = 1;
  do {
    Serial.println(count);
    count++;
  } while (count <= 10);
}

void loop() {
  // Empty
}

5. Break and Continue

5.1 Break

  • Terminates the current loop or switch statement.

Example: Stop Loop After 5 Iterations

void setup() {
  Serial.begin(9600);

  for (int i = 1; i <= 10; i++) {
    if (i > 5) {
      break;
    }
    Serial.println(i);
  }
}

void loop() {
  // Empty
}

5.2 Continue

  • Skips the rest of the current iteration and moves to the next iteration.

Example: Skip Even Numbers

void setup() {
  Serial.begin(9600);

  for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
      continue;
    }
    Serial.println(i);
  }
}

void loop() {
  // Empty
}

6. Practical Examples

Example 6.1: LED Chase Sequence

const int ledPins[] = {2, 3, 4, 5};
const int numLeds = 4;

void setup() {
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < numLeds; i++) {
    digitalWrite(ledPins[i], HIGH);
    delay(200);
    digitalWrite(ledPins[i], LOW);
  }
}

Example 6.2: Temperature Alert System

const int tempPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int temp = analogRead(tempPin);

  if (temp > 800) {
    Serial.println("High Temperature Alert!");
  } else if (temp > 600) {
    Serial.println("Moderate Temperature.");
  } else {
    Serial.println("Temperature is Normal.");
  }

  delay(1000);
}

7. Best Practices for Control Statements

  1. Use Indentation:
    • Properly indent code for better readability.
  2. Avoid Infinite Loops:
    • Ensure loop termination conditions are met.
  3. Minimize Nested Loops:
    • Too many nested loops can make the program difficult to read and debug.
  4. Use Switch for Multiple Conditions:
    • Use switch when handling multiple cases for a single variable.
  5. Optimize Conditions:
    • Avoid redundant checks in conditional statements.

Conclusion

Control statements are fundamental for managing the flow of execution in Arduino programs. By using conditional and looping statements effectively, you can build powerful and dynamic Arduino applications.

This tutorial covered the essential control statements and provided examples to help you get started.

For more details, visit the official Arduino reference.

 

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Interrupts

by shedboy71
written by shedboy71

Interrupts in Arduino allow you to execute specific pieces of code immediately when a particular event occurs, regardless of what the main program is doing.

They are essential for creating responsive and time-sensitive applications.

This tutorial explains how to use interrupts in Arduino and demonstrates practical examples.

Table of Contents

1. What Are Interrupts in Arduino?

Interrupts are mechanisms that pause the main program flow and execute a specific piece of code (an interrupt service routine, or ISR) when a defined event occurs. Once the ISR is complete, the main program resumes.

2. How Do Interrupts Work?

  1. Trigger an Event: An interrupt is triggered by hardware events such as a change in pin state or a timer overflow.
  2. Execute ISR: The ISR runs immediately and completes as quickly as possible.
  3. Resume Main Code: After the ISR finishes, the main program continues.

3. Types of Interrupts

3.1 External Interrupts

  • Triggered by events on specific external pins (INT0 and INT1 on most Arduino boards).
  • Use attachInterrupt() to configure them.

Available Interrupt Pins (Common Boards)

Board Pins
Arduino Uno 2 (INT0), 3 (INT1)
Arduino Mega 2, 3, 18, 19, 20, 21
Arduino Nano 2, 3

3.2 Pin Change Interrupts

  • Triggered by changes on any GPIO pin.
  • Requires the EnableInterrupt library for easy implementation.

4. Functions for Interrupts

4.1 attachInterrupt()

  • Configures an external interrupt.
  • Syntax: 
    attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);
    • pin: The pin number (use digitalPinToInterrupt(pin) to convert it to the interrupt number).
    • ISR: The interrupt service routine function to execute.
    • mode: Trigger condition (LOW, CHANGE, RISING, FALLING).

4.2 detachInterrupt()

  • Disables an interrupt.
  • Syntax: 
    detachInterrupt(digitalPinToInterrupt(pin));

5. Practical Examples

5.1 Button Press Interrupt

Use an interrupt to toggle an LED when a button is pressed.

const int buttonPin = 2;  // Interrupt pin
const int ledPin = 13;    // LED pin
volatile bool ledState = false;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);  // Configure button pin with pull-up resistor
  pinMode(ledPin, OUTPUT);           // Configure LED pin
  attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING);
}

void loop() {
  digitalWrite(ledPin, ledState);  // Set LED state
}

// ISR to toggle LED state
void toggleLED() {
  ledState = !ledState;
}

5.2 Pulse Counting

Count the number of pulses received on a pin (e.g., from a rotary encoder or sensor).

const int pulsePin = 2;  // Interrupt pin
volatile int pulseCount = 0;

void setup() {
  Serial.begin(9600);
  pinMode(pulsePin, INPUT_PULLUP);  // Configure pin with pull-up resistor
  attachInterrupt(digitalPinToInterrupt(pulsePin), countPulse, RISING);
}

void loop() {
  Serial.print("Pulse Count: ");
  Serial.println(pulseCount);
  delay(1000);  // Print every second
}

// ISR to increment pulse count
void countPulse() {
  pulseCount++;
}

5.3 Toggle LED Using a Timer Interrupt

Use a timer interrupt to toggle an LED periodically. This requires the TimerOne library.

  1. Install the TimerOne Library:
    • Go to Tools > Manage Libraries.
    • Search for “TimerOne” and install it.
  2. Code Example:
#include <TimerOne.h>

const int ledPin = 13;  // LED pin
volatile bool ledState = false;

void setup() {
  pinMode(ledPin, OUTPUT);
  Timer1.initialize(1000000);  // Set timer to 1 second (1,000,000 microseconds)
  Timer1.attachInterrupt(toggleLED);  // Attach interrupt
}

void loop() {
  digitalWrite(ledPin, ledState);  // Set LED state
}

// ISR to toggle LED state
void toggleLED() {
  ledState = !ledState;
}

5.4 Random LED Blinking Using Interrupt

Use interrupts to randomly blink LEDs when triggered by a button press.

const int buttonPin = 2;  // Interrupt pin
const int ledPins[] = {3, 4, 5};  // LED pins
const int numLeds = 3;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
  attachInterrupt(digitalPinToInterrupt(buttonPin), randomBlink, FALLING);
}

void loop() {
  // Main loop does nothing; all work is handled in the ISR
}

// ISR to randomly blink an LED
void randomBlink() {
  int randomLed = random(0, numLeds);
  digitalWrite(ledPins[randomLed], HIGH);
  delay(200);
  digitalWrite(ledPins[randomLed], LOW);
}

6. Best Practices for Using Interrupts

  1. Keep ISRs Short:
    • Avoid delays or complex operations in ISRs. Only set flags or increment counters.
    void ISR() {
  // Avoid using Serial.print or delay() here
  flag = true;  // Use flags for further processing in the main loop
}
  2. Disable Unused Interrupts:
    • Use detachInterrupt() to disable interrupts when no longer needed.
  3. Minimize Shared Resources:
    • Avoid accessing variables shared between ISRs and the main program. Use volatile for shared variables.
  4. Debounce Buttons:
    • Add debouncing logic to prevent multiple triggers from button noise.
  5. Test Interrupt Priority:
    • Understand that some interrupts may take priority over others. Ensure critical tasks are prioritized.
  6. Use External Pull-Up Resistors When Necessary:
    • Ensure clean signal transitions for stable interrupt triggers.

Conclusion

Interrupts in Arduino are powerful tools for creating responsive and real-time applications.

They allow you to handle events like button presses, sensor pulses, or timer overflows with minimal delay.

By following the examples and best practices in this tutorial, you can confidently use interrupts in your Arduino projects.

For more details, visit the official Arduino reference.

 

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Operators

by shedboy71
written by shedboy71

Operators in Arduino are used to perform operations on variables and values. They are essential for controlling program flow, performing arithmetic, and making comparisons.

This tutorial introduces the types of operators available in Arduino, along with examples to demonstrate their usage.

Table of Contents

1. What Are Operators?

An operator is a symbol that tells the Arduino to perform a specific action on one or more operands. For example:

  • + adds two numbers.
  • && checks if two conditions are true.

2. Types of Arduino Operators

2.1 Arithmetic Operators

Used to perform basic mathematical operations.

Operator Description Example
+ Addition x + y
– Subtraction x – y
* Multiplication x * y
/ Division x / y
% Modulus (remainder) x % y

Example: Using Arithmetic Operators

void setup() {
  Serial.begin(9600);

  int x = 10;
  int y = 3;

  Serial.println(x + y);  // Addition
  Serial.println(x - y);  // Subtraction
  Serial.println(x * y);  // Multiplication
  Serial.println(x / y);  // Division
  Serial.println(x % y);  // Modulus
}

void loop() {
  // Empty
}

2.2 Comparison Operators

Used to compare two values.

Operator Description Example
== Equal to x == y
!= Not equal to x != y
> Greater than x > y
< Less than x < y
>= Greater than or equal to x >= y
<= Less than or equal to x <= y

Example: Using Comparison Operators

void setup() {
  Serial.begin(9600);

  int a = 5;
  int b = 10;

  Serial.println(a == b);  // False (0)
  Serial.println(a != b);  // True (1)
  Serial.println(a > b);   // False (0)
  Serial.println(a < b);   // True (1)
}

void loop() {
  // Empty
}

2.3 Logical Operators

Used to combine or invert boolean values.

Operator Description Example
&& Logical AND (both true) x && y
` `
! Logical NOT (invert condition) !x

Example: Using Logical Operators

void setup() {
  Serial.begin(9600);

  bool condition1 = true;
  bool condition2 = false;

  Serial.println(condition1 && condition2);  // False (0)
  Serial.println(condition1 || condition2);  // True (1)
  Serial.println(!condition1);               // False (0)
}

void loop() {
  // Empty
}

2.4 Bitwise Operators

Used to manipulate data at the bit level.

Operator Description Example
& Bitwise AND x & y
` ` Bitwise OR
^ Bitwise XOR x ^ y
~ Bitwise NOT ~x
<< Left shift x << 2
>> Right shift x >> 2

Example: Using Bitwise Operators

void setup() {
  Serial.begin(9600);

  int x = 5;  // 0101 in binary
  int y = 3;  // 0011 in binary

  Serial.println(x & y);  // Bitwise AND (0001)
  Serial.println(x | y);  // Bitwise OR (0111)
  Serial.println(x ^ y);  // Bitwise XOR (0110)
  Serial.println(~x);     // Bitwise NOT
  Serial.println(x << 1); // Left shift (1010)
  Serial.println(x >> 1); // Right shift (0010)
}

void loop() {
  // Empty
}

2.5 Assignment Operators

Used to assign values to variables.

Operator Description Example
= Assign x = y
+= Add and assign x += y
-= Subtract and assign x -= y
*= Multiply and assign x *= y
/= Divide and assign x /= y
%= Modulus and assign x %= y

Example: Using Assignment Operators

void setup() {
  Serial.begin(9600);

  int x = 10;

  x += 5;  // x = x + 5
  Serial.println(x);

  x *= 2;  // x = x * 2
  Serial.println(x);
}

void loop() {
  // Empty
}

2.6 Increment/Decrement Operators

Used to increase or decrease a value by 1.

Operator Description Example
++ Increment by 1 ++x
— Decrement by 1 –x

Example: Using Increment/Decrement Operators

void setup() {
  Serial.begin(9600);

  int x = 5;

  Serial.println(++x);  // Pre-increment: Increment, then print
  Serial.println(x++);  // Post-increment: Print, then increment
  Serial.println(--x);  // Pre-decrement: Decrement, then print
  Serial.println(x--);  // Post-decrement: Print, then decrement
}

void loop() {
  // Empty
}

3. Practical Examples

Example 3.1: Calculating the Area of a Rectangle

void setup() {
  Serial.begin(9600);

  int length = 10;
  int width = 5;
  int area = length * width;

  Serial.print("Area: ");
  Serial.println(area);
}

void loop() {
  // Empty
}

Example 3.2: Checking a Range with Logical Operators

void setup() {
  Serial.begin(9600);

  int temperature = 25;

  if (temperature > 20 && temperature < 30) {
    Serial.println("Temperature is within the comfortable range.");
  } else {
    Serial.println("Temperature is outside the comfortable range.");
  }
}

void loop() {
  // Empty
}

Example 3.3: Toggle an LED Using Bitwise Operators

const int ledPin = 13;
bool ledState = false;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  ledState = !ledState;  // Toggle state using NOT operator
  digitalWrite(ledPin, ledState);
  delay(1000);  // Wait for 1 second
}

4. Best Practices for Using Operators

  1. Use Parentheses for Clarity:
    • Parentheses make complex expressions easier to read.
    • Example: (a + b) * c is clearer than a + b * c.
  2. Be Cautious with Division:
    • Integer division truncates the result. Use floats for precise results.
  3. Avoid Unnecessary Bitwise Operations:
    • Use bitwise operators only when working with binary data.
  4. Test Logical Conditions Thoroughly:
    • Ensure all branches in your conditional statements are tested.
  5. Optimize Arithmetic Operations:
    • Combine multiple operations using assignment operators when possible.

Conclusion

Operators are the building blocks of Arduino programming, enabling mathematical calculations, logical comparisons, and data manipulation. By understanding and using these operators effectively, you can write efficient and powerful Arduino sketches.

For more details, visit the official Arduino reference.

0 comment
0 FacebookTwitterPinterestEmail
Arduino Tutorials

Tutorial: Arduino Data Types

by shedboy71
written by shedboy71

Arduino programming supports a variety of data types for storing and manipulating data.

Understanding these data types is essential for writing efficient and bug-free programs.

This tutorial introduces the different data types available in Arduino and provides practical examples to illustrate their usage.

Table of Contents

1. What Are Data Types?

Data types define the type of data a variable can store. In Arduino, data types are used to:

  • Store numbers, characters, or boolean values.
  • Control memory usage.
  • Perform specific operations based on the type of data.

2. Basic Data Types

2.1 int (Integer)

  • Stores whole numbers (positive or negative).
  • Range: -32,768 to 32,767 (16-bit).

Example: Storing and Printing an Integer

void setup() {
  Serial.begin(9600);

  int num = 12345;  // Declare an integer variable
  Serial.println(num);  // Print the integer
}

void loop() {
  // Empty
}

2.2 float (Floating Point)

  • Stores decimal numbers.
  • Range: -3.4028235E+38 to 3.4028235E+38 (4 bytes).

Example: Using Floats

void setup() {
  Serial.begin(9600);

  float pi = 3.14159;  // Declare a floating-point variable
  Serial.println(pi);  // Print the float
}

void loop() {
  // Empty
}

2.3 char (Character)

  • Stores a single character or a small number (1 byte).
  • Range: -128 to 127 (ASCII values).

Example: Storing and Printing a Character

void setup() {
  Serial.begin(9600);

  char letter = 'A';  // Declare a char variable
  Serial.println(letter);  // Print the character
}

void loop() {
  // Empty
}

2.4 boolean

  • Stores true or false.
  • Used for conditional logic.

Example: Using a Boolean

void setup() {
  Serial.begin(9600);

  boolean isOn = true;  // Declare a boolean variable
  if (isOn) {
    Serial.println("The light is on.");
  } else {
    Serial.println("The light is off.");
  }
}

void loop() {
  // Empty
}

3. Unsigned Data Types

3.1 unsigned int

  • Stores only positive integers.
  • Range: 0 to 65,535.

Example: Using Unsigned Integers

void setup() {
  Serial.begin(9600);

  unsigned int distance = 50000;  // Declare an unsigned int
  Serial.println(distance);  // Print the unsigned int
}

void loop() {
  // Empty
}

3.2 unsigned long

  • Stores larger positive integers.
  • Range: 0 to 4,294,967,295.

Example: Using Unsigned Long for Timers

void setup() {
  Serial.begin(9600);
}

void loop() {
  unsigned long currentMillis = millis();  // Get the number of milliseconds since the program started
  Serial.println(currentMillis);
  delay(1000);  // Wait for 1 second
}

4. Advanced Data Types

4.1 String

  • Stores a sequence of characters.

Example: Using Strings

void setup() {
  Serial.begin(9600);

  String greeting = "Hello, Arduino!";  // Declare a string
  Serial.println(greeting);  // Print the string
}

void loop() {
  // Empty
}

4.2 Array

  • Stores multiple values of the same type.

Example: Using Arrays

void setup() {
  Serial.begin(9600);

  int numbers[5] = {10, 20, 30, 40, 50};  // Declare an array
  for (int i = 0; i < 5; i++) {
    Serial.println(numbers[i]);  // Print each array element
  }
}

void loop() {
  // Empty
}

4.3 struct

  • Groups variables of different types into a single unit.

Example: Using Structs

struct SensorData {
  int temperature;
  float humidity;
  boolean motionDetected;
};

void setup() {
  Serial.begin(9600);

  SensorData data = {25, 60.5, true};  // Declare and initialize a struct
  Serial.print("Temperature: ");
  Serial.println(data.temperature);
  Serial.print("Humidity: ");
  Serial.println(data.humidity);
  Serial.print("Motion Detected: ");
  Serial.println(data.motionDetected);
}

void loop() {
  // Empty
}

5. Practical Examples

Example 5.1: Using Data Types for Sensors

void setup() {
  Serial.begin(9600);

  int sensorValue = analogRead(A0);  // Read analog input
  float voltage = sensorValue * (5.0 / 1023.0);  // Convert to voltage
  Serial.print("Sensor Value: ");
  Serial.println(sensorValue);
  Serial.print("Voltage: ");
  Serial.println(voltage);
}

void loop() {
  delay(1000);  // Wait for 1 second
}

Example 5.2: Timing an Event with Unsigned Long

unsigned long previousMillis = 0;
const long interval = 2000;  // 2 seconds

void setup() {
  Serial.begin(9600);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;  // Update the last executed time
    Serial.println("Event triggered!");
  }
}

6. Best Practices for Using Data Types

  1. Choose the Right Type: Use the smallest data type that fits your range to save memory.
  2. Unsigned for Non-Negative Values: Use unsigned for variables that only store positive values.
  3. Use Floats for Precision: Use float when decimal precision is needed.
  4. Use Structs for Grouped Data: Use struct to manage related variables efficiently.
  5. Be Mindful of Overflow: Monitor large data types like long and unsigned long to avoid overflow.

Conclusion

Understanding data types is a fundamental aspect of Arduino programming. By selecting the appropriate data type for your application, you can optimize memory usage and write efficient, readable code.

This tutorial provides an overview of the most commonly used data types and their practical applications in Arduino projects.

For more details, visit the official Arduino reference.

0 comment
0 FacebookTwitterPinterestEmail
Arduino

10 Useful Arduino Code Snippets

by shedboy71
written by shedboy71

Here are 10 handy Arduino code snippets for various common tasks:

1. Blink an LED

const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);  // Wait for 1 second
  digitalWrite(ledPin, LOW);
  delay(1000);  // Wait for 1 second
}

2. Read Analog Input

const int analogPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(analogPin);
  Serial.println(sensorValue);
  delay(500);
}

3. Button Controlled LED

const int buttonPin = 2;
const int ledPin = 13;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

4. PWM LED Brightness Control

const int ledPin = 9;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness);
    delay(10);
  }
  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness);
    delay(10);
  }
}

5. Temperature Reading with LM35

const int tempPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(tempPin);
  float voltage = sensorValue * (5.0 / 1023.0);
  float temperature = voltage * 100;  // LM35 outputs 10mV per degree Celsius
  Serial.print("Temperature: ");
  Serial.println(temperature);
  delay(1000);
}

6. Ultrasonic Sensor (HC-SR04) Distance Measurement

const int trigPin = 9;
const int echoPin = 10;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long duration = pulseIn(echoPin, HIGH);
  int distance = duration * 0.034 / 2;

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
  delay(1000);
}

7. Control Servo Motor

#include <Servo.h>

Servo myServo;
const int potPin = A0;

void setup() {
  myServo.attach(9);
}

void loop() {
  int potValue = analogRead(potPin);
  int angle = map(potValue, 0, 1023, 0, 180);
  myServo.write(angle);
  delay(15);
}

8. RGB LED Control

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  analogWrite(redPin, 255);   // Full red
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 0);
  delay(1000);

  analogWrite(redPin, 0);
  analogWrite(greenPin, 255);  // Full green
  analogWrite(bluePin, 0);
  delay(1000);

  analogWrite(redPin, 0);
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 255);  // Full blue
  delay(1000);
}

9. Simple Debouncing for Button Input

const int buttonPin = 2;
const int ledPin = 13;
bool lastState = LOW;
bool currentState;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  currentState = digitalRead(buttonPin);
  if (currentState != lastState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (currentState == HIGH) {
      digitalWrite(ledPin, !digitalRead(ledPin));
    }
  }
  lastState = currentState;
}

10. OLED Display with SSD1306

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  if (!display.begin(SSD1306_I2C_ADDRESS, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for (;;);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Hello, OLED!");
  display.display();
}

void loop() {}

These snippets are versatile and can be directly integrated or modified for your projects. Each demonstrates a practical use of Arduino functionalities, from basic GPIO manipulation to interfacing with sensors and displays.

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor KitArduino Code

KY-032 Obstacle avoidance sensor module arduino example

by shedboy71
written by shedboy71

The KY-032 Obstacle avoidance sensor module returns a signal when it detects an object in range. The range of the sensor is around 2-40 cm is distance. The Obstacle Avoidance Sensors usually come in two types – with 3 and 4 pins. The 3 pin version does not have the ability to be enabled/disabled. The 4 pin version has optional Enable pin. Infrared obstacle avoidance sensor is designed to detect obstacles or the difference in reflective services.

ky032

ky032

One application is to help a wheeled robot avoid obstacles with a sensor to react to adjustable distance settings. This device has an infrared transmitter and receiver, that forms the sensor pair. The transmitter LED emits a certain frequency of infrared, which the receiver LED will detect. The receiving LED will detect some of the signal back and will trigger the digital on/off “signal” pin when a specific threshold “distance” has been detected. Most boards will have 2 potentiometers, one of which is to adjust how sensitive the sensor is.

You can use it to adjust the distance from the object at which the sensor detects it. Typically, the other potentiometer, which changes the transmitter IR frequency is not adjusted.

The module detects an obstacle [LED on the module: ON] [Sensor Signal= Digital Off]

This sensor allows you to activate and deactivate the obstacle detection by manipulating the enable pin (EN). It is activated by default which means that the sensor is in detection mode by default.
If you want to manually control the enable then you need to remove the jumper with the label “EN” and put a control signal on the en pin.

Parts List

Name Link
Arduino Uno UNO R3 CH340G/ATmega328P, compatible for Arduino UNO
Sensor kit 37 IN 1 SENSOR KITS FOR ARDUINO HIGH-QUALITY FREE SHIPPING (Works with Official for Arduino Boards)
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

 

Connection

This is the connections we used

KY-032 module Arduino connection
S D3
V+ +5V
G GND
en n/c
arduino and ky032 layout

arduino and ky032 layout

Code

[codesyntax lang=”cpp”]

int Sensor = 3; // Declaration of the sensor input pin
   
void setup ()
{
  Serial.begin(9600); // Initialization serial output
  pinMode (Sensor, INPUT) ; // Initialization sensor pin
}
   

void loop ()
{
  bool val = digitalRead (Sensor) ;
   
  if (val == HIGH) // If a signal is detected,
  {
    Serial.println("No obstacle");
  }
  else
  {
    Serial.println("Obstacle detected");
  }
  Serial.println("------------------------------------");
  delay(500); // Break of 500ms
}

[/codesyntax]

Output

Open the serial monitor and point the module at an object

Obstacle detected
————————————
Obstacle detected
————————————
No obstacle
————————————
No obstacle
————————————
Obstacle detected
————————————
Obstacle detected
————————————
No obstacle

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor KitArduino Code

KY-033 Hunt sensor module arduino example

by shedboy71
written by shedboy71

The KY-033 Hunt sensor module detects if a light reflecting or absorbing area is in front of it. This module uses an IR transmitter and receiver that will detect how reflective the surface is in front of the module. It has a potentiometer to adjust the sensitivity of the module so it can detect if the surface is black or white.

Operating voltage: 2.5V – 12V(cannot over 12V)
Working current: 18mA – 20mA at 5V
Output electrical level signal: low level when detecting objects / high level when no objects / 0 or 1 decides if objects exist

This behavior can be used to automatically follow a line with a robot and this is a very common application of this module

Parts List

Name Link
Arduino Uno UNO R3 CH340G/ATmega328P, compatible for Arduino UNO
Sensor kit 37 IN 1 SENSOR KITS FOR ARDUINO HIGH-QUALITY FREE SHIPPING (Works with Official for Arduino Boards)
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

 

Connection

This is the connections we used

Connect the module’s Power line (middle) and ground (G) to +5v and GND. Connect the signal pin (S) to pin 3 on the Arduino.

KY-033 module Arduino connection
S D3
V+ +5V
G GND

Code

[codesyntax lang=”cpp”]

int Sensor = 3; // sensor input pin
   
void setup ()
{
  Serial.begin(9600); // Initialize serial output
  pinMode (Sensor, INPUT) ;
}
   

void loop ()
{
  bool val = digitalRead (Sensor) ; // The current signal of the sensor will be read
   
  if (val == HIGH)
  {
    Serial.println("Line detected");
  }
  else
  {
    Serial.println("Line not detected");
  }
  Serial.println("------------------------------------");
  delay(500); // 
}

[/codesyntax]

Output

Open the serial monitor and move the IR tracker on and off a black mark, you should see something like this

Line not detected
————————————
Line not detected
————————————
Line not detected
————————————
Line detected
————————————
Line detected
————————————
Line detected
————————————
Line not detected
————————————

 

 

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor KitArduino Code

KY-009 RGB Full color LED SMD Module arduino example

by shedboy71
written by shedboy71

This is the KY-009 RGB Full color LED SMD Module.

This module has a 5050 surface mount RGB LED that can be used to create virtually any colour by varying the intensity of the 3 colours by using the PWM output. Resistors will be needed to connect to an Arduino.

Voltage :
Red 1.8 to 2.4VDC
Green 2.8 to 3.6VDC
Blue 2.8 to 3.6VDC

Parts List

Name Link
Arduino Uno UNO R3 CH340G/ATmega328P, compatible for Arduino UNO
Sensor kit 37 IN 1 SENSOR KITS FOR ARDUINO HIGH-QUALITY FREE SHIPPING (Works with Official for Arduino Boards)
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
resistor kit 600PCS Component Kit 1% 1/4W Resistor Pack

 

Connection

This is the connections we used for the LED to avoid potential damage

KY-009 module Resistor value Arduino connection
R 180Ω resistor Pin 11
G 110Ω resistor Pin 10
B 110Ω resistor Pin 9
– GND

Code

Example 1

[codesyntax lang=”cpp”]

int redpin = 11; 
int bluepin =10;
int greenpin =9;
 
int val;
 
void setup() 
{
  pinMode(redpin, OUTPUT);
  pinMode(bluepin, OUTPUT);
  pinMode(greenpin, OUTPUT);
  Serial.begin(9600);
}
 

void loop() 
{
  for(val=255; val>0; val--)
  {
   analogWrite(redpin, val);
   analogWrite(bluepin, 255-val);
   analogWrite(greenpin, 128-val);
   delay(1); 
  }
 
  for(val=0; val<255; val++)
  {
   analogWrite(redpin, val);
   analogWrite(bluepin, 255-val);
   analogWrite(greenpin, 128-val);
   delay(1); 
  }

}

[/codesyntax]

Example 2

[codesyntax lang=”cpp”]

int redpin = 11; 
int bluepin =10;
int greenpin =9;
  
void setup ()
{
  // Output pin initialization
  pinMode (redpin, OUTPUT); 
  pinMode (greenpin, OUTPUT);
  pinMode (bluepin, OUTPUT); 
}
  
void loop ()
{
  digitalWrite (redpin, HIGH);   // LED will be switched on
  digitalWrite (greenpin, LOW);  // LED will be switched off
  digitalWrite (bluepin, LOW);   // LED will be switched off
  delay (3000); // Wait for 3 seconds
  
  digitalWrite (redpin, LOW);    // LED will be switched off
  digitalWrite (greenpin, HIGH); // LED will be switched on
  digitalWrite (bluepin, LOW);   // LED will be switched off
  delay (3000); // Wait for 3 seconds
   
  digitalWrite (redpin, LOW);    // LED will be switched off 
  digitalWrite (greenpin, LOW);  // LED will be switched off 
  digitalWrite (bluepin, HIGH);  // LED will be switched on 
  delay (3000); // Waitfor 3 seconds
}

[/codesyntax]

 

 

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor KitArduino Code

KY-020 Tilt Switch Module arduino example

by shedboy71
written by shedboy71

The KY-020 Arduino tilt switch sensor module. The KY-020 is a metallic ball switch that will open/close the circuit depending on the angle its tilted at. It does not measure the angle.

KY-020 Tilt Switch Module

KY-020 Tilt Switch Module

What is a tilt switch?

A mercury switch is an electrical switch that opens and closes a circuit when a small amount of the liquid metal mercury connects metal electrodes to close the circuit. There are several different basic designs (tilt, displacement, radial, etc.) but they all share the common design strength of non-eroding switch contacts.

The most common is the mercury tilt switch. It is in one state (open or closed) when tilted one direction with respect to horizontal, and the other state when tilted the other direction. This is what older style thermostats used to turn a heater or air conditioner on or off.

Parts List

Name Link
Arduino Uno UNO R3 CH340G/ATmega328P, compatible for Arduino UNO
Sensor kit 37 IN 1 SENSOR KITS FOR ARDUINO HIGH-QUALITY FREE SHIPPING (Works with Official for Arduino Boards)
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

 

Connection

This is the connections we used

Connect the module’s Power line (middle) and ground (-) to +5v and GND. Connect the signal pin (S) to pin 2 on the Arduino.

KY-020 module Arduino connection
S D2
middle +5V
– GND
arduino and ky020 layout

arduino and ky020 layout

Code

We switch the on board LED on and off and also output text via the serial port

[codesyntax lang=”cpp”]

int tiltPin = 3;      // pin number for tilt switch 
int ledPin =  13;     // pin number of LED 
int tiltState = 0;

void setup() 
{ 
  Serial.begin(9600); 
  pinMode(ledPin, OUTPUT);  // set the LED pin as output      
  pinMode(tiltPin, INPUT);  // set the tilt switch pin as input
}

void loop()
{
  // read the tilt switch state
  tiltState = digitalRead(tiltPin);

  // check if the tilt switch is tilted.
  if (tiltState == HIGH) 
  {     
    digitalWrite(ledPin, HIGH);  
    Serial.println("switch is closed");
  } 
  else 
  {
    digitalWrite(ledPin, LOW); 
    Serial.println("switch is open");
  }
  delay(200);
}

[/codesyntax]

Output

Open the serial monitor and move the switch module

switch is closed
switch is closed
switch is closed
switch is closed
switch is open
switch is closed
switch is closed
switch is closed

 

 

0 comment
0 FacebookTwitterPinterestEmail
37 Sensor KitArduino Code

KY-025 Reed Switch Module and Arduino

by shedboy71
written by shedboy71

The KY-025 Reed Switch Module is a small electrical switch which operates with an applied magnetic field, the module can be used as proximity sensor.

KY-025 Reed Switch Module

KY-025 Reed Switch Module

The module has digital and analog outputs. A potentiometer is used to calibrate the sensitivity of the sensor for the analog output whereas the digital output is simply either 1 or 0 depending on whether the switch is open or closed, the digital mode is the easiest to use.

What is a reed switch?

The reed switch is an electrical switch operated by an applied magnetic field. It consists of a pair of contacts on ferromagnetic metal reeds in a hermetically sealed glass envelope. The contacts may be normally open, closing when a magnetic field is present, or normally closed and opening when a magnetic field is applied. The switch may be actuated by a coil, making a reed relay, or by bringing a magnet near the switch. Once the magnet is pulled away from the switch, the reed switch will go back to its original position.

An example of a reed switch’s application is to detect the opening of a door, when used as a proximity switch for a burglar alarm.

Parts List

Name Link
Arduino Uno UNO R3 CH340G/ATmega328P, compatible for Arduino UNO
Sensor kit 37 IN 1 SENSOR KITS FOR ARDUINO HIGH-QUALITY FREE SHIPPING (Works with Official for Arduino Boards)
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

 

Connection

This is the connections we used

Connect the board’s analog output (A0) to pin A0 on the Arduino and the digital output (D0) to pin 2. Connect the power line (+) and ground (G) to 5V and GND.

KY-025 module Arduino connection
A0 A0
G GND
+ 5V
D0 2

 

arduino and ky025 layout

arduino and ky025 layout

Code

Example 1

[codesyntax lang=”cpp”]

const int reedPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin
int reedState = 0;         // variable for reading the reed switch status
  
void setup() 
{
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);      
  // initialize the pushbutton pin as an input:
  pinMode(reedPin, INPUT);     
}
 
void loop()
{
  // read the state of the pushbutton value:
  reedState = digitalRead(reedPin);
  // check the reed switch is .
  // if it is, the buttonState is HIGH:
  if (reedState == HIGH) 
  {     
    // turn LED on:    
    digitalWrite(ledPin, HIGH);  
  } 
  else 
  {
    // turn LED off:
    digitalWrite(ledPin, LOW); 
  }
}

[/codesyntax]

Example 2

[codesyntax lang=”cpp”]

// Arduino pin numbers
//D2 and A0 used on board and connected to D0 and A0 on the module
//G ground
//+ 5V
//open arduino console - upload the code and watch the result
 
const int digital = 2;
const int analog = 0;
 
void setup()
{
pinMode(digital, INPUT);
Serial.begin(115200);
}
 
void loop()
{
Serial.print(digitalRead(digital));
Serial.print("-");
Serial.println(analogRead(analog));
delay(250);
}

[/codesyntax]

 

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts