Bit of an odd ball thing to post I know, someone might find it useful so last night I open sourced my TigerSharc 201 tool chain.

Its a DSP chip that is relevant in the music world specifically in signal processing, but has many other applications.

This project contains the 3 core components of any chip's toolchain, the Compiler (C to Assembly) the Assembler (Assembly to Machine Objects) and the Linker (Compiles your objects and provides a binary the DSP can run)

http://www.github.com/rm2kdev/TigerSharc-201-Tool-Chain

I built and used this to compile a firmware for a particular bit of kit, unfortunately that project was shut down by the manufacturer (respectfully and politely I'll add) so I pivoted to building my own vst thing instead www.forgeefx.com (not an ad, just part of the true story) since all the code was pure C i just stopped using this compiler, and ported to a vst.

Its highly optimized and produces binaries that run faster than the real compiler, yes, a good bit of AI assistance (still claiming to be an engineer as I've worked in the industry for 20+ years), no reverse engineering used it was created by reading the DSP/CPU's instruction set in the official published documentation (Processor Programming Reference) and cleanly implementing all of those instructions and then building optimizations for the compilation process. (mostly around math, opcode usage, memory etc)

This on its own, does not produce binaries that run on any hardware (That would need a boot loader, and firmware, and other work), it does however produce binaries that run on this exact DSP/CPU in question.

Happy to answer any questions.

Hi everyone,
I work in automotive software and want to build a solid understanding of Image Signal Processing (ISP) for ADAS cameras. I’m new to ISP, and I find vendor documentation difficult to follow without understanding the basics first.
I’m looking for a structured learning path covering:
Camera fundamentals: How image sensors work, RAW images, Bayer patterns, exposure, gain, and noise.
ISP pipeline: Demosaicing, white balance, noise reduction, color correction, HDR, and tone mapping.
ISP tuning: How to evaluate image quality and understand the trade-offs between different settings.
ADAS applications: How ISP settings affect object detection and perception, especially in low light or high-contrast scenes.
Which courses, books, YouTube playlists, or practical tutorials would you recommend? Free and paid options are both welcome. Hands-on exercises using RAW images, Python, or OpenCV would be especially helpful.
If you work in automotive imaging, where would you start, and in what order would you learn these topics? Please share links or resource names.
Thanks!

Hello DSP community,

Today, something I haven't figured out hit me differently, and I want to discuss it. I was thinking about the perimeter of the circle, which is quite easy to say straightforwardly:

Perimeter=2(\pi)r, and this is also an arc length. Now, assume you take a compass with a unit radius. You start to draw just one circle. You get 2(\pi), which is a perimeter, and it is no longer in radians. It can be seen as radians because the value is exactly (2\pi), but it is not a angle anymore; it's a length. See the trick.

Then I started asking myself why we need degrees, because degrees mess with the whole logic. If I think in radians, I don't need to memorize equations for perimeter and arc length, and I can see the angle/length transformations clearly; instead, I can see the whole logical path.

I thought this is important and shapes the definition of period, and, what’s more, it's a kind of fundamental for signal analysis. How do you learn such formula? Is there anything wrong with my thinking?

Happy day!

Edit: Typo

I've been working on a new Rust DSP library that I'm calling yagi. So far, it's largely a port of liquid-dsp, but I've put work into expanding some of the capabilities and making the whole thing feel more Rustlike. liquid's a great library and you should check it out if you haven't.

I just released yagi 0.5 and I feel it is ready for external users. If you're doing DSP things in Rust, give it a shot https://github.com/brian-armstrong/yagi

As a way of demoing my new library, I put together a little demo of it with wasm https://brian-armstrong.github.io/yagi/lab.html#intro

The demo shows yagi's modem, interpolation and decimation, packetization and error correction, and channel impairments. If you get a chance to try it out, let me know what you think.

Cheers!

I teach an undergraduate digital communications course and have released the material openly; I built it with Claude Code. Posting here because most of it is DSP at the baseband level, and I would value review from people who work on this in practice.

The core is a single offline HTML file (no install, no account) with 109 step-by-step scenes and 10 interactive labs. The figures are recomputed as parameters change, for example pulse shape and roll-off against ISI and the eye opening, or matched-filter output and decision statistics in AWGN. Topics covered: sampling and PCM, matched filter, ISI and the Nyquist criterion, eye diagrams, signal-space representation, the optimal AWGN receiver, PSK/PAM/QAM/FSK, and introductory information theory.

Scope note: this is a senior undergraduate course. It does not cover synchronization, channel equalization, or multicarrier systems.

The 120 worked problems were checked against independent NumPy/SciPy computations and Monte Carlo BER simulations. I am especially interested in errata and in places where the numerical treatment is sloppy.

Course site · GitHub repository

https://reddit.com/link/1x5ye41/video/qv02kixs2hvh1/player

Ratio9’s standalone version is free for Apple silicon Macs running macOS 12 or later. I’m Max, its developer; version 1.2.1 is now available.

I previously shared the synth here. Ratio9 1.2.1 includes a direct AI workflow around its controls and audio analysis: a compatible assistant changes a patch, auditions it, requests fresh output measurements, then uses those readings to guide the next revision. The connection uses a local stdio MCP client.

The live analysis view shows frequency content, changes over time and output levels. The preset stays customizable: oscillators, filters, modulation and effects remain accessible to the musician.

The pictures show the main interface at INIT and a separate growl preset in the live spectrum/spectrogram view.

I’m interested in the evaluation problem behind this: which measurements would you pair with spectral information to guide modulation-heavy sound design across different pitches and note lengths? A spectrogram gives useful evidence about a sound, but musical usefulness still needs listening.

The complete standalone synth is free. Optional VST3 + AU plug-ins are $79.99 USD once for two Macs. You bring your own AI account and compatible client. This is an alpha release; complex patches can cause CPU spikes or dropouts.

Download and setup: https://ratio9synth.com/download

My current pipeline consists of a 15–450 Hz Butterworth band-pass filter, followed by a conditional 50 Hz notch filter. Rather than applying the notch filter to every recording, I calculate a 50 Hz power ratio, R50=P50/Pbackground, where P50 is the mean PSD between 49–51 Hz and Pbackground is the mean PSD across 40–48 Hz and 52–60 Hz. I apply the notch filter only when R50>300), using a 50 Hz notch filter with (Q=30).

I understand that this threshold is empirical and that the method may miss some recordings with power-line interference or occasionally remove genuine EMG content around 50 Hz.

Do you think this approach is methodologically valid?

The "Superclav" extends the basic Karplus-Strong algorithm, incorporating localized tweaks for each range of notes in the typical keyboard range of a clavichord, to things like attack, decay, noise-filtering, etc...in order to arrive at a satisfyingly musically expressive instrument.

In this video, I'm using an authentic 1/4-comma meantone temperament, which was widely used during the Renaissance as a standard keyboard tuning. The characteristic sound is the sweet resonance of the pure 5/4 major thirds and 8/5 minor sixths, paid for by comprising the fifths to make them a hair flat, and thus, more "active" with their beating.

I am a senior EE student interested in the signal processing/telecom field. I hope to work remotely in the future. How common are remote jobs in the field?

I am trying to create a tuner by doing FT on the signal then doing a weighed sum of the amplitudes to find the dominant frequency and well it gets the clean notes but if i add enough background noise it starts not rly working anymore. I am new to all this so pls bare with me as I have a few questions:

1) Applying pass filters would rly help since its the same as after doing the FT just not looking at those unwanted freqs

