# 1. Mount the flashed boot partition locally (e.g. /media/boot/)
cd /media/boot/
 
# 2. Enable SSH daemon on first boot by writing an empty trigger file
touch ssh
 
# 3. Configure Wi-Fi credentials pre-boot by creating a configuration file
# File: wpa_supplicant.conf
# ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
# update_config=1
# country=US
# network={
#     ssid="Enterprise-Network"
#     psk="SecureWiFiPassword123"
# }

# 1. Launch raspi-config in non-interactive CLI mode to enable read-only system
sudo raspi-config nonint do_overlayfs 1
 
# 2. Re-mount the boot partition as read-only manually inside fstab
# Edit /etc/fstab to verify mount configurations:
# /dev/mmcblk0p1  /boot  vfat  ro,defaults  0  2
# /dev/mmcblk0p2  /      ext4  ro,defaults,noatime  0  1

# 1. Update the APT package database cache
sudo apt update
 
# 2. Upgrade all system packages and kernels
sudo apt dist-upgrade -y
 
# 3. Update the firmware on the onboard EEPROM (for Pi 4 and Pi 5 models)
sudo rpi-eeprom-update -a
 
# 4. Reboot system to apply changes
sudo reboot

# 1. Read current active EEPROM configuration settings
vcgencmd bootloader_config
 
# 2. Extract configuration to a text template file for modification
sudo rpi-eeprom-config --get > boot_config.txt
 
# 3. View extracted config variables:
# BOOT_ORDER=0xf41                 # Boot priority sequence (Try SD card first, then USB mass storage)
# POWER_OFF_ON_HALT=1              # Shut off power rails to external USB ports when system halts
# PCIE_PROBE=1                     # Automatically detect and initialize PCIe devices (NVMe) at boot
 
# 4. Apply the modified text parameters back to the EEPROM
sudo rpi-eeprom-config --apply boot_config.txt

# Add the following parameters to the single-line boot config '/boot/firmware/cmdline.txt':
console=serial0,115250 console=tty1 root=/dev/nfs nfsroot=192.168.1.10:/srv/nfs/rpi1,vers=3 rw ip=dhcp rootwait

# File: /boot/firmware/config.txt
 
# Enable hardware interfaces
dtparam=i2c_arm=on
dtparam=spi=on
 
# Enable hardware audio output
dtparam=audio=on
 
# Allocate 128 MB of RAM to the GPU (preserved for camera structures)
gpu_mem=128
 
# Load a custom Device Tree Overlay (e.g. w1-gpio for 1-Wire DS18B20 temperature sensors)
dtoverlay=w1-gpio,gpiopin=4
 
# Enable hardware serial console port
enable_uart=1

# 1. Install the device tree compiler utility
sudo apt install -y device-tree-compiler
 
# 2. Compile a custom Device Tree Source overlay file into binary format
dtc -@ -I dts -O dtb -o custom_led.dtbo custom_led.dts
 
# 3. Copy the compiled binary overlay to system overlays directory
sudo cp custom_led.dtbo /boot/firmware/overlays/

/dts-v1/;
/plugin/;
 
/ {
    compatible = "brcm,bcm2835";
 
    fragment@0 {
        target = <&gpio>;
        __overlay__ {
            custom_led_pins: custom_led_pins {
                brcm,pins = <17>;     /* Using GPIO pin 17 */
                brcm,function = <1>;  /* Configure as output (GPIO_OUT) */
                brcm,pull = <0>;      /* Disable internal pull-ups/pull-downs */
            };
        };
    };
 
    fragment@1 {
        target = <&leds>;
        __overlay__ {
            status_led: status_led {
                label = "custom:status:led";
                gpios = <&gpio 17 0>; /* Active high */
                default-state = "keep";
                linux,default-trigger = "heartbeat"; /* Set kernel heartbeat pulse pattern */
            };
        };
    };
};

pwd                        # Display path of active folder
ls -lha                    # List files in verbose table showing size metric and hidden files
cd /boot/firmware/         # Change active folder location
mkdir -p /srv/backup/      # Create nested folders
touch /tmp/rpi.lock        # Create empty file or update access timestamp
cp -a /etc/ /srv/backup/   # Copy directory recursively, preserving permissions
mv file.txt new_file.txt   # Rename or move file
rm -rf /tmp/test/          # Delete files and directories recursively
ln -s /etc/hosts local_lnk # Create symbolic link to target file
find /etc/ -name "*.conf"  # Find files matching name mask under directory tree
locate wpa_supplicant      # Find files quickly using prebuilt system database
cat /etc/os-release        # Display file contents
head -n 10 /var/log/syslog # Output first 10 lines of a file
tail -f /var/log/syslog    # Output and monitor new entries in real-time
grep -rn "error" /var/log/ # Search recursively for string pattern showing line numbers
wc -l /etc/passwd          # Count lines in a file
file /boot/firmware/start.elf # Display file format description and target architecture
stat /boot/firmware/config.txt # View file permissions, owner, and modification timestamps
diff old.conf new.conf     # Compare text file structures and output line modifications

