Boxcar averager, high-pass-filter and SAT

[Taktyk]

Hi

Until now, I've used a single HPF for SAT. With a range of 0.1-3HZ. Slow and fast signal tuning. It works well for weak signals.

However, a strong signal from a large target causes and a quick move of the target away from the coil causes the signal to return to zero for a long time.

Here is an example [3:40]:

https://www.youtube.com/watch?v=FfQg8HdNQRQ

With low SAT and strong signal there is a long return to zero. How to make a quick return?

How to make a better SAT? Will a boxcar averager be better than HPF? HPF has a long pulse response...

Any ideas for a better SAT?

Thank you for your answers!

Taktyk

[Marchel]

Hi


What type of Filter do you use in your project ? I'm also working on a digital Metal Detector and I chose the IIR Filter and I'm using this application http://www.iowahills.com/4IIRFilterPage.html for the calculation and I also think it's slow

[Taktyk]

Rutus is not my project. I'm doing a two-box at the moment. I need a very slow SAT. I use IIR high-pass-filters.

[Marchel]

Try to look at this forum maybe it will help you there is everything you need about detectors.

http://www.md4u.ru/viewtopic.php?f=24&t=8251&start=100

It would be nice if we solved your problem together because it would help maybe a lot of people who are building their own metal detector.

[waltr]

My guess is that the HPF is saturating in the Negative direction when the Target is moved away from the coil.

This is the response of HPF and analog SAT circuits.

Without more details of exactly what the input and output values of the HPF are this is a guess.

[Marchel]

Exactly it's just a guess, I like this project http://www.radiodom.org/index/krot_pro/0-31 it seems that the filter works well in it. My project is based on the same principle, I also just need the right HPF for the project to work properly, there are photos and test video in static mode.

https://github.com/folny/nRF52_Metal_Detector

[Ferric Toes]

My guess is that the HPF is saturating in the Negative direction when the Target is moved away from the coil.

This is the response of HPF and analog SAT circuits.

Without more details of exactly what the input and output values of the HPF are this is a guess.

This analogue circuit prevents the capacitor going negative more than the reference voltage. At -4mV it gives almost instantaneous recovery back to zero. The second capacitor and jfet can be left out and the circuit is still very effective. The second filter was for ultra sharp pinpointing.

Better opamps available today. Don't forget to open the jumper switch after zeroing.

Eric.

[tony_av]

5kHz very simple yet good results:


unsigned short long ar[]={0,0},y1=0,y2=0;
unsigned int syg1, syg2, res=0, res1=0, x1[]={0,0,0,0,0,0,0}, x2[]={0,0,0,0,0,0,0};
unsigned char br=0,br1;

for(unsigned int i=0;i<128;i++)
{
ar[0]+=ADC_GetConversion(0);
__delay_us(67);
ar[1]+=ADC_GetConversion(1);
}
ar[0]>>=3;//Low pass filter about 40Hz
ar[1]>>=3;
res=ar[0]>>8;
res<<=8;
res=res|(ar[0]&0x0000ff);
ar[0]=0;
res1=ar[1]>>8;
res1<<=8;
res1|=(ar[1]&0x0000ff);
ar[1]=0;
for (br1=1;br1<7;br1++)
{
x1[br1-1]=x1[br1];
x2[br1-1]=x2[br1];
}
x1[6]=res;
x2[6]=res1;
for(char i=0;i<7;i++)
{
y1+=x1[i];
y2+=x2[i];
}
y1=y1/7;
y2=y2/7;
res=res-y1; // High pass filter 40Hz/7=5.6Hz
res1=res1-y2;
syg1=abs(res); //absolute value - not needed
syg2=abs(res1);
y1=0;
y2=0;

[Carl-NC]

If the target creates what is considered to be a "positive" signal then the removal of the target creates a negative signal. When the signal goes negative, you simply speed up the SAT whether in hardware or software. This is a slow attack fast decay filter.

