Voltage = (ADC_value / 1023.0) * Reference_Voltage

int sensorPin = A0;  // Analog input pin
int sensorValue = 0; // Variable to store the value read

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

void loop() {
    sensorValue = analogRead(sensorPin);  // Read the analog value
    Serial.println(sensorValue);          // Print the value to the serial monitor
    delay(1000);                          // Delay for 1 second
}
        

analogReference(EXTERNAL); // Use an external reference voltage
        

analogReference(INTERNAL); // Use the internal 1.1V reference voltage
        

5V / 1024 = 4.88 mV
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * I2C Master Example
 * Sends a command to an I2C slave and receives a response.
 */

#include <Wire.h>

#define SLAVE_ADDR 8 // Address of the I2C slave device

byte i=0;

void setup() {
    // Initialize I2C as master
    Wire.begin();
    Serial.begin(115200);
    Serial.println("Arduino i2c example by Peter Ivan Dunne, ©2024, all rights reserved");
    Serial.println("Released under the Mozilla Public License");
    Serial.println("https://jazenga.com/educational");
    Serial.println("Purpose: to demonstrate use of i2c interface in master mode");
}

void loop() {
    // Request data from the slave
    Wire.beginTransmission(SLAVE_ADDR); // Start communication with slave
    Wire.write(i); // Send a command to the slave
    Wire.endTransmission(); // End communication

    // Request 1 byte of data from the slave
    Wire.requestFrom(SLAVE_ADDR, 1);
    Serial.print("Transmitted ");
    Serial.println(i);

    // Check if data is available
    if (Wire.available()) {
        byte receivedData = Wire.read(); // Read the received byte
        Serial.print("Received data: ");
        Serial.println(receivedData); // Print data to Serial Monitor
    }
    i++;
    delay(500); // Delay for 1 second
}
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * I2C Slave Example
 * Listens for commands from I2C master and responds with data.
 */

#include <Wire.h>

#define SLAVE_ADDR 8 // Address of the I2C slave device

void setup() {
    // Initialize I2C as slave
    Wire.begin(SLAVE_ADDR);
    Wire.onRequest(requestEvent); // Register request event
    Wire.onReceive(receiveEvent); // Register receive event
    Serial.begin(115200);
    Serial.println("Arduino i2c example by Peter Ivan Dunne, ©2024, all rights reserved");
    Serial.println("Released under the Mozilla Public License");
    Serial.println("https://jazenga.com/educational");
    Serial.println("Purpose: to demonstrate use of i2c interface in slave mode");
}
byte receivedData=0;
void loop() {
    // Main loop does nothing, communication is handled by interrupts
}

// Function called when master requests data
void requestEvent() {
    Wire.write(255-receivedData); // Send data to the master
}

// Function called when master sends data
void receiveEvent(int numBytes) {
    while (Wire.available()) {
        receivedData = Wire.read(); // Read data from master
        Serial.print("Received data: ");
        Serial.println(receivedData, HEX); // Print received data
    }
}
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * SPI Master Example
 * Sends data to SPI Slave and receives a response.
 */

#include <SPI.h>

byte dataToSend=0;

void setup() {
    SPI.begin();
    SPI.setClockDivider(SPI_CLOCK_DIV8);
    SPI.setDataMode(SPI_MODE0);
    SPI.setBitOrder(MSBFIRST);

    Serial.begin(115200);
    Serial.println("Arduino SPI example by Peter Ivan Dunne, ©2024, all rights reserved");
    Serial.println("Released under the Mozilla Public License");
    Serial.println("https://jazenga.com/educational");
    Serial.println("Purpose: to demonstrate use of SPI interface in master mode");
}

void loop() {
    digitalWrite(SS, LOW);
    ++dataToSend;
    byte receivedData = SPI.transfer(dataToSend);
    digitalWrite(SS, HIGH);

    Serial.print("Sent data: ");
    Serial.println(dataToSend);
    Serial.print("Received data: ");
    Serial.println(receivedData);
    delay(500);
}
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * SPI Slave Example
 * Receives data from SPI Master and sends a response.
 */

#include <SPI.h>

volatile byte receivedData = 0;
volatile byte dataToSend = 0;

void setup() {
    pinMode(MISO, OUTPUT);
    SPCR |= _BV(SPE);
    pinMode(SS, INPUT);
    pinMode(MOSI, INPUT);
    pinMode(SCK, INPUT);

    Serial.begin(115200);
    Serial.println("Arduino SPI example by Peter Ivan Dunne, ©2024, all rights reserved");
    Serial.println("Released under the Mozilla Public License");
    Serial.println("https://jazenga.com/educational");
    Serial.println("Purpose: to demonstrate use of SPI interface in slave mode");
}

