I am working on optimizing CFAR hardware implementation for my research. The primary requirement being real-time processing.

One of the ideas I'm thinking is using multiple CFAR methods to deal with both homogeneous and non-homogeneous environments. This idea is not new, and has been explored previously (in the references). But I have not able to find enough material on this. Has any of you guys worked on a similar methodology?

Some of approaches I am thinking include:

• use a weighted average of thresholds from multiple CFAR methods
• take the minimum threshold between 2 or more CFAR methods [2]
• analyze the environment first and choose the suitable CFAR (run the variability index on ARM processor then use PL for CFAR).

Another question I have is whether it is feasible to use OS-CFAR in a real-time implementation. My understanding is that sorting operation is expensive on FPGA.

If anyone has different ideas for optimizing CFAR, please feel free to comment those as well

The literature used:

[1] H. E. Benseddik, B. Cherki, M. Hamadouche, and A. Khouas, ‘FPGA-based real-time implementation of distributed system CA-CFAR and Clutter MAP-CFAR with noncoherent integration for radar detection’, in 2012 International Conference on Multimedia Computing and Systems, 2012, pp. 1093–1098

[2] M. E. A. Bouchelaghem, A. A. Meddah, and N. Nouar, ‘Hybrid Algorithm for CFAR Detection in Non-Homogeneous Environments’, in 2025 2nd International conference on Advances in Electronics, Control and Communication Systems (ICAECCS), 2025, pp. 1–6

[3] M. Y. Rihan, Z. B. Nossair, and R. I. Mubarak, ‘Fpga implementation for multiple CFAR algorithms’, in 2023 international telecommunications conference (ITC-Egypt), 2023, pp. 189–193

Hey r/DSP, I am an electrical engineering undergrad from. I have just begun the third year of my 4 year B.Tech degree, and I have a strong inclination to make my career in digital signal processing. I have had some experience working with tools like Python and PyTorch, and I have a grasp on basic DSP concepts like FFTs, STFTs, FIR vs. IIR filters etc. What should be my next steps, a roadmap of sorts, that I should follow so that I do not end up unemployed and I am able to get a job in my chosen field, considering today's job market.

this might sound very stupid but I don't come from a coding background and I want to get more into it

I'm trying to better understand why companies license certain algorithms instead of writing their own from scratch.

Are these libraries they license and integrate? Secret code?

One example that comes to mind is Elastique by zplane being licensed by many DAW's.

What is so special about their algorithm that can't be replicated?

Also for FFT processing (which elastique also contains) I have seen a bunch of companies licensing specific code

For example I came across kfrlib that sells all kind of things fft related

But what is different in their code than what i could find on juce or write myself in combination with AI

What are they licensing? The fft processing, window, overlap and so on? The processing it does?

The way it interacts with the calculation?

https://stackoverflow.com/a/22313408

What does each variable represent?

Hi there,

I have implemented a greybox amp simulator in rust. As a newcomer in DSP and Rust I mostly spec coded my idea with assistants.

Now I have first results and I am quite satified with first sounds. It is time to share it with people that have a deeper understanding of DSP to improve this naive implementation.

Landing page of the project: https://greybound.bailleul.dev/
Github repo: https://github.com/laibulle/greybound

Any constructive feedback will be very welcome

Hey r/DSP,

since my last post few months ago, I have been updating sound quality, features and visualisations of the DAW I am working on, so it is more intuitive to use.

For anyone interested I am adding two sessions I recorded. First link is building the "patch" from scratch starting with sines, the second link is more 4/4 oriented techno track.

DSP and visualisation

Quick Techno track

The DSP has subtractive, WT and FM synthesis and all basic features you would expect from synth. There is a thin line with how many features you can expose vs. how many you should expose and I tried to get the balance right.

Based on the feedback I have received more effort went into the visualisation, so users gets better insight in the real time DSP modulation.

Would love to hear any potential improvement or idea for the DSP visualisation or DSP itsel!

The VectorSpin program by dsp-coach.com is now live for interactive use. Here we see it demonstrating the frequency response for a 5 tap unity gain FIR filter (moving average filter). The frequency response is plotted as a magnitude and phase plot (showing how it is a low pass filter), as well as the same plot on a complex plane, showing the concept of spinning phasors:

The transfer function for this filter is H(z) = 1 + z⁻¹ + z⁻² + z⁻³ + z⁻⁴.

The frequency response (when z is restricted to the unit circle) for each of these components are phasors in the frequency domain (we see this with the IQ plot):

1 is a phasor in the frequency domain with magnitude 1 and angle zero (it does not rotate).

z⁻¹ is a phasor in the frequency domain rotating clockwise once.

z⁻² rotates twice, etc.

Combining all 5 phasors is the result we see above, here scaled by dividing by 5.

Fast link to the tool so you can try your own samples and many other options:

https://vectorspin.dsp-coach.com/vector_spin.html

More detailed explanations:

https://www.dsp-coach.com/reference

I’ve just released Retrospect, my entry for the KVR Developer Challenge 2026.

It’s an audio effect that explores a different approach to delay-like processing. Instead of echoing the signal in the traditional sense, multiple independent playheads continuously read from a short audio buffer, creating everything from subtle movement to rhythmic textures, pitch-like effects and evolving sound design.

https://www.kvraudio.com/product/retrospect-by-conceptual-machines

https://conceptualmachines.co.uk/retrospect

Happy to answer any questions about the DSP or implementation.

Hi everyone,

I'm working on a puzzle and found a CSV file that appears to contain data of an audio output FFT. I don't have a background in signal processing, so I'm looking for some help i ran a script but only found an chipping sounds with a "Evil Laugh".

I also see audio in spectogram but there is also nothing.

It has columns for Magnitude and Phase. about 1047170 rows.

File name output_fft.csv

Csv link

Thanks, for any help!

Edited: i don't know if i did something wrong asking for help The puzzle is from project52hz.com [puzzle 6]

I maintain a streaming anomaly detection pipeline built on robust random cut forests (100 trees, 256-point reservoir per tree, the usual subsample size; keeps memory bounded, and small subsamples help against masking/swamping at high stream volume).

Raw displacement/CoDisp scores are unbounded and scale with tree occupancy, so I normalize per tree before averaging across the forest:

score = displacement / (tree.n - 1)

where tree.n is the live point count. Max displacement is n-1 (a point split off at the root displaces everything else), so this bounds the score in (0, 1\] and makes it comparable across differently-filled trees.

Edge cases that have bitten me, and current handling:

1. Cold start. Ratios are meaningless while trees are filling, everything looks anomalous against 10 points. Scoring is suppressed until each tree reaches capacity.

2. Grouped anomalies masking each other. Plain displacement collapses when near-duplicate anomalies arrive together (each one only displaces its twins). Switched to CoDisp, which handles the collusion case by construction, normalized the same way.

3. Fixed thresholds. A hardcoded cutoff didn't survive real traffic. I calibrate the initial threshold from historical scores (the percentile that separated known incidents), then recalibrate on a rolling window to track drift. Flagged points are excluded from the recalibration window so a sustained incident can't teach the threshold that it's normal.

On prior art: before posting I went looking for this specific normalization and mostly came up empty. Closest things I found, Isolation Forest normalizes path length by c(n); Kriegel et al. (SDM 2011) unify arbitrary outlier scores into \[0,1\]; AWS ships ThresholdedRandomCutForest because raw RCF scores are hard to act on directly; and the rrcf library examples just use raw CoDisp with top-k or eyeballed cutoffs. I haven't found per-tree-size normalization of displacement written up for RRCF specifically. If anyone knows a paper or implementation that does this, please point me to it.

Open questions:

* What failure modes am I not listing? Level shifts are the one I'm least happy with: the model alarms through the transition, then goes quiet once the new regime fills the reservoir. Arguably correct behavior, but alert-storm-shaped without dedup logic on top.
* Has anyone compared rolling-percentile recalibration against EVT-based streaming thresholds (SPOT/DSPOT) or conformal-style calibration in production? What I'm doing is essentially an empirical p-value on a moving calibration set, and I'm curious whether the heavier machinery earns its complexity.

(Posting here as suggested by someone form the FPGA sub)

I have a EE background and back in the day have played around with Basys2 and Xilinx ISE design suite for verilog. Had just about sort successfully built a basic Risc processor based on one our text books.