tar -cvzf backup.tar.gz /etc/  # Create compressed gzip archive of directory
tar -xvzf backup.tar.gz -C /tmp/ # Extract gzip archive contents to target path
tar -cvjf backup.tar.bz2 /var/log/ # Create bzip2 compressed archive
tar -xvjf backup.tar.bz2 -C /tmp/  # Extract bzip2 archive contents
zip -r files.zip /home/pi/     # Create compressed zip archive
unzip files.zip -d /tmp/       # Extract zip file contents
gzip large.log                 # Compress file directly, replacing it with .gz format
gunzip large.log.gz            # Decompress .gz file back to standard log format

ps aux                     # Display all running processes on the system
top -d 2                   # Print active process resource usage statistics every 2 seconds
htop                       # Launch interactive process monitoring console (requires installation)
pgrep -u root systemd      # Print PIDs of systemd processes owned by root
kill -15 1024              # Send SIGTERM signal to PID 1024 to terminate gracefully
kill -9 1024               # Send SIGKILL signal to PID 1024 to terminate immediately
pkill -u debian            # Terminate all active processes owned by user account
killall python3            # Kill all instances of python3 processes
jobs                       # List background jobs
bg %1                      # Resume suspended job 1 in background
fg %1                      # Bring background job 1 to foreground
nohup python3 monitor.py & # Run process in background, ignoring hangup signals
ulimit -n                  # Display maximum open file descriptors threshold
nice -n 10 backup.sh       # Start process with lower priority nice value
renice +5 -p 2045          # Modify priority level of active PID 2045 process

uname -a                   # Output kernel release, OS name, and architecture
lshw -short                # Print brief hardware configuration details
lspci                      # List PCI devices (requires USB PCIe controller)
lsusb                      # List USB buses and connected hardware
df -h                      # Output disk space metrics in human-readable format
du -sh /var/log/           # Summarize disk usage of target directory
free -h                    # Show RAM and swap metrics
uptime                     # Print system running time and average CPU loads
journalctl -xe             # Show systemd journal logs
dmesg | grep -i gpio       # Print kernel ring buffer messages filtered by search term
lsmod                      # List loaded kernel module drivers
modinfo w1-gpio            # Display information about kernel module details
lscpu                      # View CPU cores and architecture descriptors
lsblk                      # Display disk partition structures and UUID layouts

ip addr show dev eth0      # Display active IP configuration for eth0 interface
ping -c 3 google.com       # Send ICMP echo packets to verify remote host connectivity
ss -tulnp                  # Show active TCP and UDP sockets with owning process details
traceroute 8.8.8.8         # Display hop paths to destination host
curl -I https://raspberrypi.org # Fetch HTTP headers of target site
wget https://site.com/file # Download file
dig google.com             # Perform DNS record queries
nslookup google.com        # Query internet name servers for IP mapping
hostnamectl                # Display active hostnames and architecture details
ip route show              # Print active system routing path configurations
ip neigh show              # Display ARP mapping table records
netstat -i                 # Print network interface packets statistics

chmod 755 script.sh        # Set owner (rwx), group (r-x), and others (r-x) permissions
chown -R pi:pi /home/pi/   # Assign file ownership recursively
su - administrator         # Log in to administrator user session
sudo -i                    # Escalate terminal session to superuser (root) configuration
visudo                     # Safely edit system sudoers rules file
useradd -m -s /bin/bash usr# Create new user account with home folder and bash shell
userdel -r usr             # Delete user account, home folder, and mail spool
id pi                      # Print user and group IDs (UID/GID) for account
w                          # Display logged in users and their active command sessions
last                       # View history of user login and system reboot records

# Launch the interactive configuration interface
sudo raspi-config
 
# Run configuration actions non-interactively via CLI (e.g. enable I2C bus)
sudo raspi-config nonint do_i2c 0

# 1. Read the onboard CPU core temperature
vcgencmd measure_temp
# Output: temp=48.2'C
 
# 2. Monitor real-time CPU voltage configuration
vcgencmd measure_volts core
# Output: volt=0.8560V
 
# 3. Read active CPU core frequency
vcgencmd measure_clock arm
# Output: frequency(48)=1500345728 (1.5 GHz)
 
# 4. Check for system throttling events (e.g., under-voltage or over-temperature)
vcgencmd get_throttled
# Returns a hex bitmask. 0x0 means normal operations; 0x50005 indicates active under-voltage.

# Print the active board layout and pins schema
pinout

# Set standard execute permissions (rwxr-xr-x)
chmod 755 /usr/local/bin/sensor_logger

# 1. View active shell umask value (e.g. 0022)
umask
 
# 2. Configure a restrictive umask where new files are readable only by the owner
umask 0077
# New files: 600 (rw-------), New directories: 700 (rwx------)
 