2) Would it help if i did a matched filtering? since that should tell me how strongly the signal i get is correlated to some note and it also accounts for the fact that the note is not played continuosly. What im having srs trouble is understanding how these compares to the FT in the way u analyse things. Cause FT also kinda shows how well a freq corelates to the signal u have which makes me wonder what difference in information do these two give?

3) Any other ideas if I have random noise in the 200-20kHz range?

Hello all,

I built a radar object classifier on RadarScenes, extending a prior single-scan classifier to accumulate observations over a tracked object's history instead of classifying each scan in isolation.

A single RadarScenes object instance contains only about 2.9 radar points on average, very sparse. A single scan also can't capture temporal characteristics: RCS and micro-Doppler both vary continuously as an object moves. Pedestrians produce characteristic micro-Doppler from limb motion; different object classes show different RCS fluctuation patterns as aspect angle and scattering geometry change scan to scan. Accumulating observations gives both higher point density and provides temporal dynamics.

Multi-scan baseline

DeepReflecs encoder (Ulrich, Glaser & Timm, RadarConf 2021), PointNet style, per point shared weights, on single scans across car, large_vehicle, two_wheeler, pedestrian, pedestrian_group: 0.7370 macro F1.

Using RadarScenes' persistent `track_id`, I build a causal, N=20, per track sliding-window buffer:

- x_seq/y_seq: Global, odometry-corrected coordinates recentered per scan on the object centroid. Unlike x_cc/y_cc (car-frame coordinates that accumulate over time to form a trajectory).

- Cross sensor buffer: whichever of the 4 sensors currently observe the track push to the same buffer.

- Stride 1, causal: every new scan updates the buffer and produces a prediction. No future context, real time streaming compatible.

- Each scan is encoded once by a frozen per scan encoder and cached

- Fusion concatenates the causal GRU's hidden state (order aware) with an order-invariant pooled embedding (all N scans' points as one set, no sequence structure) through a small trained mlp head.

Results

Pooling alone, no sequence model, no notion of scan order at all, recovers +0.1243 macro F1. The GRU adds a real but much smaller +0.0282 on top. Fusion adds nothing measurable beyond the GRU.

Ablation

Llarger GRUs, a Transformer, a state space model, point level self attention, all trained on the exact same frozen per scan embeddings, land inside a 0.86 to 0.89 band, a 0.03 spread. End to end fine tuning of the frozen encoder makes things slightly worse (about -0.002 to -0.003), not better.

Conclusion

