Python spectrum analyzer to CSV extract for Agilent N9340B

import pyvisa
import time
import csv
from datetime import datetime
import os
import argparse
import sys

# ------------------------------------------------------------------------------
# Command-line argument parsing
# This section defines and parses command-line arguments, allowing users to
# customize the scan parameters (filename, frequency range, step size) when
# running the script.
# ------------------------------------------------------------------------------
parser = argparse.ArgumentParser(description="Spectrum Analyzer Sweep and CSV Export")

# Define an argument for the prefix of the output CSV filename
parser.add_argument('--SCANname', type=str, default="25kz scan ",
                    help='Prefix for the output CSV filename')

# Define an argument for the start frequency
parser.add_argument('--startFreq', type=float, default=400e6,
                    help='Start frequency in Hz')

# Define an argument for the end frequency
parser.add_argument('--endFreq', type=float, default=650e6,
                    help='End frequency in Hz')

# Define an argument for the step size
parser.add_argument('--stepSize', type=float, default=25000,
                    help='Step size in Hz')
                    
# Add an argument to choose who is running the program (apk or zap)
parser.add_argument('--user', type=str, choices=['apk', 'zap'], default='zap',
                    help='Specify who is running the program: "apk" or "zap". Default is "zap".')


# Parse the arguments provided by the user
args = parser.parse_args()

# Assign parsed arguments to variables for easy access
file_prefix = args.SCANname
start_freq = args.startFreq
end_freq = args.endFreq
step = args.stepSize
user_running = args.user

# Define the waiting time in seconds
WAIT_TIME_SECONDS = 300 # 5 minutes