# 3. Configure umask in ~/.bashrc to make it persistent across logins
echo "umask 0027" >> ~/.bashrc
# New files: 640 (rw-r-----), New directories: 750 (rwar-x---)

# 1. View active ACL rules on target log file
getfacl /var/log/gpio_events.log
 
# 2. Grant read/write access to user 'developer' without changing file owner
sudo setfacl -m u:developer:rw /var/log/gpio_events.log
 
# 3. Remove all custom ACL permissions from the file
sudo setfacl -b /var/log/gpio_events.log
 
# 4. Configure default ACLs on a directory so new files inherit permissions automatically
sudo setfacl -d -m g:video:rx /srv/camera_captures/

# Apply SUID to helper binaries
sudo chmod u+s /usr/local/bin/hardware_helper
 
# Apply SGID to shared developers folders
sudo chmod g+s /srv/projects/
 
# Set sticky bit on temporary folders
sudo chmod +t /srv/tmp/

# Redirect stdout to file (overwrite)
vcgencmd measure_temp > /tmp/temp.txt
 
# Append stdout to file
echo "Pi system backup complete" >> /var/log/rpi_backup.log
 
# Redirect stderr (standard error) to file
sudo apt update 2> /tmp/apt-errors.log
 
# Redirect both stdout and stderr to the same file
python3 sensor.py &> /var/log/sensor-run.log
 
# Discard errors by redirecting to dev null
find / -name "config.txt" 2> /dev/null
 
# Pipe stdout as input to another command
ss -tulnp | grep ":22" | awk '{print $5}'

#!/bin/bash
# ==============================================================================
# Script: temp_alert.sh
# Description: Monitors CPU temperature, logs alerts on spikes, throttles fan paths.
# Author: VR-Rathod
# ==============================================================================
 
LOG_FILE="/var/log/rpi_temp_monitor.log"
LIMIT_TEMP=75.0
 
log_event() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$1] - $2" >> "$LOG_FILE"
}
 
log_event "INFO" "Starting temperature monitor daemon..."
 
# Read real-time temperature using vcgencmd
RAW_TEMP=$(vcgencmd measure_temp | awk -F'=' '{print $2}' | sed "s/'C//")
 
# Compare temperature limits using bash comparisons
if (( $(echo "$RAW_TEMP >= $LIMIT_TEMP" | bc -l) )); then
    log_event "CRITICAL" "High CPU temperature detected: $RAW_TEMP'C!"
    # Trigger system warning indicators or shut down processes
else
    log_event "INFO" "CPU temperature stable at: $RAW_TEMP'C."
fi
 
exit 0

#!/bin/bash
# ==============================================================================
# Script: config_backup.sh
# Description: Packages configuration files, outputs target logs, pushes off-site.
# Author: VR-Rathod
# ==============================================================================
 
BACKUP_DIR="/var/backups/rpi_system"
REMOTE_SERVER="backup.local"
REMOTE_USER="pi_backup"
 
mkdir -p "$BACKUP_DIR"
FILE_NAME="rpi_configs_$(date '+%Y%m%d_%H%M%S').tar.gz"
 
# Package system network interfaces and configurations
tar -czf "$BACKUP_DIR/$FILE_NAME" /boot/firmware/config.txt /etc/wpa_supplicant/ /etc/NetworkManager/
 
if [ -f "$BACKUP_DIR/$FILE_NAME" ]; then
    echo "Backup package created successfully: $FILE_NAME"
    # Push to backup server (requires SSH keys pre-shared)
    # scp "$BACKUP_DIR/$FILE_NAME" "$REMOTE_USER@$REMOTE_SERVER:/volume/backup/"
else
    echo "Error: Backup compilation failed."
    exit 1
fi
 
exit 0

#!/bin/bash
# ==============================================================================
# Script: gpio_logger.sh
# Description: Monitor GPIO pin state changes and log timestamp events.
# Author: VR-Rathod
# ==============================================================================
 
GPIO_PIN=17
EVENT_LOG="/var/log/gpio_events.log"
 
# Export GPIO pin if using sysfs (legacy interface compatibility)
if [ ! -d "/sys/class/gpio/gpio$GPIO_PIN" ]; then
    echo "$GPIO_PIN" > /sys/class/gpio/export
fi
 
echo "in" > "/sys/class/gpio/gpio$GPIO_PIN/direction"
 
echo "Monitoring state changes on GPIO $GPIO_PIN..."
LAST_STATE=$(cat "/sys/class/gpio/gpio$GPIO_PIN/value")
 
while true; do
    CURRENT_STATE=$(cat "/sys/class/gpio/gpio$GPIO_PIN/value")
    if [ "$CURRENT_STATE" -ne "$LAST_STATE" ]; then
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] GPIO $GPIO_PIN state changed: $LAST_STATE -> $CURRENT_STATE" >> "$EVENT_LOG"
        LAST_STATE=$CURRENT_STATE
    fi
    sleep 0.1