void loop() {
    if (SPSR & _BV(SPIF)) {
        receivedData = SPDR;
        dataToSend = 255 - receivedData;
        SPDR = dataToSend;
    }

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

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Frequency Generation Example
 * Generates a 1 kHz square wave on pin 9 using Timer1.
 */

const int outputPin = 9; // Output pin

void setup() {
    pinMode(outputPin, OUTPUT); // Set output pin as an output

    // Configure Timer1 for 1 kHz frequency
    noInterrupts(); // Disable interrupts
    TCCR1A = 0; // Set Timer1 control register A to 0
    TCCR1B = 0; // Set Timer1 control register B to 0
    TCNT1  = 0; // Initialize counter value to 0

    // Set compare match register for 1 kHz frequency
    OCR1A = 999; // (16*10^6) / 1000 = 16000
                 // (16000/2/8=1000)
                 // 1000-1=999
    // Configure Timer1 for CTC mode and set prescaler to 8
    TCCR1B |= (1 << WGM12); // CTC mode
    TCCR1B |= (1 << CS11);  // Prescaler 8
    TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

    interrupts(); // Enable interrupts
}

void loop() {
    // Main loop does nothing, ISR handles frequency generation
}

// Interrupt Service Routine for Timer1 compare match
ISR(TIMER1_COMPA_vect) {
    digitalWrite(outputPin, !digitalRead(outputPin)); // Toggle pin state
}     
        

/*
* © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * PWM Generation Example
 * Generates a PWM signal with 50% duty cycle on pin 9 using Timer0.
 */

const int pwmPin = 9; // Pin for PWM output

void setup() {
    pinMode(pwmPin, OUTPUT); // Set PWM pin as output

    // Configure Timer0 for PWM mode
    analogWrite(pwmPin, 128); // 50% duty cycle (128 out of 255)
}

void loop() {
    // Main loop does nothing
}
        

/*
* © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * One-Shot Timer Example
 * Performs an action once after a 1-second delay using Timer1.
 */

const int ledPin = 13; // Pin connected to an LED
bool actionTriggered = false; // Flag to check if action is triggered

void setup() {
    pinMode(ledPin, OUTPUT); // Set LED pin as output

    // Configure Timer1 for 1-second delay
    noInterrupts(); // Disable interrupts
    TCCR1A = 0; // Set Timer1 control register A to 0
    TCCR1B = 0; // Set Timer1 control register B to 0
    TCNT1  = 0; // Initialize counter value to 0

    // Set compare match register for 1-second delay
    OCR1A = 15624; // (16*10^6) / (1024*1) - 1 = 15624

    // Configure Timer1 for CTC mode and set prescaler to 1024
    TCCR1B |= (1 << WGM12); // CTC mode
    TCCR1B |= (1 << CS12) | (1 << CS10); // Prescaler 1024
    TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

    interrupts(); // Enable interrupts
}

void loop() {
    if (actionTriggered) {
        digitalWrite(ledPin, HIGH); // Turn LED on
        delay(1000); // Wait for 1 second
        digitalWrite(ledPin, LOW); // Turn LED off
        actionTriggered = false; // Reset flag
    }
}

// Interrupt Service Routine for Timer1 compare match
ISR(TIMER1_COMPA_vect) {
    actionTriggered = true; // Set flag to trigger action
}
        

/*
* © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Frequency Measurement Example
 * Measures the frequency of an input signal on pin 2 using Timer1.
 */

const int inputPin = 2; // Pin connected to input signal
volatile unsigned long pulseCount = 0; // Count of pulses
unsigned long frequency = 0; // Frequency in Hz

void setup() {
    pinMode(inputPin, INPUT); // Set input pin as input

    // Configure Timer1 for frequency measurement
    noInterrupts(); // Disable interrupts
    TCCR1A = 0; // Set Timer1 control register A to 0
    TCCR1B = 0; // Set Timer1 control register B to 0
    TCNT1  = 0; // Initialize counter value to 0

    // Set compare match register for measurement period (1 second)
    OCR1A = 15624; // (16*10^6) / (1024*1) - 1 = 15624

    // Configure Timer1 for CTC mode and set prescaler to 1024
    TCCR1B |= (1 << WGM12); // CTC mode
    TCCR1B |= (1 << CS12) | (1 << CS10); // Prescaler 1024
    TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

    // Attach external interrupt to input pin
    attachInterrupt(digitalPinToInterrupt(inputPin), countPulses, RISING);

    // Initialize Serial Monitor
    Serial.begin(115200);
    interrupts(); // Enable interrupts
}

void loop() {
    // Print frequency once per second
    delay(1000);
    frequency = pulseCount; // Frequency in Hz
    pulseCount = 0; // Reset pulse count
    Serial.print("Frequency: ");
    Serial.print(frequency);
    Serial.println(" Hz");
}

// Interrupt Service Routine for Timer1 compare match
ISR(TIMER1_COMPA_vect) {
    // Timer interrupt; no action needed
}

// External Interrupt Service Routine to count pulses
void countPulses() {
    pulseCount++; // Increment pulse count
}
        

/*
* © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Externally Triggered Timer Pulse Example
 * Generates a pulse on pin 9 when an external trigger is detected on pin 2.
 */

const int triggerPin = 2; // Pin connected to external trigger
const int pulsePin = 9; // Pin for pulse output

void setup() {
    pinMode(triggerPin, INPUT); // Set trigger pin as input
    pinMode(pulsePin, OUTPUT); // Set pulse pin as output

    // Initialize Serial Monitor
    Serial.begin(115200);

    // Attach external interrupt to trigger pin
    attachInterrupt(digitalPinToInterrupt(triggerPin), triggerPulse, RISING);
}

void loop() {
    // Main loop does nothing
}

// External Interrupt Service Routine to trigger pulse
void triggerPulse() {
    digitalWrite(pulsePin, HIGH); // Set pulse pin high
    delay(10); // Pulse duration
    digitalWrite(pulsePin, LOW); // Set pulse pin low
    Serial.println("Pulse triggered");
}
        

/*
* © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Externally Triggered Time Measurement Example
 * Measures the time interval between two external triggers on pins 2 and 3.
 */

const int triggerPin1 = 2; // Pin connected to first external trigger
const int triggerPin2 = 3; // Pin connected to second external trigger
volatile unsigned long startTime = 0; // Start time
volatile unsigned long endTime = 0; // End time
volatile bool firstTrigger = false; // Flag for first trigger

void setup() {
    pinMode(triggerPin1, INPUT); // Set first trigger pin as input
    pinMode(triggerPin2, INPUT); // Set second trigger pin as input

    // Initialize Serial Monitor
    Serial.begin(115200);

    // Attach external interrupts to trigger pins
    attachInterrupt(digitalPinToInterrupt(triggerPin1), recordStartTime, RISING);
    attachInterrupt(digitalPinToInterrupt(triggerPin2), recordEndTime, RISING);
}

void loop() {
    if (firstTrigger && (endTime > startTime)) {
        unsigned long interval = endTime - startTime; // Time interval
        Serial.print("Time Interval: ");
        Serial.print(interval);
        Serial.println(" microseconds");
        firstTrigger = false; // Reset flag
    }
}

// External Interrupt Service Routine to record start time
void recordStartTime() {
    startTime = micros(); // Record start time
    firstTrigger = true; // Set flag for first trigger
}

// External Interrupt Service Routine to record end time
void recordEndTime() {
    endTime = micros(); // Record end time
}
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Arduino UNO PWM Example
 * Demonstrates how to use PWM and set a frequency of 25 kHz.
 */

const int pwmPin = 9; // PWM output pin

void setup() {
    pinMode(pwmPin, OUTPUT); // Set the PWM pin as an output

  // Stop Timer1
  TCCR1A = 0;  // Clear Timer/Counter Control Register A
  TCCR1B = 0;  // Clear Timer/Counter Control Register B

  // Set the PWM frequency to 25kHz
  // 16mhz/25000=640
  // Setting Prescaler to 1 and TOP to 640 gives us a 25kHz frequency
  TCCR1B |= _BV(WGM13) | _BV(WGM12);  // Set mode 14: Fast PWM with ICR1 as TOP
  TCCR1A |= _BV(WGM11);               // Set mode 14: Fast PWM
  TCCR1A |= _BV(COM1A1);              // Set non-inverting mode for pin 9

  ICR1 = 640;                         // Set TOP to 640 for 25kHz frequency
  OCR1A = 160;                        // Set PWM duty cycle to 25% duty cycle

  // Set prescaler to 1 (no prescaling)
  TCCR1B |= _BV(CS10);
}

void loop() {
    // Output a PWM signal with a 50% duty cycle
    analogWrite(pwmPin, 320); // 320 out of 640 corresponds to 50% duty cycle
    delay(1000); // Wait for 1 second

    // Change duty cycle
    analogWrite(pwmPin, 320); // 64 out of 640 corresponds to ~25% duty cycle
    delay(1000); // Wait for 1 second
}
        

void setup() {
  Serial.begin(115200);  // Initialize serial at 9600 baud
  while (!Serial);     // Wait for Serial (only needed on Leonardo, but safe)
  Serial.println("Hello from Arduino!");
}

void loop() {
  if (Serial.available()) {
    String input = Serial.readStringUntil('\n');
    Serial.print("You said: ");
    Serial.println(input);
  }
}
        

#include <Arduino.h>

struct DataPacket {
  bool status;
  byte level;
  int16_t value16;
  int32_t value32;
  float temperature;
  time_t timestamp;
  char label[16];
  uint8_t crc;
};

DataPacket packet;

uint8_t calculateCRC(uint8_t *data, size_t length) {
  uint8_t crc = 0;
  for (size_t i = 0; i < length; i++) {
    crc ^= data[i];
  }
  return crc;
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // Fill packet with test data
  packet.status = true;
  packet.level = 42;
  packet.value16 = -3276;
  packet.value32 = 12345678;
  packet.temperature = 25.7;
  packet.timestamp = now();
  strncpy(packet.label, "Node_A1", sizeof(packet.label));

  // Calculate CRC for all but last byte (crc itself)
  packet.crc = calculateCRC((uint8_t*)&packet, sizeof(packet) - 1);

  // Send the packet as binary
  Serial.write((uint8_t*)&packet, sizeof(packet));
}

void loop() {
  // Read structured data if available
  if (Serial.available() >= sizeof(DataPacket)) {
    DataPacket incoming;
    Serial.readBytes((char*)&incoming, sizeof(DataPacket));
    uint8_t calc = calculateCRC((uint8_t*)&incoming, sizeof(incoming) - 1);
    if (incoming.crc == calc) {
      Serial.print("Valid data: ");
      Serial.println(incoming.label);
    } else {
      Serial.println("CRC mismatch!");
    }
  }
}
        

/*
 * External Interrupt Example
 * Toggles an LED when a button connected to pin 2 is pressed.
 */

const int buttonPin = 2; // Pin connected to the button
const int ledPin = 13; // Pin connected to the LED

volatile bool ledState = LOW; // State of the LED (volatile as it is modified in ISR)

void setup() {
    pinMode(buttonPin, INPUT_PULLUP); // Set button pin as input with pull-up resistor
    pinMode(ledPin, OUTPUT); // Set LED pin as output

    // Attach interrupt to button pin
    attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING);

    // Initialize Serial Monitor
    Serial.begin(115200);
}

