I have the winners of the quarter second mark. The sample file was generated from the best uniform linear array antenna configuration I could make. The element spacing distance was 0.4 wavelengths at 1090MHZ.
Up in first place we have 64 messages with the four-antenna system using random theta probing and a constant amplitude. This means obj was right about holding that amplitude at 1.0 but the jury is still out for a windowing function!
In second place we have 60 messages with the four-antenna system using a random theta and randomizing the amplitude of the weights.
In third place we have the uniform linear array sweep done with 4-antennas with 25 messages.
The two-antenna system with random probing for 10 messages.
And, due, to my poor signal reception and unfortunately due to only having a single antenna we got zero messages for last place.
Now, I just need a sample file to run from someone who has a great view of a lot of traffic to see how well they perform. The messages counted had to have a good CRC or correctable bit errors up to 2.
We had an upsetā¦ 4x-random-amplitude swooped in for first place leaving 4x-random with constant amplitude in second place. This was after it ran all night and reached the 17 second mark.
I was thinking you know that since I had done some projects in the past with CUDA, I might be able to leverage an NVIDIA GPU to do the beamforming calculations. Iām not sure if the CUDA cores could handle framing up any messages so that might still have to be done on the CPU. If anyone has any advice, suggestions, or what not let me know because Iām going to be thinking on it.
Itās a lot of work really because I have to use C++ as of right now. Iām thinking I could bolt it on as another program you run. The current program might connect to this other program via TCP and shovel the data with information about how many beams to form, perhaps, random. Then the C++ program pushes back over TCP the results.
Or I could write the whole thing over in C++, excluding the decoding, and just fully rely on piping the output to dump1090 for a map.
Iām wondering though does anyone have an NVIDIA card theyād like to use? Iām just wondering if Iād be the only one interested in this. If there are other people out there that would use it then Iād for sure be willing to build it. It shouldnāt take too long to programm but it would be a pile of work. Like I said, Iāve done similar stuff a while back.
The real question is will it allow more beams to be formed and how many more. Right now, Iād like to double the number of beams on my current computer from around 300 to 600 or greater to really dig out those messages that exist with a multi-antenna system.
So, if you have an NVIDIA card thatās just sitting there a lot and not doing anything it might be worth putting it to some use. I figure there are some people out there that might spend the extra money to put together system too. It obviously isnāt for everyone because the RTLSDR still offers a really nice amount of performance for the price.
At the same time, youād need at least one BladeSDR. Also, if anyone has any other cards out there with multiple coherent RX streams let me know. I might be able to buy one and build something around it.
Itās too early to tell but it might be a viable alternative to using so much CPU even if it does find fewer messages than the random approach. We are talking just a single threaded program that could be nearly as good, better, or equal to the random approach.
I was off my rocker when I said single threaded program. With four antennas it still takes a hefty price tag in CPU usage. I canāt tell if itās better or worse, so I made a branch called lms for anyone that wants to follow along or try it out.
You can change the mu parameter to control how fast it tries to learn the weights.
A weird side effect was it also created something like stream1090 where itās using the CRC to throw away messages. I thought this was cheating but I must confess I was out of options. If anyone has any opinion on that, please, feel free to tell me.
I suppose I could have redone the preamble with the new weights and then did a preamble check. That might be where all the CPU is going, haha. Right into that CRC calculation. I will have to review that but until then it runs!
If anyone is looking for the new code. It is under the function process_stream_lmsin the main.rs file. It does all the new work right there. There isnāt much to it.
I want to attribute some of the performance in messages per second with just going straight to the CRC check instead of a preamble. If I run it with a preamble check it seems to get lower message counts. But with a preamble check it should run on a PI board.
Iām working on seeing what I can get the Linearly Constrained Minimum Variance (LCMV) beamformer to do. Itās not doing very well but I may have made some mistake. Iām sweeping it and using only one SOI. It is forming and moving nulls where something exists but not getting many messages per second compared to LMS or random.
Turns out if I use the LCMV, with four antennas, to create just one main lobe and one null and I sweep these back and forth I can dig up more messages than ever before.
for theta_lobe in np.linspace(-np.pi * 0.5, np.pi * 0.5, 300):
for theta_null in np.linspace(-np.pi * 0.5, np.pi * 0.5, 300):
beamformer(theta_lobe, theta_null)
And that is with a preamble check. This time Iām not using the CRC like I do with the LMS beamformer.
The only problem is I donāt think I can get it to run in real-time. It looks like it might be time I found an FPGA I can shovel this data at and let it churn through it.
I offered you to help out with demodulation. Stream1090 is very flexible. Give me a format, and a sampling speed. I can add make stream1090_beam in a very short time.
Where A is antenna 1, B is antenna 2, and so forth.
And the sampling speed is 2e6.
Try the LMS beamformer since it seems to do so well. But I donāt think you will be able to do the CRC so quickly. Iāve been looking at it and the way LMS works it wonāt produce a CRC you can shift.
If you can get it to run on a PI that would be really nice.
I will upload a sample file you can download. I will edit this message with the link when it finishes uploading.
It is a six-minute-long file at 2e6 samples per second of course it might be off by a few thousand KHZ. It has four antennas. Sorry they are not the best antennas. They are wideband so the frontend is likely overloaded with signals outside the bandwidth, and they are low to the ground.
I forgot to mention the numbers, in the file, are 16-bit signed integers but only 11-bits are are used and 1 bit for the sign (12 total). They should be sign extended.
At the moment, Iām doing a math course. I needed to fully understand numpy.linalg.pinv. So, I sort of left off working on the LCMV beamformer.
The LCMV was doing great in Python, but when I translated to Rust it stopped working as well. It might be rounding errors or something. I remember in C++ you can set the FP model to fast or precision, but I have not found that for Rust yet.
So anyway, Iām going down the math road to implementing pinv.
And just to be clear: You will need that sampling rate. Not me. I can provide a passthrough mode for your data in stream1090 so channels are not being mixed up and at a certain speed. I am not going to run you experiment. Just to be clear.