done

#!/bin/bash
# ==============================================================================
# Script: fan_controller.sh
# Description: Toggle fan relay on pin 18 based on system temperatures.
# Author: VR-Rathod
# ==============================================================================
 
FAN_PIN=18
TEMP_THRESHOLD=60.0
 
# Export pin
if [ ! -d "/sys/class/gpio/gpio$FAN_PIN" ]; then
    echo "$FAN_PIN" > /sys/class/gpio/export
fi
echo "out" > "/sys/class/gpio/gpio$FAN_PIN/direction"
 
while true; do
    TEMP=$(vcgencmd measure_temp | awk -F'=' '{print $2}' | sed "s/'C//")
    if (( $(echo "$TEMP > $TEMP_THRESHOLD" | bc -l) )); then
        # Enable Fan
        echo "1" > "/sys/class/gpio/gpio$FAN_PIN/value"
    else
        # Disable Fan
        echo "0" > "/sys/class/gpio/gpio$FAN_PIN/value"
    fi
    sleep 5
done

#!/bin/bash
# ==============================================================================
# Script: gpio_debounce.sh
# Description: Monitors GPIO 23, filters spikes occurring within a 150ms bounce window.
# Author: VR-Rathod
# ==============================================================================
 
PIN=23
DEBOUNCE_MS=150
LAST_TRIGGER_TIME=0
 
# Export pin
if [ ! -d "/sys/class/gpio/gpio$PIN" ]; then
    echo "$PIN" > /sys/class/gpio/export
fi
echo "in" > "/sys/class/gpio/gpio$PIN/direction"
 
echo "Starting software bounce filter on pin $PIN..."
 
while true; do
    VALUE=$(cat "/sys/class/gpio/gpio$PIN/value")
    if [ "$VALUE" -eq 0 ]; then
        CURRENT_TIME=$(date +%s%3N) # Get epoch milliseconds
        DIFF=$((CURRENT_TIME - LAST_TRIGGER_TIME))
        
        if [ "$DIFF" -gt "$DEBOUNCE_MS" ]; then
            echo "[$(date '+%H:%M:%S')] [GPIO EVENT] Valid transition detected on Pin $PIN!"
            LAST_TRIGGER_TIME=$CURRENT_TIME
        fi
    fi
    sleep 0.05
done

#!/bin/bash
# ==============================================================================
# Script: throttle_logger.sh
# Description: Reads throttled register bitmasks, decodes flags, writes logs.
# Author: VR-Rathod
# ==============================================================================
 
LOG_FILE="/var/log/rpi_throttle.log"
 
log_event() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}
 
HEX_MASK=$(vcgencmd get_throttled | awk -F'=' '{print $2}')
VAL=$((HEX_MASK))
 
if [ "$VAL" -ne 0 ]; then
    [ $((VAL & 0x1)) -ne 0 ] && log_event "WARNING: Under-voltage active!"
    [ $((VAL & 0x2)) -ne 0 ] && log_event "WARNING: ARM frequency capped (active)!"
    [ $((VAL & 0x4)) -ne 0 ] && log_event "WARNING: Throttling active!"
    [ $((VAL & 0x10000)) -ne 0 ] && log_event "NOTICE: Under-voltage occurred since last boot."
    [ $((VAL & 0x20000)) -ne 0 ] && log_event "NOTICE: Frequency capped occurred since last boot."
    [ $((VAL & 0x40000)) -ne 0 ] && log_event "NOTICE: Throttling occurred since last boot."
fi

# Create new user account with home folder and bash shell
sudo useradd -m -s /bin/bash -c "System Developer" developer
 
# Set or modify the user password
sudo passwd developer
 
# Add user to the default administration group 'sudo' (allows escalations)
sudo usermod -aG sudo developer
 
# Lock account logins
sudo usermod -L developer
 
# Unlock account logins
sudo usermod -U developer
 
# Delete account completely, wiping home directory
sudo userdel -r developer

# Add user 'developer' to hardware groups
sudo usermod -aG gpio,i2c,spi,video developer

# Launch Visudo safely
sudo visudo
 
# Restrict password-free execution loops:
# Allow members of group 'sudo' to run any command with passwords
# %sudo ALL=(ALL:ALL) ALL

# Display active Raspberry Pi repository endpoints
cat /etc/apt/sources.list.d/raspi.list
# Output: deb http://archive.raspberrypi.org/debian/ bookworm main

# 1. Create a secure directory to store third-party GPG keyring signatures
sudo mkdir -p /etc/apt/keyrings
 
# 2. Download and import the official Docker repository GPG signing key
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 
# 3. Add the Docker repository source to the APT configuration directory
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 
# 4. Refresh local caches and install the Docker community edition engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

# 1. Update the local package index tables
sudo apt update
 
# 2. Upgrade all installed packages to their latest versions
sudo apt upgrade -y
 