void loop() {
    // Main loop does nothing, ISR handles LED toggling
}

// Interrupt Service Routine to toggle LED
void toggleLED() {
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Update LED
    Serial.println("Button pressed, LED toggled");
}
        

/*
 * © 2024 Copyright Peter I. Dunne, all rights reserved
 * Prepared for educational use
 * Released under the Mozilla Public License
 * Timer interrupt example
 */

#include <avr/io.h>
#include <avr/interrupt.h>

void setup() {
  // Set pin 13 as output
  pinMode(13, OUTPUT);
  
  // Stop Timer1
  TCCR1A = 0; // Clear Timer/Counter Control Register A
  TCCR1B = 0; // Clear Timer/Counter Control Register B
  TCNT1 = 0;  // Initialize Timer1 counter to 0

  // Set CTC (Clear Timer on Compare Match) mode
  TCCR1B |= (1 << WGM12);

  // Set prescaler to 1024
  TCCR1B |= (1 << CS12) | (1 << CS10);

  // Set compare match register to trigger interrupt every 1 second
  // f_timer = 16 MHz / (1024 * (1 + 15624)) ≈ 1 Hz
  OCR1A = 15624;  // 16,000,000 / (1024 * 1Hz) - 1 = 15624

  // Enable Timer1 compare interrupt
  TIMSK1 |= (1 << OCIE1A);

  // Enable global interrupts
  sei();
}