In hardware you typically have an RC HPF where a shunt resistor sets the SAT speed. You could split that resistor into a fixed value (say, 100k) and a pot (say, 1Meg) and put a shorting switch (4066) across the pot. When the SAT signal goes negative you short the pot. This is basically how the SAT works in the GS5/TDI designs. You could also use a 100k shunt resistor in series with a 4066 switch and PWM the switch (at say, 1MHz) from a uC. The PWM duty cycle controls the normal SAT speed, and just turn the switch on to get a fast decay.

In software you would implement the SAT with a FIR or IIR filter and just alter the coefficients on the fly. Or reset the filter contents.

[Taktyk]

My guess is that the HPF is saturating in the Negative direction when the Target is moved away from the coil.

This is the response of HPF and analog SAT circuits.

Without more details of exactly what the input and output values of the HPF are this is a guess.

Yes, the filter response is zero in the minus direction.

[Taktyk]

In software you would implement the SAT with a FIR or IIR filter and just alter the coefficients on the fly. Or reset the filter contents.

I reset the filter when it's less than 0. It's good! I'm still experimenting with coefficients...

This is my filter for SAT:

#define NZEROS1 1
#define NPOLES1 1

float filter_bessel_0_05_Hz_HPF1(float input_value)
{
static float xv[NZEROS1+1], yv[NPOLES1+1];

xv[0] = xv[1];
xv[1] = input_value / 1.000157080e+00;
yv[0] = yv[1];
yv[1] = (xv[1] - xv[0]) + ( 0.9996858901 * yv[0]);
return yv[1];
}

and code for the program:

if(ram_cfg.HPF_static>0 && CurrentY>0)
{CurrentY = set_HPF_static(CurrentY);}

if(ram_cfg.HPF_static>0 && CurrentY<0)
{CurrentY = set_HPF_static(0);}


Thank you for all your answers!

TAKTYK

[Marchel]

I tried your filter and it is quite slow, here is my filter try the one even though it is very similar to yours.

float XY_H_a0 = 1.000000000000000000;
float XY_H_a1 = -0.939062505817492399;
float XY_H_a2 = 0.000000000000000000;
float XY_H_b0 = 2.435352399105962910;
float XY_H_b1 = -2.435352399105962910;
float XY_H_b2 = 0.000000000000000000;


float X_H_X1, X_H_X2, X_H_Y1, X_H_Y2;
float Y_H_X1, Y_H_X2, Y_H_Y1, Y_H_Y2;


int IIR_X_HP_Filter(int x)
{
float y, CenterTap;


CenterTap = x * XY_H_b0 + XY_H_b1 * X_H_X1 + XY_H_b2 * X_H_X2;
y = XY_H_a0 * CenterTap - XY_H_a1 * X_H_Y1 - XY_H_a2 * X_H_Y2;


X_H_X2 = X_H_X1;
X_H_X1 = x;
X_H_Y2 = X_H_Y1;
X_H_Y1 = y;


return (int)y;
}


int IIR_Y_HP_Filter(int x)
{
float y, CenterTap;


CenterTap = x * XY_H_b0 + XY_H_b1 * Y_H_X1 + XY_H_b2 * Y_H_X2;
y = XY_H_a0 * CenterTap - XY_H_a1 * Y_H_Y1 - XY_H_a2 * Y_H_Y2;


Y_H_X2 = Y_H_X1;
Y_H_X1 = x;
Y_H_Y2 = Y_H_Y1;
Y_H_Y1 = y;


return (int)y;
}

[Marchel]

Hi


I've added all my code to GitHub, I'll be adding a schematic and a pcb in Eagle format soon.

https://github.com/folny/nRF52_Metal...T_v.1.0/main.c

[waltr]

Thanks. I will be looking over your project.

[Marchel]

Thanks. I will be looking over your project.

The project is under development many things are not yet working, communication is still only through J-Link RTT.