# 3. Perform a full system distribution upgrade (resolves complex dependencies)
sudo apt dist-upgrade -y
 
# 4. Search for a package matching a query
apt-cache search python3-gpiozero
 
# 5. Show details about a package
apt-cache show python3-gpiozero
 
# 6. Install a new package
sudo apt install -y python3-gpiozero
 
# 7. Remove a package but preserve user configuration files
sudo apt remove python3-gpiozero -y
 
# 8. Remove a package and purge all associated configuration files
sudo apt purge python3-gpiozero -y
 
# 9. Clean residual dependencies that are no longer needed
sudo apt autoremove -y
 
# 10. Clean downloaded .deb package archives from local cache
sudo apt clean

# 1. Install the caching proxy server on the master node
sudo apt install -y apt-cacher-ng
 
# 2. Configure clients to route package updates through the master proxy node
# File: /etc/apt/apt.conf.d/01proxy
# Acquire::http::Proxy "http://192.168.1.50:3142";

# 1. List active network connection profiles
nmcli connection show
 
# 2. Scan for nearby Wi-Fi access points
nmcli device wifi list
 
# 3. Connect to a Wi-Fi network
sudo nmcli device wifi connect "SSID_NAME" password "WIFI_PASSWORD"
 
# 4. Configure a static IP on eth0 interface
sudo nmcli connection modify eth0 ipv4.addresses 192.168.1.150/24 ipv4.gateway 192.168.1.1 ipv4.method manual
 
# 5. Apply static IP modifications
sudo nmcli connection up eth0

# Edit configuration
sudo nano /etc/ssh/sshd_config
 
# Key parameters to harden:
# Port 2200                  # Change default port to prevent automated scanners
# PermitRootLogin no         # Block root login; enforce privilege escalation via sudo
# PasswordAuthentication no   # Disable password logins; enforce SSH key authentication
# AllowUsers developer       # Restrict login access to specific accounts
# MaxAuthTries 3             # Terminate connection after 3 failed login attempts
 
# Enforce Client Alive heartbeat checks to auto-disconnect inactive sessions
# ClientAliveInterval 300
# ClientAliveCountMax 2
 
# Restart the SSH service
sudo systemctl restart ssh

# 1. Install UFW
sudo apt install -y ufw
 
# 2. Configure default blocking policies
sudo ufw default deny incoming
sudo ufw default allow outgoing
 
# 3. Allow custom hardened SSH port
sudo ufw allow 2200/tcp
 
# 4. Allow specific service ports (e.g., HTTP server)
sudo ufw allow 80/tcp
 
# 5. Enable the firewall rules immediately
sudo ufw enable
 
# 6. Verify active rules and status
sudo ufw status verbose

# File: led_blink.py
from gpiozero import LED, Button
from time import sleep
from signal import pause
 
# Initialize hardware pins
led = LED(17)       # Connected to GPIO pin 17
button = Button(2)  # Connected to GPIO pin 2
 
# Define button trigger functions
def toggle_led():
    led.toggle()
    print("Button pressed! LED state changed.")
 
# Assign callbacks for button events
button.when_pressed = toggle_led
 
print("Sensor loop active. Press the button to toggle the LED...")
pause()  # Keep script running to receive event interrupts

# File: interrupt_poll.py
import RPi.GPIO as GPIO
from time import sleep
 
# Configure pin numbering scheme (BCM mappings)
GPIO.setmode(GPIO.BCM)
INPUT_PIN = 27
 
