Lightweight bandpass filter for embedded device (no FFT) - embedded

Question

I would like to remove certain frequencies from the discrete dataset (signal sampled by ADC). Sounds simple enough. However, there are certain constrains that make things harder:
The chip is a 32 bit NXP JN5168, that has hardware multiplication, but no hardware division, no floats support, or any tools whatsoever that make DSP easy. Therefore, FFT-based filters those are so easy to implement on ARM Cortex M chips are a no-go
Sampling is pretty much set at 1 kHz
real time and RAM usage is a concern, because there are other tasks that chip is taking care of at the same time.
I tried using well-known high/low pass filters of the form:
Filtered Value (L) = Previous Value - k*(Previous Value - Original Value) // LPF
Filtered Value (H) = Original Value - Filtered Value (L) // HPF
Unfortunately, even with multiple passes this type of filter does not work as I would like it to work. The raise of the HPF response in the frequency domain always starts at 0, and one only can control the slope there by adjustng k. Since the sampling rate can't be changed, that's the only control.
If I want to filter out anything below 120 Hz, and leave 200 Hz untouched, that's not possible with the above filter, which is very good at having sharp cutoffs below 80 Hz (at my sampling rate). If I reduce the cutoff aggressiveness, and make filter work for 120 Hz then 200 Hz are also affected (less, but significantly).
Below you can see a frequency response of the 3 passes of the above-described HPF with k=1/2.
This does not work for me. I am looking for something different: I am looking for a lightweight filter algorithm suitable for embedded applications that can ideally provide a full or significant cut at an arbitrary frequency with a steep cutoff line, so that neighboring frequencies are unaffected, or affected insignificantly.
Thanks!
Edit: I do not want to transform my signal into the frequency domain, but rather continue working with a cleaned-up signal in the time domain.
Edit 2: Changing the hardware is not an option. There is an already existing product that needs a new feature. That happens. That's life. My job is to find the solution, which I am sure exists.

Answer 1

If your computational budget can afford 5 multiplications (MACs) per sample (per millisecond at a 1 kHz sample rate), and you can save the past couple samples, you can use a biquad IIR filter. There is a cookbook for biquads coefficients.
If you can afford a small multiple of 5 MACs per sample, then you can cascade biquads and get a higher-order IIR filter with an even sharper roll-off or cutoff. But you may need to use a filter design software package (MatLab, et.al.) to optimize the pole-zero locations of a higher order IIR filter for your specific requirements.

Answer 2

Adapted from The Scientist and Engineer's Guide to
Digital Signal Processing - Chapter 19: Recursive Filters:
static const float pi = 3.141592f ;
static const float pi2 = 2.0f * pi ;
static const float s = 48000 ; // Sample rate
void bandpassFilter( float f_hz, // Filter centre frequency
float bw_hz, // Filter bandwidth
const float *x, // Pointer to input sample block
float *y, // Pointer to output buffer
int n // Number of samples in sample block
)
{
static float x_2 = 0.0f; // delayed x, y samples
static float x_1 = 0.0f;
static float y_1 = 0.0f;
static float y_2 = 0.0f;
static const float f = f_hz / s ;
static const float bw = bw_hz / s ;
static const float R = 1 - (3 * bw) ;
static const float Rsq = R * R ;
static const float cosf2 = 2 * cos(pi2 * f) ;
static const float K = (1 - R * cosf2 + Rsq ) / (2 - cosf2) ;
static const float a0 = 1.0 - K ;
static const float a1 = 2 * (K - R) * cosf2 ;
static const float a2 = Rsq - K ;
static const float b1 = 2 * R * cosf2 ;
static const float b2 = -Rsq ;
for( int i = 0; i < n; ++i)
{
// IIR difference equation
y[i] = a0 * x[i] + a1 * x_1 + a2 * x_2
+ b1 * y_1 + b2 * y_2;
// shift delayed x, y samples
x_2 = x_1;
x_1 = x[i];
y_2 = y_1 ;
y_1 = y[i];
}
}
Since at the end of the loop, the filter state is retained in the static variables x_1, y_1, x_2 and y_2, the filter may be called repeatedly with any number of samples - one sample at a time or in blocks (more efficient).
The static calculation of the coefficients and use of single precision floating point however makes it reasonably fast even for software floating point, requiring only multiply-add. The use of software floating point may increase code size somewhat - most significantly in the use of cos(), but if your frequency, and bandwidth are not variable, the coefficients may be pre-calculated and hard coded - I have included them in the code for illustration purposes, and because it was real code I had available rather then developed specifically for the question.
If the floating-point remains too resource or time hungry, then a fixed-point implementation is possible. I have used the same code adapted for fixed-point using Anthony Williams' fixed point math library which uses C++ and extensive operator overloading to allow in most cases a fixed-point implementation simply by replacing float with fixed.