Light tracker demo

[ccrause]

I had some fun building a light tracker with an attiny24 controller, 4x light dependent resistors and a home made pan & tilt platform driven by two servos.  Firmware written in Pascal of course!

Short video and project code.

[dbannon]

cool !

Davo

[ccrause]

cool !

Davo

Thanks Davo!

[loaded]

I watched the video, you did a great job, congratulations.
I'm asking this out of curiosity, don't laugh.
Can this project be modified to track a fly in the air?

[ccrause]

Can this project be modified to track a fly in the air?

It would require a different kind of detector, perhaps something like a matrix of directional microphones tuned to the typical frequency of a fly's wing beat. Or maybe image processing can be used to identify the location of a fly based on a video stream - but this would probably be beyond the capability of a humble 8 bit processor.

Anyway tracking something small like a fly will be a lot more challenging than tracking a light source.

[dbannon]

No, No, not a fly, a Mozzie, and as its flight pattern is analyzed fire a small lazer .....

Davo

[dseligo]

No, No, not a fly, a Mozzie, and as its flight pattern is analyzed fire a small lazer .....

If a Mozzie is a mosquito I was thinking same thing.

[Laksen]

Very cool it looks pretty stable. And really elegant code

I worked on something similar for a short while for stage light tracking. Basically the same concept but the light generated a pseudo random sequence with a high autocorrelation which meant that it becomes a lot more resilient to noise. Not sure it might be realistic in an avr24 though But maybe with the power of fpc it might be!

[ccrause]

Thanks Laksen!

[dbannon]

If a Mozzie is a mosquito I was thinking same thing.

Yep !

And a mosquito has a very small body mass so very little energy would be required IMHO. What a service to mankind that would be.

Davo

[ccrause]

It seems that sound tracking is doable, see this Arduino project or this PIC32 project.  Perhaps too much code for an attiny, but perhaps an atmega can run this. One challenge I see is the trigonometry required to calculate phase shift which probably need floating point support (or an integer math implementation), which is not yet available in FPC.

Perhaps the alternative is to build the phase shift sensor using discrete components, thus making the firmware code much simpler.

Or move to a more capable controller, such as ESP32 or a Raspberry Pi (but this has so much computing power there is no challenge left) and still use FPC and just a few of microphones.

[Laksen]

Maybe PLLs could be used instead of FFTs? Running 2 PLLs per axis would result in two phase outputs where the difference would be directly correlated to angle, something like the following pseudocode. If you run at 8 MHz and sample all 4 sensors at 40 kHz you would have 50 cycles per sensor reading. Should be doable with an AVR with hardware multipliers

Code: Pascal  [Select][+][-]

1. const
2.   LoopFilterCoefAlpha = ??;
3.   LoopFilterCoefBeta = ??;
4.  
5. var
6.   LFAccumulatorX0, LFAccumulatorX1: smallint;
7.   NCOX0, NCOX1: smallint;
8.  
9. function ProcessSampleX(input0, input1: smallint): longint;
10. var
11.   error0, error1,
12.   LFFeedback0, LFFeedback1: smallint;
13. begin
14.   error0:=FixedPointMul16x16(input0, sin_table[NCOX0 shr (NCObits-LUTbits)]);
15.   // Run loopfilters
16.   LFAccumulatorX0:=LFAccumulatorX0+FixedPointMul16x16(error0, LoopFilterCoefBeta);
17.   LFFeedback0:=LFAccumulatorX0+FixedPointMul16x16(error0, LoopFilterCoefAlpha);
18.   // Update NCO
19.   NCOX0:=NCOX0+LFFeedback0;
20.  
21.   error1:=FixedPointMul16x16(input1, sin_table[NCOX1 shr (NCObits-LUTbits)]);
22.   // Run loopfilters
23.   LFAccumulatorX1:=LFAccumulatorX1+FixedPointMul16x16(error1, LoopFilterCoefBeta);
24.   LFFeedback1:=LFAccumulatorX1+FixedPointMul16x16(error1, LoopFilterCoefAlpha);
25.   // Update NCO
26.   NCOX1:=NCOX1+LFFeedback1;
27.  
28.   // Calculate absolute difference in tracked phase
29.   result:=NCOX0-NCOX1;
30. end;
31.  

[Laksen]