# Initialize input pin with internal pull-up resistor
GPIO.setup(INPUT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 
# Define the interrupt callback function
def edge_detected_callback(channel):
    print(f"Edge transition detected on hardware channel: {channel}")
 
# Configure falling edge detection with a 200ms software bounce filter
GPIO.add_event_detect(INPUT_PIN, GPIO.FALLING, callback=edge_detected_callback, bouncetime=200)
 
try:
    print("Awaiting hardware edge transitions...")
    while True:
        sleep(1)
except KeyboardInterrupt:
    print("Cleaning hardware registers...")
finally:
    GPIO.cleanup()  # Reset pin configurations

# 1. Export GPIO pin 17 to user space
echo "17" > /sys/class/gpio/export
 
# 2. Configure pin direction to output
echo "out" > /sys/class/gpio/gpio17/direction
 
# 3. Set output state to high (3.3V)
echo "1" > /sys/class/gpio/gpio17/value
 
# 4. Set output state to low (0V)
echo "0" > /sys/class/gpio/gpio17/value
 
# 5. Unexport the pin when finished
echo "17" > /sys/class/gpio/unexport

# 1. Install gpiod CLI tools
sudo apt install -y gpiod
 
# 2. Scan and list available GPIO controllers on the board
gpiodetect
# Output: gpiochip0 [BCM2835] (54 lines)
 
# 3. Read the state of GPIO pin 17
gpioget gpiochip0 17
# Output: 0
 
# 4. Set the state of GPIO pin 17 to high (3.3V)
gpioset gpiochip0 17=1

# Scan the primary I2C bus (bus 1) for active devices
sudo i2cdetect -y 1
# Output showing 0x68 indicates MPU6050 address detected.

# File: read_i2c.py
import smbus2
import time
 
# Initialize I2C bus 1
bus = smbus2.SMBus(1)
DEVICE_ADDR = 0x68  # Target device address
 
# Register address definitions
PWR_MGMT_1 = 0x6b
ACCEL_XOUT_H = 0x3b
 
# Wake up the sensor (write 0 to the power management register)
bus.write_byte_data(DEVICE_ADDR, PWR_MGMT_1, 0)
 
def read_raw_data(addr):
    # High and Low byte register buffer reads
    high = bus.read_byte_data(DEVICE_ADDR, addr)
    low = bus.read_byte_data(DEVICE_ADDR, addr + 1)
    # Combine bytes (shift high byte and OR low byte)
    value = (high << 8) | low
    # Convert unsigned 16-bit to signed 16-bit value
    if value > 32767:
        value -= 65536
    return value
 
try:
    while True:
        x_val = read_raw_data(ACCEL_XOUT_H)
        print(f"X-Axis Raw Accelerometer Value: {x_val}")
        time.sleep(0.5)
except KeyboardInterrupt:
    print("Closing bus connections.")

# File: read_bmp280.py
import smbus2
import time
 
bus = smbus2.SMBus(1)
BMP_ADDR = 0x76  # Default BMP280 address
 
# Register map definitions
REG_ID = 0xD0
REG_RESET = 0xE0
REG_CTRL_MEAS = 0xF4
REG_CONFIG = 0xF5
REG_TEMP_MSB = 0xFA
 
# Read sensor ID to verify connection
chip_id = bus.read_byte_data(BMP_ADDR, REG_ID)
print(f"BMP280 Chip Verification ID: {hex(chip_id)}")
 
# Configure control measurement: normal mode, temp oversampling x1, press oversampling x1
bus.write_byte_data(BMP_ADDR, REG_CTRL_MEAS, 0x27)
# Configure config register: standby 0.5ms, filter off
bus.write_byte_data(BMP_ADDR, REG_CONFIG, 0x00)
 
# Read calibration arrays (trimming parameters)
dig_T1 = (bus.read_byte_data(BMP_ADDR, 0x89) << 8) | bus.read_byte_data(BMP_ADDR, 0x88)
dig_T2 = (bus.read_byte_data(BMP_ADDR, 0x8B) << 8) | bus.read_byte_data(BMP_ADDR, 0x8A)
# Convert to signed 16-bit
if dig_T2 > 32767: dig_T2 -= 65536
dig_T3 = (bus.read_byte_data(BMP_ADDR, 0x8D) << 8) | bus.read_byte_data(BMP_ADDR, 0x8C)
if dig_T3 > 32767: dig_T3 -= 65536
 
def read_temperature():
    # Read 3-byte temperature registers
    data = bus.read_i2c_block_data(BMP_ADDR, REG_TEMP_MSB, 3)
    adc_T = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)
    
    # Apply official Bosch compensation formula
    var1 = (adc_T / 16384.0 - dig_T1 / 1024.0) * dig_T2
    var2 = ((adc_T / 131072.0 - dig_T1 / 8192.0) * (adc_T / 131072.0 - dig_T1 / 8192.0)) * dig_T3
    t_fine = var1 + var2
    temp = t_fine / 5120.0
    return temp
 
try:
    while True:
        temperature = read_temperature()
        print(f"Calculated Temperature: {temperature:.2f} 'C")
        time.sleep(1)
except KeyboardInterrupt:
    print("BMP280 Reading terminated.")

# 1. Load the custom led overlay binary dynamically at runtime
sudo dtoverlay custom_led.dtbo
 
# 2. List all active overlays loaded dynamically at runtime
dtoverlay -l
 
# 3. Unload a dynamically loaded overlay by its index identifier
sudo dtoverlay -R 0

# File: read_spi_adc.py
import spidev
import time
 
# Initialize SPI on bus 0, device (CE) 0
spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 1350000 # 1.35 MHz clock rate
 
def read_adc(channel):
    # Ensure channel index is within valid bounds (0-7)
    if channel < 0 or channel > 7:
        return -1
    
    # Construct MCP3008 request buffer bytes:
    # Byte 0: Start bit (0x01)
    # Byte 1: Single-ended configuration bit, channel ID shifted into high nibble
    # Byte 2: Don't care byte (0x00) for receiving remaining data bits
    resp = spi.xfer2([1, (8 + channel) << 4, 0])
    
    # Extract 10-bit ADC data bits from responses buffer:
    # 8th bit of byte 1 is MSB, combined with byte 2
    adc_out = ((resp[1] & 3) << 8) | resp[2]
    return adc_out
 