# ------------------------------------------------------------------------------
# Main program loop
# The entire scanning process will now run continuously with a delay.
# ------------------------------------------------------------------------------
while True:
    # --------------------------------------------------------------------------
    # VISA connection setup
    # This section establishes communication with the spectrum analyzer using the
    # PyVISA library, opens the specified instrument resource, and performs initial
    # configuration commands.
    # --------------------------------------------------------------------------
    # Define the VISA address of the spectrum analyzer. This typically identifies
    # the instrument on the bus (e.g., USB, LAN, GPIB).
    # Define the VISA address of the spectrum analyzer. This typically identifies
    # the instrument on the bus (e.g., USB, LAN, GPIB).
    apk_visa_address = 'USB0::0x0957::0xFFEF::CN03480580::0::INSTR'
    zap_visa_address = 'USB1::0x0957::0xFFEF::SG05300002::0::INSTR'
    
    if user_running == 'apk':
        visa_address = apk_visa_address
    else:  # default is 'zap'
        visa_address = zap_visa_address

    # Create a ResourceManager object, which is the entry point for PyVISA.
    rm = pyvisa.ResourceManager()

    try:
        # Open the connection to the specified instrument resource.
        inst = rm.open_resource(visa_address)
        print(f"Connected to instrument at {visa_address}")

        # Clear the instrument's status byte and error queue.
        inst.write("*CLS")
        # Reset the instrument to its default settings.
        inst.write("*RST")
        # Query the Operation Complete (OPC) bit to ensure the previous commands have
        # finished executing before proceeding. This is important for synchronization.
        inst.query("*OPC?")


        inst.write(":POWer:GAIN ON")
        print("Preamplifier turned ON.")
        inst.write(":POWer:GAIN 1") # '1' is equivalent to 'ON'
        print("Preamplifier turned ON for high sensitivity.")


        # Configure the display: Set Y-axis scale to logarithmic (dBm).
        inst.write(":DISP:WIND:TRAC:Y:SCAL LOG")
        # Configure the display: Set the reference level for the Y-axis.
        inst.write(":DISP:WIND:TRAC:Y:RLEV -30")
        # Enable Marker 1. Markers are used to read values at specific frequencies.
        inst.write(":CALC:MARK1 ON")
        # Set Marker 1 mode to position, meaning it can be moved to a specific frequency.
        inst.write(":CALC:MARK1:MODE POS")
        # Activate Marker 1, making it ready for use.
        inst.write(":CALC:MARK1:ACT")

        # Set the instrument to single sweep mode.
        # This ensures that after each :INIT:IMM command, the instrument performs one
        # sweep and then holds the trace data until another sweep is initiated.
        inst.write(":INITiate:CONTinuous OFF")

        # Pause execution for 2 seconds to allow the instrument to settle after configuration.
        time.sleep(2)

        # --------------------------------------------------------------------------
        # File & directory setup
        # This section prepares the output directory and generates a unique filename
        # for the CSV export based on the current timestamp and user-defined prefix.
        # --------------------------------------------------------------------------
        # Define the directory where scan results will be saved.
        # It creates a subdirectory named "N9340 Scans" in the current working directory.
        scan_dir = os.path.join(os.getcwd(), "N9340 Scans")
        # Create the directory if it doesn't already exist. `exist_ok=True` prevents
        # an error if the directory already exists.
        os.makedirs(scan_dir, exist_ok=True)

        # Generate a timestamp for the filename to ensure uniqueness.
        timestamp = datetime.now().strftime("%Y%m%d_%H-%M-%S")
        # Construct the full path for the output CSV file.
        filename = os.path.join(scan_dir, f"{file_prefix}--{timestamp}.csv")

        # --------------------------------------------------------------------------
        # Sweep and write to CSV
        # This is the core logic of the script, performing the frequency sweep in
        # segments, reading data from the spectrum analyzer, and writing it to the CSV.
        # --------------------------------------------------------------------------
        # Define the width of each frequency segment for sweeping.
        # Sweeping in segments helps manage memory and performance on some instruments.
        segment_width = 10_000_000  # 10 MHz

        # Convert step size to integer, as some instrument commands might expect integers.
        step_int = int(step)
        # Convert end frequency to integer, for consistent comparison in loops.
        scan_limit = int(end_freq)

        # Open the CSV file in write mode (`'w'`). `newline=''` prevents extra blank rows.
        with open(filename, mode='w', newline='') as csvfile:
            # Create a CSV writer object.
            writer = csv.writer(csvfile)
            # Initialize the start of the current frequency block.
            current_block_start = int(start_freq)

            # Loop through frequency blocks until the end frequency is reached.
            while current_block_start < scan_limit:
                # Calculate the end frequency for the current block.
                current_block_stop = current_block_start + segment_width
                # Ensure the block stop doesn't exceed the overall scan limit.
                if current_block_stop > scan_limit:
                    current_block_stop = scan_limit

                # Print the current sweep range to the console for user feedback.
                print(f"Sweeping range {current_block_start / 1e6:.3f} to {current_block_stop / 1e6:.3f} MHz")

                # Set the start frequency for the instrument's sweep.
                inst.write(f":FREQ:START {current_block_start}")
                # Set the stop frequency for the instrument's sweep.
                inst.write(f":FREQ:STOP {current_block_stop}")
                # Initiate a single immediate sweep.
                inst.write(":INIT:IMM")
                # Query Operation Complete to ensure the sweep has finished before reading markers.
                # This replaces the fixed time.sleep(2) for more robust synchronization.
                inst.query("*OPC?")

                # Initialize the current frequency for data point collection within the block.
                current_freq = current_block_start
                # Loop through each frequency step within the current block.
                while current_freq <= current_block_stop:
                    # Set Marker 1 to the current frequency.
                    inst.write(f":CALC:MARK1:X {current_freq}")
                    # Query the Y-axis value (level in dBm) at Marker 1's position.
                    # .strip() removes any leading/trailing whitespace or newline characters.
                    level_raw = inst.query(":CALC:MARK1:Y?").strip()

                    try:
                        # Attempt to convert the raw level string to a float.
                        level = float(level_raw)
                        # Format the level to one decimal place for consistent output.
                        level_formatted = f"{level:.1f}"
                        # Convert frequency from Hz to MHz for readability.
                        freq_mhz = current_freq / 1_000_000
                        # Print the frequency and level to the console.
                        print(f"{freq_mhz:.3f} MHz : {level_formatted} dBm")
                        # Write the frequency and formatted level to the CSV file.
                        writer.writerow([freq_mhz, level_formatted])

                    except ValueError:
                        # If the raw level cannot be converted to a float (e.g., if it's an error message),
                        # use the raw string directly.
                        level_formatted = level_raw
                        # Optionally, you might want to log this error or write a placeholder.
                        print(f"Warning: Could not parse level '{level_raw}' at {current_freq / 1e6:.3f} MHz")
                        writer.writerow([current_freq / 1_000_000, level_formatted])

                    # Increment the current frequency by the step size.
                    current_freq += step_int

                # Move to the start of the next block.
                current_block_start = current_block_stop

    except pyvisa.VisaIOError as e:
        print(f"VISA Error: Could not connect to or communicate with the instrument: {e}")
        print("Please ensure the instrument is connected and the VISA address is correct.")
        # Decide if you want to exit or retry after a connection error
        # For now, it will proceed to the wait and then try again.
    except Exception as e:
        print(f"An unexpected error occurred during the scan: {e}")
        # Continue to the wait or exit if the error is critical
    finally:
        # ----------------------------------------------------------------------
        # Cleanup
        # This section ensures that the instrument is returned to a safe state and
        # the VISA connection is properly closed after the scan is complete.
        # ----------------------------------------------------------------------
        if 'inst' in locals() and inst.session != 0: # Check if inst object exists and is not closed
            try:
                # Attempt to send the instrument to local control.
                inst.write("SYST:LOC")
            except pyvisa.VisaIOError:
                pass # Ignore if command is not supported or connection is already broken
            finally:
                inst.close()
                print("Instrument connection closed.")
        
        # Print a confirmation message indicating the scan completion and output file.
        if 'filename' in locals(): # Only print if filename was successfully created
            print(f"\nScan complete. Results saved to '{filename}'")

    # --------------------------------------------------------------------------
    # Countdown and Interruptible Wait
    # --------------------------------------------------------------------------
    print("\n" + "="*50)
    print(f"Next scan in {WAIT_TIME_SECONDS // 60} minutes.")
    print("Press Ctrl+C at any time during the countdown to interact.")
    print("="*50)

    seconds_remaining = WAIT_TIME_SECONDS
    skip_wait = False

    while seconds_remaining > 0:
        minutes = seconds_remaining // 60
        seconds = seconds_remaining % 60
        # Print countdown, overwriting the same line
        sys.stdout.write(f"\rTime until next scan: {minutes:02d}:{seconds:02d} ")
        sys.stdout.flush() # Ensure the output is immediately written to the console

        try:
            time.sleep(1)
        except KeyboardInterrupt:
            sys.stdout.write("\n") # Move to a new line after Ctrl+C
            sys.stdout.flush()
            choice = input("Countdown interrupted. (S)kip wait, (Q)uit program, or (R)esume countdown? ").strip().lower()
            if choice == 's':
                skip_wait = True
                print("Skipping remaining wait time. Starting next scan shortly...")
                break # Exit the countdown loop
            elif choice == 'q':
                print("Exiting program.")
                sys.exit(0) # Exit the entire script
            else:
                print("Resuming countdown...")
                # Continue the loop from where it left off

        seconds_remaining -= 1

    if not skip_wait:
        # Clear the last countdown line
        sys.stdout.write("\r" + " "*50 + "\r")
        sys.stdout.flush()
        print("Starting next scan now!")
    
    print("\n" + "="*50 + "\n") # Add some spacing for clarity between cycles

