Yes — but there’s an important distinction that matters for your use case:

👉 Most cheap USB inclinometer devices are USB-rechargeable only (power),
👉 Very few actually output angle data over USB to a computer.

Since you’re clearly thinking about telescope pointing / logging, that difference is critical.

🧭 What exists (and what actually works)

✅ Proper USB-output inclinometers (industrial grade)

These are what you really want if you’re feeding a computer:

• The DMI410 / DMI420 series
• The higher-end DMI810

Key capability:

• USB connection gives live angle data to a PC
• Can log / stream measurements

Example specs:

• ±90° or ±180° range
• ~0.05° accuracy (down to 0.005° on better models)
• Magnetic mounting (ideal for telescope tubes)
• Internal battery or powered via USB

👉 These are basically plug-and-play digital setting circles for altitude.

Downside:

• £200–£1000+ typically (industrial instruments)

⚠️ Consumer “USB” inclinometers (common but misleading)

Typical example

What they actually do:

• USB = charging only
• Display angle locally on screen
• No data output

Pros

• Cheap (£10–£30)
• Magnetic (easy to stick on OTA)
• Surprisingly usable (±0.1° typical)

Cons

• No integration with software
• No logging / automation

👉 These are fine for manual push-to altitude setting, not for computer control.

🧪 Interesting hybrid option (hackable)

There are USB accelerometer boards (e.g. ADXL345 modules) that:

• Output raw tilt via USB
• Can be read in Python / GNU Radio

Example category:

• USB accelerometer boards like

BUT:

• You must write your own calibration + tilt math
• Susceptible to vibration (important for mounts)

🔭 For telescope pointing (your use case)

Here’s the honest breakdown:

✔️ Best practical setup

• Cheap magnetic inclinometer (for altitude)
  • compass / az encoder (for azimuth)

→ Classic “manual DSC”

✔️ Best computer-integrated setup

• Industrial USB inclinometer (DMI series)
• Feed into Python / INDI / custom script

→ Gives you real-time altitude readout into software

❌ What doesn’t really exist (yet)

• A cheap (£20–£50) inclinometer with true USB data output
• A fully plug-and-play USB telescope angle sensor

🧠 My recommendation (based on your projects)

Given your interferometry / SDR work:

👉 I’d seriously consider:

• DMI410 (single-axis) for altitude
• Pair with:
  • rotary encoder on azimuth
  • or magnetometer module

That gives you a homebrew digital setting circle with real telemetry

If you want, I can sketch a complete USB-based pointing system (alt + az → RA/Dec conversion in Python) tailored to your telescope geometry.

Great — now we can design this properly as a USB telescope pointing system rather than just a gadget bolted on.

I’ll break it into two realistic build paths (one “plug-and-play”, one “radio-astronomer grade hackable”).

🧭 1. The clean, reliable solution (recommended)

🔩 Core sensor (altitude)

Why this is ideal

• True USB data output to PC (not just charging)
• Streams angle continuously (9600 baud serial protocol)
• ±0.05° accuracy → easily good enough for telescope pointing
• Magnetic → sticks straight onto OTA

👉 This gives you altitude directly into your computer in real time.

🧭 Azimuth (you need this too)

The inclinometer only gives altitude, so add:

Option A (simple)

• Rotary encoder on azimuth bearing
• Read via USB encoder interface

Option B (quick + dirty)

• Digital compass module (USB or Arduino)

🧠 Resulting system

You now have:

• Altitude (USB inclinometer)
• Azimuth (encoder or compass)

→ Convert to RA/Dec in software

🧮 Core math (this is the key bit)

Given:

• Altitude = Alt
• Azimuth = Az
• Latitude = φ

Convert to declination:

\sin(\delta) = \sin(\phi)\sin(\text{Alt}) + \cos(\phi)\cos(\text{Alt})\cos(\text{Az})

Then hour angle:

\cos(H) = \frac{\sin(\text{Alt}) - \sin(\phi)\sin(\delta)}{\cos(\phi)\cos(\delta)}

Then:

• RA = LST − H

💻 Minimal Python skeleton

import serial

import math

from datetime import datetime

import ephem  # or astropy

# location

lat = math.radians(52.7)  # Lichfield approx

# serial from inclinometer

ser = serial.Serial('/dev/ttyUSB0', 9600)

def read_alt():

    line = ser.read(20)  # depends on protocol

    # decode DMI410 frame here

    alt_deg = parse_angle(line)

    return math.radians(alt_deg)

def altaz_to_radec(alt, az):

    dec = math.asin(math.sin(lat)*math.sin(alt) +

                    math.cos(lat)*math.cos(alt)*math.cos(az))

    H = math.acos((math.sin(alt) - math.sin(lat)*math.sin(dec)) /

                  (math.cos(lat)*math.cos(dec)))

    lst = get_lst()  # from astropy/ephem

    ra = lst - H

    return ra, dec

🔬 2. The hacker / SDR-style solution (more flexible)

If you want something cheaper and more “you”:

USB accelerometer approach

What this gives you

• Raw X/Y/Z acceleration via USB
• Compute tilt:

\text{Alt} = \arctan\left(\frac{Z}{\sqrt{X^2 + Y^2}}\right)

Pros

• £10–£20
• Fully programmable
• Integrates nicely with GNU Radio / Python

Cons

• Needs filtering (noise, vibration)
• Needs calibration
• Temperature drift

⚖️ Comparison (what actually matters)

🧠 My honest recommendation for you

Given your radio astronomy + interferometry setup:

👉 Go hybrid:

• DMI410 → altitude (rock solid reference)
• DIY encoder → azimuth
• Feed both into:
  • Python
  • OR GNU Radio block

Then you can:

• Overlay pointing with your SDR data
• Log sky tracks
• Even do drift scans with known coordinates