try:
    while True:
        analog_value = read_adc(0) # Read analog channel 0
        voltage = (analog_value * 3.3) / 1023.0 # Map reading to voltage level
        print(f"Channel 0 Raw: {analog_value} | Calculated Voltage: {voltage:.2f} V")
        time.sleep(0.5)
except KeyboardInterrupt:
    spi.close()
    print("SPI connection terminated.")

// File: sensor_trigger.c
// Compile command: gcc -o sensor_trigger sensor_trigger.c -lgpiod
 
#include <gpiod.h>
#include <stdio.h>
#include <unistd.h>
 
int main() {
    const char *chipname = "gpiochip0";
    struct gpiod_chip *chip = gpiod_chip_open_by_name(chipname);
    if (!chip) {
        perror("Error opening GPIO chip");
        return 1;
    }
    
    struct gpiod_line *line = gpiod_chip_get_line(chip, 17);
    if (!line) {
        perror("Error getting line 17 descriptor");
        gpiod_chip_close(chip);
        return 1;
    }
    
    int ret = gpiod_line_request_output(line, "custom_driver", 0);
    if (ret < 0) {
        perror("Error requesting output line 17");
        gpiod_chip_close(chip);
        return 1;
    }
    
    printf("Looping output pulses on GPIO pin 17...\n");
    while (1) {
        gpiod_line_set_value(line, 1); // Set HIGH
        sleep(1);
        gpiod_line_set_value(line, 0); // Set LOW
        sleep(1);
    }
    
    gpiod_line_release(line);
    gpiod_chip_close(chip);
    return 0;
}

# 1. Verify that the camera module is detected by the libcamera framework
libcamera-still --list-cameras
 
# 2. Capture a high-resolution still image and save to disk
libcamera-still -o test_capture.jpg
 
# 3. Capture a 10-second H.264 video clip
libcamera-vid -t 10000 -o test_recording.h264
 
# 4. Stream low-latency camera video feeds to local ports
libcamera-vid -t 0 --inline --listen -o tcp://0.0.0.0:5001

# Auto-detect official Raspberry Pi camera modules (OV5647, IMX219, IMX477, IMX708)
camera_auto_detect=1

// File: rpi_gpio_driver.c
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
 
#define DEVICE_NAME "rpi_gpio"
#define CLASS_NAME "rpi_class"
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Vaibhav Rathod");
MODULE_DESCRIPTION("A minimal character device driver for RPi GPIO simulation.");
MODULE_VERSION("0.1");
 
static int major_number;
static char message[256] = {0};
static short size_of_message;
static int number_opens = 0;
 
static int dev_open(struct inode *, struct file *);
static int dev_release(struct inode *, struct file *);
static ssize_t dev_read(struct file *, char *, size_t, loff_t *);
static ssize_t dev_write(struct file *, const char *, size_t, loff_t *);
 
static struct file_operations fops = {
    .open = dev_open,
    .read = dev_read,
    .write = dev_write,
    .release = dev_release,
};
 
static int __init rpi_gpio_init(void) {
    printk(KERN_INFO "rpi_gpio: Initializing the rpi_gpio module\n");
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        printk(KERN_ALERT "rpi_gpio failed to register a major number\n");
        return major_number;
    }
    printk(KERN_INFO "rpi_gpio: registered successfully with major number %d\n", major_number);
    return 0;
}
 
static void __exit rpi_gpio_exit(void) {
    unregister_chrdev(major_number, DEVICE_NAME);
    printk(KERN_INFO "rpi_gpio: Unregistered device, exiting module.\n");
}
 
static int dev_open(struct inode *inodep, struct file *filep) {
    number_opens++;
    printk(KERN_INFO "rpi_gpio: Device has been opened %d time(s)\n", number_opens);
    return 0;
}
 
static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset) {
    int error_count = 0;
    error_count = copy_to_user(buffer, message, size_of_message);
    if (error_count == 0) {
        printk(KERN_INFO "rpi_gpio: Sent %d characters to the user\n", size_of_message);
        return (size_of_message = 0);
    } else {
        printk(KERN_INFO "rpi_gpio: Failed to send %d characters to the user\n", error_count);
        return -EFAULT;
    }
}
 
static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    sprintf(message, "%s(%zu letters)", buffer, len);
    size_of_message = strlen(message);
    printk(KERN_INFO "rpi_gpio: Received %zu characters from the user\n", len);
    return len;
}
 
static int dev_release(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "rpi_gpio: Device successfully closed\n");
    return 0;
}
 
module_init(rpi_gpio_init);
module_exit(rpi_gpio_exit);

obj-m += rpi_gpio_driver.o
 
all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
 
clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

# 1. Compile the kernel module driver
make
 
# 2. Insert the module into the active kernel space
sudo insmod rpi_gpio_driver.ko
 
# 3. Verify module loading in syslog
dmesg | grep rpi_gpio
 
# 4. Check device node configuration
cat /proc/devices | grep rpi_gpio
 