Navigating Silos: Overcoming Fragmentation

Navigating Silos: How Jira Helped Me Lose Friends and Alienate Colleagues

A satirical survival guide to modern collaboration dysfunction.

In this book, we embark on a journey to explore the intricate relationship between silos, agile methodologies, and the ubiquitous project management tool, Jira. While agile practices aim to foster collaboration, adaptability, and customer-centricity, the reality is that many organizations still grapple with the stubborn persistence of silos – those barriers that stifle communication, hinder collaboration, and impede innovation.

In this age of interconnectedness and rapid change, the need to break down silos and foster cross-functional collaboration has never been more pressing. Yet, paradoxically, many organizations find themselves entrenched in siloed structures, with Jira often inadvertently exacerbating these divisions.

“Breaking Down the Walls We Lovingly Reinforce”

Through the chapters of this book, we’ll dissect the ways in which Jira, despite its many benefits, can inadvertently reinforce silos within organizations. From its team-centric approach to its customization capabilities and permission controls, we’ll uncover the subtle ways in which Jira contributes to organizational fragmentation.

“Sprinting to nowhere”

But fear not – this book is not a lamentation of the status quo. Instead, it serves as a guide for navigating the complex terrain of silos and agile business practices within the context of Jira. With each chapter, we’ll uncover practical strategies and insights to mitigate the silo effect, foster collaboration, and harness the full potential of agile methodologies.

Whether you’re a seasoned Jira user, an agile enthusiast, or a curious observer of organizational dynamics, “Navigating Silos” offers invaluable insights and actionable advice for transforming siloed structures into agile, collaborative ecosystems. So let’s embark on this journey together, as we navigate the intersection of silos, agile, and Jira, towards a future of integrated, adaptive, and customer-focused organizations.

