Dump1090-fa is not able to decode

[Arunchinna]

Hi

When I run rtl_adsb my tuner automatically set to 1090 mhz frq and 2000000 sample rate as shown below but i cant see any flight on my site

[tomvdhorst]

You have a Fitipower FC0013 chip DVB tuner dongle, that’s not the correct one for ADSB reception.

With that dongle you won’t get any aircraft as you have noticed.

You will need a dongle based on the R820T chip

[obj]

note that rtl_adsb does essentially no error detection, so the output you see from rtl_adsb is just decoding garbage messages from random noise.

[geckoVN]

@tomvdhorst

You have a Fitipower FC0013 chip DVB tuner dongle, that’s not the correct one for ADSB reception.

@Arunchinna
The FC0012 is the worst offender. The various FC0013’s “might” be able to be modified to work at 1090. The table below is the ‘received wisdom’ and is reproduced in many places.
Some of the FC0013’s are claimed to have an L-Band input on the chip (allowing input up to 1700MHz), but as no second connector is provided, it would require internal modification.

Given the Fitipower chips all get poor reviews (high noise floor, poor sensitivity, synth spurs) and no datasheet seems to be available, I really can’t see the point spending time on it.

[abcd567]

@obj

note that rtl_adsb does essentially no error detection

Wow, AI is a computer programming tutor !!!

I just asked AI that I need a code to remove garbage from output of rtl_adsb, and it repplied as follows:

AI Overview

To correct a single-bit error using a Cyclic Redundancy Check (CRC) by brute force, you can write a program that systematically flips each bit in the received message (including the CRC bits) and recalculates the CRC for each modified version. The version that yields a zero remainder (or a matching checksum) is the corrected message

.This method is described as being used in tools like Dump1090, a program that processes ADS-B data.

Pseudocode for Single-Bit Error Correction

Here is the pseudocode for this approach:

pseudocode

function correct_single_bit_error(received_message, polynomial):
    message_length = length(received_message)

    // Function to calculate CRC. This needs to be an actual CRC implementation
    // that uses the specified polynomial and returns the remainder.
    function calculate_crc(data, poly):
        // (Implementation specific to your CRC standard and data type)
        // ... returns remainder (syndrome) ...

    // 1. Check the original message
    initial_remainder = calculate_crc(received_message, polynomial)
    if initial_remainder is 0:
        return received_message, "No error detected"

    // 2. Iterate through every bit position
    for i from 0 to message_length - 1:
        // Create a copy of the message to modify
        potential_correct_message = copy(received_message)

        // Flip the bit at position i
        potential_correct_message[i] = 1 - potential_correct_message[i] // Assumes binary (0 or 1)

        // 3. Calculate the CRC of the modified message
        new_remainder = calculate_crc(potential_correct_message, polynomial)

        // 4. If the remainder is zero, the error was at position i
        if new_remainder is 0:
            return potential_correct_message, "Error corrected at bit position " + i

    // If no single-bit flip results in a valid CRC, it might be a multi-bit error or a false detection
    return received_message, "Could not correct single-bit error"

 

Key Considerations

• CRC Implementation: You will need a specific implementation of the calculate_crc function tailored to the exact CRC standard (e.g., CRC-16, CRC-32, specific generator polynomial, initial values, reflection, etc.) used to generate the original checksum.
• Performance: This is a brute-force method. For a message with N bits, you perform N+1 CRC calculations. This is acceptable for short messages (like the 112-bit ADS-B messages in the Dump1090 example) but may be inefficient for very long data blocks.
• Guarantees: This method can only correct single-bit errors. A two-bit error might accidentally result in a valid CRC for a flipped bit, leading to an incorrect correction (a miscorrection). This approach works because with a good CRC polynomial, each single-bit error results in a unique non-zero remainder, or “syndrome”.

 

 

[MC130E]

@geckoVN

Given the Fitipower chips all get poor reviews (high noise floor, poor sensitivity, synth spurs) and no datasheet seems to be available, I really can’t see the point spending time on it.

Hi,

Agreed on all.

Several of the people I have dealt with that unknowingly had a Fitipower chip did not intentionally purchase a Fitipower chip. The seller used standard online descriptions that identified it as a typical R820T or similar, and then shipped a Fitipower, often by mistake.

The bigger companies would not do this, but some of the smaller online resellers might not even fully understand the difference. Most just returned the device. Some asked the seller, who then immediately shipped out the correct device.

Regards,
-Dan

[jimMerk2]

@abcd567

I just asked AI that I need a code to remove garbage from output of rtl_adsb, and it repplied as follows:

You probably need to be more specific in asking the question. You can actually ask AI to write code in a specific language. Also apparently copilot AI is better at answering these types of questions than google AI, although I haven’t tried it.

[obj]

@abcd567

I just asked AI that I need a code to remove garbage from output of rtl_adsb, and it repplied as follows:

If you mean it’s good at pasting together text without understanding any of it, maybe?

(for example, the “guarantees” part is a bunch of mostly-true statements slapped together but the explanation as a whole makes no sense – halfway through it starts talking about the uniqueness of syndromes for single-bit errors, which is entirely irrelevant in brute-force correction)

[abcd567]

@obj

If you mean it’s good at pasting together text without understanding any of it, maybe?

You are right. I have noted that answers / solutions by AI are often wrong, confusing or misguiding.

Google search AI collects bits and pieces from discussion forums, facebook, articles on web by novice & hobbyists etc and combine these and outputs the mixture..

[mgrone]

While the suggested pseudo code is in some way correct. Nobody ever would do this. CRC obeys linearity, i.e, CRC(A x B) = CRC(A) x CRC(B). Flipping a single bit is M x (0..010…0).
For ADS-B you are interested in the bit pattern 0..010…0 for which you get:

CRC(M x (0..010..0)) = 0

which by linearity is

CRC(M) x CRC(0..010..0) = 0

which then yields

CRC(M) = CRC(0..010..0)

1. So you precompute all CRC(0..010..0) and put them in a hashtable
2. If you have message M with CRC(M) != 0, look into the table at CRC(M) to get your bit correction pattern.

Stream1090 does the table here:

include/CRCErrorTable.hpp