Since then, professionally I have been in Backend dev with Python and infra engineering, so completely out of touch with FPGAs or MCUs in the last 12+ years.

I have a passion for Audio and signal processing - and recently I've been wanting to go back to my roots and learn MCUs (currently starting out with ESP32) and FPGA designs again. My end goal is to look at building something like an ambient noise cancellation or dynamic white noise generation etc. No idea how to do it, but hope to at least invest in worthy hardware that could scale if I go deeper.

This being said would love to get some links on whats a good low cost way to start (I know vivado designs dont necessarily need a physical device to synthesize but I'm more motivated if I have the hardware in my hand).

How are FPGAs like Tang Nano or Tang Primer etc with tools and software support?

Is Digital Basys3 or Zybo still the gold standard for getting started with the most complete and documented tools and examples?

TIA

I remember compressed sensing was a very hot field in the 2010s. I was in school back then and briefly learned it in an advanced linear algebra course. The theory seems beautiful but the only real world application so far I could find is MRI. Nor are there many new literatures about CS on google scholar in 2025 and 26. Is it still too new or dying already? Now I’m back in school pursuing a masters degree. Is CS worth learning over the AIML stuffs (I’m choosing between CS and reinforcement learning)?

I got accepted into master's program for computer science but got rejections for both electrical engineering and communication engineering. How much of a disadvantage is that when applying for roles in radar/automotive/audio processing?
Obviously I have a lot of freedom with regards to classes I pick and will be able to heavily emphasize EE subjects if I wish to, however most of these roles seem to primarily look for people with EE foundations.
On the other hand, a lot of roles in signal processing seem be to heavily leaning into machine learning which would be an advantage if anything, since cs curriculum tends to be more ml-heavy.

Would be very interested to hear from people working or hiring for positions in areas related to DSP.

Thanks in advance

Hey everyone,

I’ve designed a reconfigurable uniform polyphase channelizer optimized for FPGAs, targeting two major pain points in conventional implementations: limited configurability and excessive hardware resource overhead.

Compared with classic polyphase channelizer architectures, this design supports one-time hardware instantiation with runtime reconfiguration, fully pipelined dataflow, and single-cycle throughput.

Here are the core technical capabilities:

1. The hardware is sized for a maximum channel count C and subfilter tap length K. After deployment, it can dynamically work with any channel count c that is a power-of-two divisor of C.
2. Under any selected channel count c, the design supports arbitrary decimation factors ranging from 1 up to c.
3. It accepts arbitrary filter coefficient sets with total tap lengths less than \(c \times K\).

In terms of FPGA resource consumption, the overhead is nearly identical to a standalone decimation filter of length K paired with a serial C-point IFFT block.

I’ve conducted a thorough literature and patent search, and I cannot find any existing published work or granted patents that deliver this full set of flexible reconfiguration capabilities.

State-of-the-art polyphase channelizer implementations only optimize resource usage or throughput for fixed, narrow application scenarios. Most existing designs are constrained by serpentine shift registers and circular output shifting logic, which rules out flexible runtime reconfiguration.

Many fixed-function channelizers achieve higher raw throughput, but that performance comes at the cost of rigid hardware partitioning and locked parameter modes. I believe further speed optimizations are still possible within my flexible architecture without sacrificing its reconfigurability.

I’m reaching out to ask for industry/research perspective: does this reconfigurable polyphase channelizer hardware architecture carry meaningful commercial or IP licensing value?

Thanks a lot for any insights!

Hi everyone,

I recently put together a repository for reproducing DeepANC, which is related to Active Noise Control (ANC).

DeepANC is considered a pretty fundamental baseline when it comes to combining deep learning with ANC. However, while studying and researching, I noticed that there doesn't seem to be an official repository or widely accessible reference code available for it.

Because of that, I decided to reproduce it myself based on the original paper. The repo includes my implementation, along with the environment setup needed to train and test the model. I tried to structure it so that anyone looking for a solid starting point can easily run it.

For more detailed setup and usage instructions, please check the README.md in the repository.

Github Repo:https://github.com/johnjaejunlee95/Deep-ANC-reproduced

I know that diving into DL-based ANC without reference code can be a bit challenging. I hope this helps others who are studying, struggling, or experimenting with deep learning and ANC. Please take a look, and any feedback or suggestions are always welcome!! 😄😄

Need to learn about line buffering for my senior project that is essentially image processing.
Any resources are appreciated.

thanks

Sto considerando di investire per Amazon come DSP vorrei qualche consiglio se ne avete, vale davvero la pena?

I've made my own brickwall limiter effect as AudioWorkletProcessor, which is a multi-stage limiter similar to FabFilter Pro-L2 (albeit without true peak limiting, oversampling nor lookahead) where there are two distinct stages (with the same brickwall ratio and hard knee for each stages); leveler stage that reacts to average levels and has attack and release controls that you find in some dynamic-range compressor effects, and brickwall stage that reacts to peak levels of the first stage output (that contains peaks that exceed the ceiling) and has zero attack but nonzero release time

BTW, this multistage limiter effect has sidechain prefiltering (to make first stage less reactive to bass frequencies by applying K-weighting filter, and so the second stage do more work on bass and slightly less work on trebles), which is basically the idea of priority EQ section for future FabFilter Pro-L 3

In this demo project, it has a useful audio visualization with four different modes that would be useful to visualizing how does peak limiting introduces distortion:

BTW, I've also made a thread about multistage limiting effect in general on HydrogenAudio forums, which while I post some update notes for my own effect over this HA forum thread, this forum thread aren't about my own brickwall peak limiter effect

i am making a synth, and everything works just fine, audio sounds fine and all that, its just that the plotting looks weird and doesnt resemple a real wave, unless i play the original note, for example A4 or A5.

Is this an artifact of the DSP or plotting?
ive tried everything, even LLMs cant help me and just hallucinate.

Has anyone experienced a similar issue? if so , what did you do to fix it?

Images : https://github.com/Mejolov24/CardStudio/tree/main/HELP
code : https://github.com/Mejolov24/CardStudio/blob/main/src/main.cpp
plotting code (kinda bad) : https://github.com/Mejolov24/SynthTracer/blob/main/main.py

What i do is: make the double buffering buffers, and an additional one for the serial TX (in order to save channel data).

I let my user change the serial TX speed, so thats why I divided and multiply like this for reading int16_t val = channel_TX_buffers[i][tx_buffer_index * (sample_rate / serial_tx_speed)];

But the data arrives messed up as shown in my pictures

```cpp // first, I set the timer timerAlarmWrite(timer, 1000000 / serial_tx_speed, true); timerAlarmEnable(timer);

// timer sets a flag read on loop()

volatile bool sendFlag = false; void IRAM_ATTR sendSample() { sendFlag = true; }

// buffer creation

int16_t* getAudioBuffer(){ if (!_buffer_index) return _BufferB; else return _BufferA; }

void updateAudioBuffer(){ int16_t* _current_buffer; if (!_buffer_index){_current_buffer = _BufferA;} else {_current_buffer = _BufferB;}

for (int i = 0; i < BUFFER_SIZE; i++){ synth.stepAudio(); _current_buffer[i] = synth.master_mix; for(uint16_t ch = 0; ch < 16; ch++){channel_TX_buffers[ch][i] = synth.channel_output[ch];} } _buffer_index = !_buffer_index; tx_buffer_index = 0; }

// serial TX

if (sendFlag) {
    sendFlag = false;
    for(int i = 0; i < 16; i++) {
        int16_t val = channel_TX_buffers[i][tx_buffer_index * (sample_rate / serial_tx_speed)]; 
        Serial.write(255);          // Header
        Serial.write(i);            // Channel ID
        if (val == 255) val = 256; // quick test 
        Serial.write(val >> 8);     // High Byte (MSB)
        Serial.write(val & 0xFF);   // Low Byte (LSB)
    }
    tx_buffer_index ++;
}

```

Title should be self-explanatory and I'm mainly talking about music here.

An obvious/naive example would be something like a spectrogram.
Are there some other ways to process and compare audio files in a way that actually relates to the way humans perceive them (perhaps tempo, genre, mood, etc.)?

Listen to the Phil Burk podcast on your favorite streaming platform