Chapter 1: The Joy of Isolation

In this chapter, we dive headfirst into the beauty of silos. We’ll explore how isolating teams can lead to unparalleled focus and efficiency. Learn how to build impenetrable walls between departments and revel in the sweet solitude of individualized workflows. Embrace the silo mindset and watch your productivity soar!

Chapter 2: Harnessing Hierarchies

Discover the power of hierarchies in siloed organizations. From top-down decision-making to rigid reporting structures, we’ll show you how to wield hierarchy like a well-oiled machine. Say goodbye to collaboration and hello to clear lines of authority. With the right hierarchy in place, you’ll be unstoppable!

Chapter 3: Cultivating Conflict

Conflict is the lifeblood of siloed organizations. In this chapter, we’ll teach you how to sow the seeds of discord and watch them flourish. From territorial disputes to passive-aggressive email chains, we’ll explore the many ways conflict can strengthen your silos. Embrace the chaos and watch your silos thrive!

Chapter 4: Jira Jamboree

Jira isn’t just a tool – it’s a way of life. In this chapter, we’ll explore how to use Jira to reinforce your silos and keep teams isolated. From custom workflows to permission schemes, we’ll dive deep into the world of Jira customization. Say goodbye to cross-functional collaboration and hello to Jira-centric silos!

Chapter 5: Metrics Madness

Metrics are the key to success in siloed organizations. In this chapter, we’ll explore how to measure everything – from individual productivity to departmental throughput. Learn how to use metrics to pit teams against each other and drive competition. With the right metrics in place, you’ll never have to worry about collaboration again!

Chapter 6: Silo-Centric Systems: The Jira Dilemma

The heart of the issue with Jira’s role in perpetuating silos within organizations. Uncover how its structure, primarily designed around individual teams and projects, inadvertently fosters isolation and independence. From customized workflows to restricted permissions, explore how Jira’s features inadvertently reinforce silos, hindering cross-team collaboration and communication.

Chapter 7: Customization Conundrum

Explore the double-edged sword of Jira’s customization capabilities. While empowering teams to tailor workflows to their unique needs, these very customizations can inadvertently deepen silos. By encouraging teams to operate within their own tailored environments, Jira inadvertently fosters a culture of isolation, hindering collaboration and integration across departments.

Chapter 8: Permissions Pitfalls

Unravel the complexities of Jira’s permission controls and their impact on organizational dynamics. While essential for security and privacy, overly restrictive permissions can isolate teams within their own domains, limiting visibility and collaboration across the organization. Learn how to strike a balance between security and collaboration to mitigate the silo effect.

Chapter 9: Integration Impasse

Navigate the challenges of integrating Jira with other tools and platforms. While Jira offers some level of integration, the lack of seamless connectivity between systems can exacerbate silos. Explore strategies for bridging the gap between disparate tools to foster better cross-functional collaboration and communication.

Chapter 10: Communication Constraints

Discover the communication limitations inherent in Jira’s design. While adept at tracking tasks and managing workflows, Jira may fall short in facilitating open dialogue and real-time collaboration among teams. Learn how to supplement Jira with external communication channels to bridge the communication gap and foster a more connected organizational culture.

Chapter 11: Remote Renaissance

In this bonus chapter, we’ll explore how remote work can take your silo game to the next level. Say goodbye to watercooler chatter and hello to the solitude of your home office. We’ll show you how to leverage remote work to reinforce silos and keep teams isolated. From virtual meetings that lack human connection to asynchronous communication that fosters misunderstanding, we’ll dive deep into the world of remote silos. Embrace the WFH revolution and watch your silos thrive – all from the comfort of your own home!

Chapter 12: The Future of Silos

“They Call them swim lanes” – Robert S

In our final chapter, we’ll look to the future of siloed organizations. With advancements in technology and a growing appetite for isolation, the sky’s the limit. From AI-powered workflow automation to virtual reality team-building exercises, we’ll explore the cutting edge of siloed innovation. Embrace the future – and embrace your silos!

 

Starrett Analog Gage Amplifier – No 718

ButFeatures

  • Zero set control.
  • Screwdriver adjustment for individual calibration.
  • Resolution: .0001″ (0.010mm) to .000010″ (0.001mm)
  • Range: .003″ (.300mm) to 10.0003″ (10.030mm)
  • Only three switches – one for inch/millimeter, one for fine or coarse resolution & one for polarity.\par
  • Compact size of 8″ x 4-3/4″ x 2″ (200 x 119 x 50mm).
  • 110 volt AC operation (7.5 volt transformer furnished).

 

 