The following is actually working with a simple xor phase detector. My rough estimate is that it can run in 43 cycles on any AVR with RAM, but haven't measured it with FPC yet. Could probably be optimized a lot. Don't have any working AVR boards or microphones around sadly..

Code: Pascal  [Select][+][-]

1. const
2.   alphaShift = 9;
3.   betaShift = 10;
4.  
5. var
6.   NCO: word; // Scaled radians [0;2*pi) / (2*pi)*65536
7.   lfAcc: smallint = 4000; // round(tone/samplerate * 32768)
8.  
9. procedure ProcessSinglePLL(inputNeg: boolean);
10. var
11.   errorAlpha, errorBeta, addend: smallint;
12. const
13.   alphaConst = SarSmallint(high(smallint),alphaShift);
14.   betaConst  = SarSmallint(high(smallint),betaShift);
15. begin
16.   // Phase error detector
17.   errorAlpha:=alphaConst;
18.   errorBeta :=betaConst;
19.  
20.   if inputNeg xor (NCO>$8000) then
21.   begin
22.     errorAlpha:=-errorAlpha;
23.     errorBeta :=-errorBeta;
24.   end;
25.  
26.   lfAcc :=lfAcc+errorBeta;
27.   addend:=lfAcc+errorAlpha;
28.  
29.   NCO:=NCO+addend;
30. end;
31.  

[ccrause]

The following is actually working with a simple xor phase detector. My rough estimate is that it can run in 43 cycles on any AVR with RAM, but haven't measured it with FPC yet. Could probably be optimized a lot. Don't have any working AVR boards or microphones around sadly..

Code: Pascal  [Select][+][-]

1. const
2.   alphaShift = 9;
3.   betaShift = 10;
4.  
5. var
6.   NCO: word; // Scaled radians [0;2*pi) / (2*pi)*65536
7.   lfAcc: smallint = 4000; // round(tone/samplerate * 32768)
8.  
9. procedure ProcessSinglePLL(inputNeg: boolean);
10. var
11.   errorAlpha, errorBeta, addend: smallint;
12. const
13.   alphaConst = SarSmallint(high(smallint),alphaShift);
14.   betaConst  = SarSmallint(high(smallint),betaShift);
15. begin
16.   // Phase error detector
17.   errorAlpha:=alphaConst;
18.   errorBeta :=betaConst;
19.  
20.   if inputNeg xor (NCO>$8000) then
21.   begin
22.     errorAlpha:=-errorAlpha;
23.     errorBeta :=-errorBeta;
24.   end;
25.  
26.   lfAcc :=lfAcc+errorBeta;
27.   addend:=lfAcc+errorAlpha;
28.  
29.   NCO:=NCO+addend;
30. end;
31.  

I am not familiar with the application of signal processing or PLL, do you have a reference or a short explanation of how the algorithm above works?  What is InputNeg, is it the difference in values of two signals calculated from successive measurements? .  Would a sound signal with multiple harmonics need something like a low pass filter, or will the PLL loop above handle the higher harmonics as long as the PLL update frequency is some factor higher than the highest significant harmonic?

I will buy some cheap electret microphones and a couple of op amps to start playing around, so I could also implement your PLL idea if I manage to understand enough of the implementation details.

[Laksen]

I am not familiar with the application of signal processing or PLL, do you have a reference or a short explanation of how the algorithm above works?

It's a simple control system for acquiring and tracking a tone basically. With a second order loop filter (PI) it can track the tone with a zero phase offset meaning you can reconstruct the absolute phase of the input signal.

I've drawn a diagram here: PLL diagram

What is InputNeg, is it the difference in values of two signals calculated from successive measurements?

In the case of this code it assumes the input has the format of sin(x), so whether that is negative or positive (1 bit quantization). To do a phase comparison you would run a PLL for each microphone and then compare the NCO counter to tell the absolute phase difference between them.

Would a sound signal with multiple harmonics need something like a low pass filter, or will the PLL loop above handle the higher harmonics as long as the PLL update frequency is some factor higher than the highest significant harmonic?

It might lock to a harmonic or even one of the subharmonics if you are unlucky. It's best if you can tell which exact frequency range the harmonic will be in, in that case you can clamp the value of lfAcc to stay inside that frequency range.
That's the downside with a PLL approach, with an FFT you would be able to find the global maximum

I will buy some cheap electret microphones and a couple of op amps to start playing around, so I could also implement your PLL idea if I manage to understand enough of the implementation details.

Could be cool to see