# 5. Remove the module from the active kernel
sudo rmmod rpi_gpio_driver

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <pthread.h>
#include <unistd.h>
 
// Structure representing a single GPIO pin event
struct gpio_event {
    int pin;
    int state;
    unsigned long timestamp_ms;
};
 
// Structure defining the Circular Ring Buffer with condition variables
struct ring_buffer {
    struct gpio_event *buffer;
    int head;
    int tail;
    int capacity;
    pthread_mutex_t lock;
    pthread_cond_t read_cond;  // Signaled when data is enqueued
};
 
// Initialize the ring buffer
struct ring_buffer *init_buffer(int capacity) {
    struct ring_buffer *rb = (struct ring_buffer *)malloc(sizeof(struct ring_buffer));
    rb->capacity = capacity;
    rb->buffer = (struct gpio_event *)malloc(capacity * sizeof(struct gpio_event));
    rb->head = 0;
    rb->tail = 0;
    pthread_mutex_init(&rb->lock, NULL);
    pthread_cond_init(&rb->read_cond, NULL);
    return rb;
}
 
// Check if buffer is empty
bool is_empty(struct ring_buffer *rb) {
    return (rb->head == rb->tail);
}
 
// Check if buffer is full
bool is_full(struct ring_buffer *rb) {
    return ((rb->head + 1) % rb->capacity == rb->tail);
}
 
// Enqueue event (ISR Thread calling)
bool enqueue_event(struct ring_buffer *rb, struct gpio_event event) {
    pthread_mutex_lock(&rb->lock);
    
    if (is_full(rb)) {
        pthread_mutex_unlock(&rb->lock);
        return false;
    }
    
    rb->buffer[rb->head] = event;
    rb->head = (rb->head + 1) % rb->capacity;
    
    // Signal blocked reader threads that data is available
    pthread_cond_signal(&rb->read_cond);
    
    pthread_mutex_unlock(&rb->lock);
    return true;
}
 
// Dequeue event (Blocking user thread calling)
bool dequeue_event_blocking(struct ring_buffer *rb, struct gpio_event *event_dest) {
    pthread_mutex_lock(&rb->lock);
    
    // Block until buffer contains data (condition variable check loop)
    while (is_empty(rb)) {
        pthread_cond_wait(&rb->read_cond, &rb->lock);
    }
    
    *event_dest = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % rb->capacity;
    
    pthread_mutex_unlock(&rb->lock);
    return true;
}
 
// Free buffer structures
void free_buffer(struct ring_buffer *rb) {
    free(rb->buffer);
    pthread_mutex_destroy(&rb->lock);
    pthread_cond_destroy(&rb->read_cond);
    free(rb);
}
 
// Global buffer reference for producer-consumer threads
struct ring_buffer *shared_rb;
 
// Simulate hardware ISR generating pin events in background
void *isr_producer_thread(void *arg) {
    printf("[ISR Thread] Hardware driver thread active.\n");
    struct gpio_event evs[] = {
        { .pin = 17, .state = 1, .timestamp_ms = 100 },
        { .pin = 17, .state = 0, .timestamp_ms = 250 },
        { .pin = 27, .state = 1, .timestamp_ms = 400 }
    };
    
    for (int i = 0; i < 3; i++) {
        usleep(300000); // Sleep 300ms to simulate physical delay
        if (enqueue_event(shared_rb, evs[i])) {
            printf("[ISR Thread] Enqueued state transition on Pin %d\n", evs[i].pin);
        }
    }
    
    // Push a shutdown event (Pin -1) to exit consumer loops
    struct gpio_event exit_event = { .pin = -1, .state = 0, .timestamp_ms = 0 };
    enqueue_event(shared_rb, exit_event);
    return NULL;
}
 
// Simulate user space reading daemon
void *user_consumer_thread(void *arg) {
    printf("[User Thread] Reading daemon thread active.\n");
    struct gpio_event ev;
    
    while (true) {
        dequeue_event_blocking(shared_rb, &ev);
        if (ev.pin == -1) {
            printf("[User Thread] Shutdown sentinel signal received. Exiting daemon.\n");
            break;
        }
        printf("[User Thread] Read Event: Pin %d -> State %d (Logged at: %ld ms)\n", 
               ev.pin, ev.state, ev.timestamp_ms);
    }
    return NULL;
}
 
int main() {
    printf("=== MULTI-THREADED PRODUCER-CONSUMER RING BUFFER ===\n");
    shared_rb = init_buffer(10);
    
    pthread_t producer, consumer;
    
    // Spawn threads
    pthread_create(&consumer, NULL, user_consumer_thread, NULL);
    pthread_create(&producer, NULL, isr_producer_thread, NULL);
    
    // Wait for threads to finish
    pthread_join(producer, NULL);
    pthread_join(consumer, NULL);
    
    free_buffer(shared_rb);
    printf("System simulation completed successfully.\n");
    return 0;
}