Probe to get:

Starrett 715-1Z – LVDT Lever Type Gage Head

 

Calibration

Recording studio Survival Guide

When it comes to recording studios, it’s easy to obsess over gear—the mics, preamps, monitors, and plugins that shape your sound. But while equipment is critical, it’s often the overlooked details that make or break a session. A forgotten cable, an overheated amp, or even a lack of snacks can grind the creative process to a halt. That’s where this Studio Survival Guide comes in. It’s a practical checklist for everything beyond the gear—cleaning supplies, tools, food, and creature comforts—that keeps sessions running smoothly and everyone focused on making great music. Whether you’re a seasoned engineer or a first-time studio owner, this guide ensures you’re prepared for anything, so the session never skips a beat.

Cleaning Supplies

  • Cable ties (for organizing cables)
  • Compressed air cans (for cleaning gear)
  • Contact cleaner/lube (for maintaining electrical contacts)
  • Deodorant (for personal hygiene during long sessions)
  • Dust covers (for protecting equipment not in use)
  • Fingernail clippers (for personal grooming)
  • First aid kit (for emergencies)
  • Javex, mop, broom (for cleaning floors and surfaces)
  • Light bulbs (for replacing burnt-out lights)
  • Microfiber cloths (for cleaning delicate surfaces like screens or instruments)
  • Mouthwash (for freshening breath)
  • Q-tips (for detailed cleaning of gear or instruments)
  • Rubbing alcohol (for cleaning and disinfecting)
  • Sink (for general cleaning and handwashing)
  • Towel per person (for personal use or spills)
  • Washroom Stock  (for personal hygiene and convenience)

Food

  • Apple juice (for hydration or snacks)
  • Aspirin or Tylenol (for headaches or minor pain)
  • Bottle of scotch (for celebratory or relaxing moments)
  • Breath mints (for freshening breath)
  • Candy, fruit, nuts, sodas, bottled water (for snacks and refreshments)
  • Coffee grinder and beans (for fresh coffee preparation)
  • Condiments (for enhancing food)
  • Cough drops (for soothing sore throats)
  • Drugs (medicinal, herbal, recreational) (as appropriate for the session)
  • Glasses (one per person) (for drinks)
  • Lemon juice, coffee (with all the fixings), tea, herbal tea (for beverages)
  • Local restaurant menu book (for ordering takeout)
  • Microwave or toaster oven (for cooking/warming food)
  • Mini freezer (for ice or frozen snacks)
  • Non-alcoholic beverage alternatives (e.g., sparkling water or mocktails)
  • Plates (for serving food)
  • Reusable water bottles (to reduce waste)
  • Silverware (for eating meals)
  • Snacks for dietary restrictions (e.g., gluten-free, vegan options)

Furnishings

  • Ashtrays (if smoking is permitted)
  • Chairs for everyone (for seating during sessions)
  • Coat rack (for storing outerwear)
  • Comfortable seating (e.g., ergonomic chairs for extended sessions)
  • Eating area (tables and chairs) (for meals or breaks)
  • GOBOs/Soundproof curtains (for windows or additional isolation)
  • Humidifier, possibly air cleaner (for maintaining air quality)
  • Mirror (for personal grooming or visual checks)
  • Mood lighting (to set the vibe for creative work)
  • Music stands with clip-on lights (for holding sheet music)
  • Office dividers (used as ISO dividers for sound separation)
  • Portable heater (for maintaining warmth in cooler environments)
  • Rugs, candles, and lights (for creating a comfortable atmosphere)
  • A small fridge or cooler (to keep perishable items fresh)
  • Storage solutions (bins, shelves for cables and accessories)
  • Waste bins and recycling containers (for managing trash and recyclables)

Gear

  • Adapters and patch cables (RCA, XLR, 1/4″) (for connecting various gear)
  • Backup hard drives (for session safety and data backup)
  • Extra vacuum tubes (for tube-based equipment)
  • Ground lift adapters (for troubleshooting hum and grounding issues)
  • Headphone amps/distributors (for multiple users to monitor audio)
  • Power conditioners or surge protectors (to protect equipment from power surges)
  • Snakes (for connecting gear to the patch bay)
  • Splicing tape and edit block (for tape editing and repair)
  • Studio monitor isolation pads (to reduce vibration and improve sound accuracy)
  • Test tone generator (for calibration and troubleshooting)