In this setup, the largest gain comes from giving the model more observations of the same tracked object: 20-scan point pooling improves macro F1 from 0.7370 to 0.8613 without using scan order at all.

Temporal modelling then provides a further, meaningful improvement. The causal GRU reaches 0.8895, adding +0.0282 over the pooled representation. So temporal ordering clearly contributes useful information; it just accounts for a smaller portion of the overall gain than observation accumulation.

With the per-scan encoder frozen, the different sequence architectures tested, suggests that the quality of the per-scan representation is the bottleneck than the particular mechanism used to aggregate the sequence.

Full report, every ablation, confusion matrix, coordinate frame reasoning: https://github.com/brunopinto900/radar-ml-autonomous-driving/blob/main/final_report.md

Thank you.

I've noticed a strange audio artifact in Roblox, especially in older games/weapons that rapidly retrigger short sound effects.

At lower rates, I hear the individual sound events normally. But once the sound is retriggered rapidly enough, a separate continuous tonal/harmonic sound appears underneath the SFX. It sounds roughly F#, and it behaves almost like a background hum or ringing generated by the audio system.

The strange part is that it doesn't seem to behave like ordinary repetition pitch. Increasing the firing/retriggering rate further doesn't simply make the tone continue rising in pitch. After crossing a certain density, the underlying tone remains approximately stationary while the individual sounds continue being retriggered.

I've reproduced it with very different Roblox sounds: rapid gun SFX (including a modded gun using different samples) and an unrelated rapidly repeated punch/impact SFX. The same kind of underlying tone is audible in both.

48,000 / 1024 = 46.875 Hz, but I don't know whether that's actually related to Roblox's audio processing or is just a property/artifact of my recording chain.

Does anyone familiar with Roblox's audio engine know what could cause this? Is there some voice scheduling, mixing, block processing, quantization, clipping/limiting, or other DSP behavior that becomes audible when Sounds are retriggered extremely rapidly?

I keep finding myself when doing sound design trying to either take what I would describe as a grainy gritty sound and making it smooth and glassy, or vice versa and taking a smooth and glassy sound and trying to make it sound more gritty and grainy in particular with synthesizers.

I'm trying to understand more what imparts these particular qualities. For examples, see below.

But here are my overall questions.

1) If you were a synth designer, and you wanted to give your synth a grainy gritty quality... how would you set things up to give it that character?

2) Vice versa, if you wanted to make your synth more glassy and smooth, how would you go about that?

3) if you wanted to switch from one to another via mixing? How would you approach it?

EXAMPLES:

This synth Chipsynth MD emulates an older sega genesis FM chip, and the underlying mechanics of it originally being a physical electronic hardware chip at a lower bit rate imparts more of a gritty character to a fair amount of sounds. (but you can get to a smoother sound with certain patches).

Whereas Zebra 3 and Zebrallete have a much smoother glassier sound in general to the majority of their synth presets. (but you can still get a grainy texture for some presets). For extremely smooth and glassy, this synth, FM lab i would consider on the extreme end of that. (yes I know that certain types of FM specialize in this type of quality)

Something in between might be this... MPowersynth... the synth sort of has this grainy texture for a majority of sounds, but there's something they are doing on the back end to impart some sort of character... to make the high end frequencies smoother at the same time as having some harshness in the mids as most of the patches tend to have that character.

Can anybody help me with this issue I'm facing in generating sine waves?

Has anyone ever written a custom FPGA SPI master state machine to completely initialize the AD9361 by doing register level writes? I want to get in contact with somebody who has done before this hardware level control of AD9361.

I teach an undergraduate Signals and Systems course and have been developing the lecture material as an interactive browser course. It covers signals and systems, LTI systems and convolution, Fourier series and transforms, and sampling and aliasing.

The current version has 531 scenes, 35 interactive labs, and 210 practice questions with worked solutions. It runs in the browser, and the site also has printable lecture notes, a question workbook, and a formula reference. Python examples run in the browser when selected.

Course site · GitHub repository

If you teach or study DSP, I’d be interested to hear whether the interactive labs and worked questions are useful, and what you think is missing.

https://reddit.com/link/1wuebkx/video/xm95ods9npsh1/player

I want process every onset note from song.wav in C/C++. Is using frequencies a good idea, if program must process every note separatelly?

Hello,

I am currently working on a project where I have to calculate the LF power from a reBAP blood pressure signal. I was instructed to use Wavelets for this task, so I've been trying to figure them out. After some research, I learned that orthogonal wavelets are better for energy preservation, so I thought maybe I'll use orthogonal wavelets because I feel like energy preservation would be important for calculating LF power of the signal. However, after more research, I learned that the orthogonal wavelet scales are only in powers of 2. So, then I think the frequency resolution is too sparse to capture the frequencies within the LF band, which ranges from 0.04 - 0.15. So then I feel like continuous wavelet transform might be a better choice because the frequency resolution is much finer. But CWT doesn't have the energy preservation that the DWT has. I'm new to signal processing and I'm not sure if any of my reasoning here is even correct. I would really appreciate any advice about how to move forward.

Thank you!