void loop() {
  // Main loop does nothing, all work is done in ISR
}

// Timer1 interrupt service routine (ISR)
ISR(TIMER1_COMPA_vect) {
  // Toggle LED on pin 13
  digitalWrite(13, !digitalRead(13));
}
        

/*
 * Serial Interrupt Example
 * Responds to incoming serial data by echoing it back.
 */

const int ledPin = 13; // Pin connected to the LED

void setup() {
    pinMode(ledPin, OUTPUT); // Set LED pin as output

    // Initialize Serial Monitor
    Serial.begin(115200);
}

void loop() {
    // Check if data is available to read
    if (Serial.available() > 0) {
        char incomingByte = Serial.read(); // Read the incoming byte
        Serial.print("Received: ");
        Serial.println(incomingByte); // Echo received data back to Serial Monitor

        // Toggle LED as feedback
        digitalWrite(ledPin, HIGH);
        delay(100);
        digitalWrite(ledPin, LOW);
    }
}
        

/*
 * SPI Interrupt Example
 * Note: Direct SPI interrupt handling is generally managed by the Arduino core.
 * This example shows basic SPI communication.
 */

#include <SPI.h>

const int ledPin = 13; // Pin connected to the LED

void setup() {
    pinMode(ledPin, OUTPUT); // Set LED pin as output

    // Initialize SPI
    SPI.begin();
    SPI.setClockDivider(SPI_CLOCK_DIV8);

    // Initialize Serial Monitor
    Serial.begin(115200);
}