Instrument supply

  • Guitars

    • Baby powder (cornstarch-based) (for reducing hand friction while playing)
    • Capo (for changing the pitch of the guitar)
    • Extra guitar patch cables (for connecting guitars to amplifiers or pedals)
    • Guitar stands (for safely holding guitars when not in use)
    • Guitar strings (nylon, acoustic, electric, and bass) (for replacements)
    • Picks (for playing)
    • Slide (for slide guitar techniques)
    • Straps (for comfortable guitar playing while standing)
  • Drums

    • Drum dampening gels or rings (for controlling overtones and resonance)
    • Drum key (for tuning drums)
    • Extra drumheads (for replacements during sessions)
    • Extra drumsticks (for replacements or variety in playing styles)
    • Lug lube (for maintaining tension rods and smooth tuning)
    • Metronome or drum machine (for keeping time)
    • Percussion mallets and brushes (for different tonal textures)
    • Various-sized cymbal felts, nylon cymbal sleeves, snare cords, tension rod washers (for maintaining drum hardware)
  • Chromatic tuner (for tuning instruments accurately)
  • Keyboard stand(s) (for securely holding keyboards)
  • Keyboard sustain pedals (for expressive keyboard playing)
  • Violin rosin (for maintaining bow grip if working with string players)

Office Supplies

  • Backup players (for covering absent musicians)
  • Blank CDRs (for storing recordings or sharing sessions)
  • Business cards (for networking opportunities)
  • City map (for navigating the area)
  • Clothespins or clamps (for holding papers or securing cables)
  • Decent restaurants that deliver (menus on hand) (for ordering meals)
  • Debit/credit card terminal (for client payments)
  • Dry-erase board with markers (for tracking or brainstorming)
  • Good restaurant list (for dining recommendations)
  • Good rolodex of numbers (for contacts like clients, vendors, and repair people)
  • Graph paper (for sketching layouts or diagrams)
  • Guitar Player, Bass Player, Modern Drummer (magazine subscriptions) (for inspiration or industry insights)
  • Label maker (for organizing cables, drawers, or gear)
  • Large wall calendar (for scheduling studio time or tracking projects)
  • Manuals for all equipment (for troubleshooting and reference)
  • Music staff paper (for writing out parts/arrangements)
  • Notepad (for jotting down lyrics, cues, or notes)
  • Pens, pencils, highlighters, and Sharpie markers (for writing and marking)
  • Repair people (contact information for equipment repairs)
  • Rental companies (for gear or equipment rentals)
  • Track sheets (for organizing session details)
  • USB drives or external SSDs (for data backup and transfer)
  • Vacuum (for cleaning the studio)
  • Whiteout (for correcting written errors)

Tools

  • Blue masking tape (for marking spots on the floor)
  • Cable tester/DMM (for testing and troubleshooting cables)
  • Console labeling tape (for marking controls or sections on the console)
  • Crimping tool and connectors (for making custom cables)
  • Digital multimeter (for measuring voltage, current, and resistance)
  • Earplugs (for hearing protection during loud sessions)
  • Fire extinguisher (for safety precautions)
  • Flashlight (for working in dimly lit areas)
  • Gaffer tape (for securing cables and other temporary fixes)
  • Heat gun (for shrink-wrapping or repairs)
  • Matches or a lighter (for igniting or emergency use)
  • Miscellaneous portable fans (for ventilation during long sessions)
  • Multi-tool, screwdriver set, socket set, and soldering/wiring tools (for general repairs and maintenance)
  • Portable phone chargers (for clients or band members)
  • Razor blades (for precise cutting tasks)
  • Roomba (for autonomous cleanup)
  • Safety goggles (for soldering or repairs)
  • Sandpaper (for smoothing surfaces or cleaning contacts)
  • Small step ladder (for reaching high shelves or fixing lights)
  • Small vacuum cleaner (for detailed cleaning)
  • Spare fuses (for outboard gear or amplifiers)
  • Stud finder (for securely mounting or hanging gear)
  • Tape (for general use)
  • Tester (RCA, XLR, 1/4 with polarity checker) (for verifying cable connections)
  • Thermal camera (for locating overheating gear)
  • WD-40 and 3-in-1 oil (for lubricating and maintaining equipment)
  • Weather stripping (for sealing gaps to improve sound isolation)