1. Why are you still designing & analysing analog radio equipment?
Simple answer – we love it!. We love our analog life – we feel grateful for and celebrate it. If making digital radios makes you happy – then build SDR radios.
For us, homebrew radio design and building really changed when the Internet arrived in town – this was 1995 and we first used a homebrew 300 baud & later a 14400 baud purchased modem. Prior to the Internet, we were on and off Compuserve since about 1984. We love personal computing,and have built computers since the 1990’s. Some people in our family write code in various programming languages and until the recent component price hikes, we assembled and benchmarked gaming PCs for our family and friends – so it’s not like we are total Luddites. We make some of our own digital equipment in other aspects -- such as our home network & the sensors and controllers used on our property. We also remember the first PC sound card homebrew SDR receivers and recall that this was sometime around 1999-2000. We built 2 or 3 back in the day.
However, we committed to analog design for certain fun hobby projects such as building radios and audio amps.
2. What does homebrew radio look like in 2026?
Short answer --- Builders must define that for themselves. For sure, the homebrew scene is diverse. We need to politely remind licenced Hams that most of the world – that’s 99.96% of the world’s population does not have a Ham radio ticket. Hams are but a wee drop in the ocean of all the people who listen to and/or make radios. That’s why we are not a Ham Radio channel. We cover radios for everyone who likes radios– everybody is welcome to our camp!
For analog building:
2 theoretical variations we’ve read about ( we do not like labelling people since individuals are complex, may behave hypocritically, are unique and people may change over time and some change often ).
• Scratch, analog component-level designers who use experiments to improve their
current projects using calculations, software and analytical tools. The lab experience
ranks as important as the building experience for many of these builders.
• Scratch, analog component-level builders who mostly use cookbook design
techniques to make electronic equipment. Limited use of test equipment and using
bench procedures to measure + tweak and improve their projects.
Do not want to invest a ton of time or money in parts, test equipment, or learning
how to perform the various RF test procedures.
Again – it’s not good to put people in boxes. The radio building scene seems exciting to us and we wonder how hard economic times – student loans, daycare costs, affordable housing, wealth extraction from the middle class by very rich people --- and so --- on will affect our great hobby over time.
3. Do you think it is harder to be a SDR radio designer than analog?
Yes, we do. At the design level, it’s all computer science and the ADCs, FPGAs and CPUs keep getting faster/more powerful. It’s more about touch screens, spectrum scopes, dealing with strong out-of-band signals etc. – all done by controlling SMD chips with source code and ever faster CPUs.
Consider just a simple bandpass filter such as the Biquad ( which is also a low-pass filter confusedly). We've done the Biquad with code and with op-amps. Both were fun!
Here is a simple second order filter with design parameters.
Let’s do the same filter using code written in C++ from Tom Langhorst :
“This is a simple biquad filter class that enables live digital filtering on real-time devices and microcontrollers or signal processing on all other computer devices.”
https://github.com/tomlankhorst/biquad
This are the meat-and-potatoes functions -- you call these functions from the usual main.cpp file. This code is Tom’s and was copied from his github repo called Biquad Digital Filter Class ::
#include "BiQuad.h"
BiQuad::BiQuad() {
resetStateOnGainChange = true;
set( 1.0, 0.0, 0.0, 0.0, 0.0 );
}
BiQuad::BiQuad(double b0, double b1, double b2, double a1, double a2) {
resetStateOnGainChange = true;
set( b0, b1, b2, a1, a2 );
}
BiQuad::BiQuad(double b0, double b1, double b2, double a0, double a1, double a2) {
resetStateOnGainChange = true;
set( b0/a0, b1/a0, b2/a0, a1/a0, a2/a0 );
}
void BiQuad::PIDF( double Kp, double Ki, double Kd, double N, double Ts ) {
double b0, b1, b2, bd, a1, a2;
a1 = -4.0/(N*Ts+2.0);
a2 = -(N*Ts-2.0)/(N*Ts+2.0);
bd = ( N*Ts+2.0 );
b0 = ( 4.0*Kp + 4.0*Kd*N + 2.0*Ki*Ts + 2.0*Kp*N*Ts + Ki*N*Ts*Ts )/(2.0*bd);
b1 = ( Ki*N*Ts*Ts - 4.0*Kp - 4.0*Kd*N )/bd;
b2 = ( 4.0*Kp + 4.0*Kd*N - 2*Ki*Ts - 2*Kp*N*Ts + Ki*N*Ts*Ts )/(2.0*bd);
set( b0, b1, b2, a1, a2 );
};
void BiQuad::set(double b0, double b1, double b2, double a1, double a2) {
B[0] = b0; B[1] = b1; B[2] = b2;
A[0] = a1; A[1] = a2;
if( resetStateOnGainChange ) {
wz[0] = 0;
wz[1] = 0;
}
}
double BiQuad::step(double x) {
double y;
/* Direct form II transposed */
y = B[0] * x + wz[0];
wz[0] = B[1] * x - A[0] * y + wz[1];
wz[1] = B[2] * x - A[1] * y;
return y;
}
std::vector< std::complex<double> > BiQuad::poles() {
std::vector< std::complex<double> > poles;
std::complex<double> b2(A[0]*A[0],0);
std::complex<double> ds = std::sqrt( b2-4*A[1] );
poles.push_back( 0.5*(-A[0]+ds) );
poles.push_back( 0.5*(-A[0]-ds) );
return poles;
}
std::vector< std::complex<double> > BiQuad::zeros() {
std::vector< std::complex<double> > zeros;
std::complex<double> b2(B[1]*B[1],0);
std::complex<double> ds = std::sqrt( b2-4*B[0]*B[2] );
zeros.push_back( 0.5*(-B[1]+ds)/B[0] );
zeros.push_back( 0.5*(-B[1]-ds)/B[0] );
return zeros;
}
bool BiQuad::stable() {
bool stable = true;
std::vector< std::complex<double> > ps = poles();
for( size_t i = 0; i < ps.size(); i++ )
stable = stable & ( std::abs( ps[i] ) < 1 );
return stable;
}
void BiQuad::setResetStateOnGainChange( bool v ){
resetStateOnGainChange = v;
}
BiQuadChain &BiQuadChain::add(BiQuad *bq) {
biquads.push_back( bq );
return *this;
}
BiQuadChain operator*( BiQuad &bq1, BiQuad &bq2 ) {
BiQuadChain bqc;
bqc.add( &bq1 ).add( &bq2 );
return bqc;
}
double BiQuadChain::step(double x) {
size_t i;
size_t bqs;
bqs = biquads.size();
for( i = 0; i < bqs; i++ )
x = biquads[i]->step( x );
return x;
}
std::vector< std::complex<double> > BiQuadChain::poles_zeros( bool zeros ) {
std::vector< std::complex<double> > chain, bq;
size_t i;
size_t bqs;
bqs = biquads.size();
for( i = 0; i < bqs; i++ ){
bq = ( zeros ) ? biquads[ i ]->zeros() : biquads[ i ]->poles();
chain.insert( chain.end(), bq.begin(), bq.end() );
}
return chain;
}
std::vector< std::complex<double> > BiQuadChain::poles() {
return poles_zeros( false );
}
std::vector< std::complex<double> > BiQuadChain::zeros() {
return poles_zeros( true );
}
bool BiQuadChain::stable() {
bool stable = true;
for( size_t i = 0; i < biquads.size(); i++ )
stable = stable & biquads[i]->stable();
return stable;
}
BiQuadChain& BiQuadChain::operator*( BiQuad& bq ) {
add( &bq );
return *this;
}
Most builders, us included, could not easily write this code. Big thanks to Tom for his code library! We don’t know many who can discribe how a biquad filter even works in plain language let alone code one. Modern digital design is about writing software. This takes conserted study and practice. If you can’t write code, then you are relegated to copying and compiling someone else’s code into yours - or just flashing their supplied firmware to your project.
While sharing code libraries is a beautiful thing and we love and rely upon it – we argue that this isn’t the same as actual design [a.k.a writing your own source code ]. However, we can completely design an analog op-amp Biquad filter in about 3 minutes with basic arithmatic using a calculator. So analog design seems much easier to us. To an experienced, professional computer programmer, it’s probably the opposite truth.
E.g. --- We seek to BP filter the downconverted IF of a receiver at ~48KHz using standard 1% R -C component values for the filter time constants. We need the bandpass filter to allow a variably selective bandpass response that does not ring excessively due to group delay, so we’ll limit filter Q to 15 or so. To allow maximum headroom (to help prevent distortion occuring within the filter), we’ll keep filter gain very low. Single DC supply.
------- END of Document -------------