void loop() {
    // Basic SPI communication example
    digitalWrite(ledPin, HIGH);
    byte response = SPI.transfer(0x42); // Send a byte and receive a response
    Serial.print("SPI Response: ");
    Serial.println(response, HEX); // Print SPI response
    digitalWrite(ledPin, LOW);
    delay(1000); // Delay for 1 second
}
        

/*
 * I2C Interrupt Example
 * Note: Direct I2C interrupt handling is managed by the Arduino core library.
 * This example demonstrates basic I2C communication.
 */

#include <Wire.h>

const int ledPin = 13; // Pin connected to the LED

void setup() {
    pinMode(ledPin, OUTPUT); // Set LED pin as output

    // Initialize I2C
    Wire.begin();
    Wire.beginTransmission(0x08); // Address of the I2C device
    Wire.write("Hello I2C");
    Wire.endTransmission();

    // Initialize Serial Monitor
    Serial.begin(115200);
}

void loop() {
    // Basic I2C communication example
    digitalWrite(ledPin, HIGH);
    Serial.println("I2C message sent.");
    digitalWrite(ledPin, LOW);
    delay(1000); // Delay for 1 second
}
        

#include <avr/io.h>
#include <avr/interrupt.h>

volatile uint16_t adcValue = 0;  // Variable to store ADC result

void setup() {
  // Set up serial communication for debugging (optional)
  Serial.begin(115200);

  // Configure the ADC
  ADMUX = (1 << REFS0);  // Set reference voltage to AVcc (5V), input to ADC0 (A0)

  ADCSRA = (1 << ADEN);  // Enable the ADC
  ADCSRA |= (1 << ADIE); // Enable ADC interrupt
  ADCSRA |= (1 << ADPS2) | (1 << ADPS1); // Set ADC prescaler to 64 (16MHz/64 = 250kHz)

  // Start the first ADC conversion
  ADCSRA |= (1 << ADSC);

  // Enable global interrupts
  sei();
}

void loop() {
  // Main loop does nothing, all work is handled in the ISR
  // Optionally, print the ADC value for debugging
  Serial.println(adcValue);
  delay(500);  // Slow down the serial output for readability
}

// ADC Conversion Complete Interrupt Service Routine
ISR(ADC_vect) {
  // Read the 10-bit ADC result (ADCL must be read first)
  adcValue = ADC;

  // Start a new ADC conversion
  ADCSRA |= (1 << ADSC);
}
        

// Pin definitions
const int encoderPinA = 2;  // Pin for encoder A (interrupt pin)
const int encoderPinB = 3;  // Pin for encoder B

volatile long encoderPosition = 0;  // Variable to store the position of the encoder
volatile int lastState = 0;         // Store previous state of encoder pin A

void setup() {
  pinMode(encoderPinA, INPUT);
  pinMode(encoderPinB, INPUT);

  // Enable pull-up resistors
  digitalWrite(encoderPinA, HIGH);
  digitalWrite(encoderPinB, HIGH);

  // Attach interrupt to encoderPinA (Interrupt 0)
  attachInterrupt(digitalPinToInterrupt(encoderPinA), updateEncoder, CHANGE);

  // Start serial communication for debugging
  Serial.begin(115200);
}

void loop() {
  // Print the current position of the encoder
  Serial.print("Encoder Position: ");
  Serial.println(encoderPosition);
  delay(100);
}

// Interrupt Service Routine (ISR)
void updateEncoder() {
  int currentStateA = digitalRead(encoderPinA);  // Read current state of pin A
  int stateB = digitalRead(encoderPinB);         // Read current state of pin B

  // If the state of A has changed
  if (currentStateA != lastState) {
    // Check the direction based on state of B
    if (stateB != currentStateA) {
      encoderPosition++;
    } else {
      encoderPosition--;
    }
    lastState = currentStateA;  // Update the last state of A
  }
}