All tags, all the time. Still some weirdness with set_history() that requires using the check widths in the framer & slicer.
This commit is contained in:
Nick Foster
parent
cd394e1863
commit
f8966f0d10
@ -40,7 +40,7 @@ air_modes_framer_sptr air_make_modes_framer(int channel_rate)
|
||||
air_modes_framer::air_modes_framer(int channel_rate) :
|
||||
gr_sync_block ("modes_framer",
|
||||
gr_make_io_signature (1, 1, sizeof(float)), //stream 0 is received data
|
||||
gr_make_io_signature (1, 1, sizeof(unsigned char))) //output is [0, 1, 2]: [no frame, short frame, long frame]
|
||||
gr_make_io_signature (1, 1, sizeof(float))) //raw samples passed back out
|
||||
{
|
||||
//initialize private data here
|
||||
d_chip_rate = 2000000; //2Mchips per second
|
||||
@ -49,6 +49,11 @@ air_modes_framer::air_modes_framer(int channel_rate) :
|
||||
d_check_width = 120 * d_samples_per_symbol; //gotta be able to look at two long frame lengths at a time
|
||||
//in the event that FRUIT occurs near the end of the first frame
|
||||
//set_history(d_check_width*2);
|
||||
|
||||
std::stringstream str;
|
||||
str << name() << unique_id();
|
||||
d_me = pmt::pmt_string_to_symbol(str.str());
|
||||
d_key = pmt::pmt_string_to_symbol("frame_info");
|
||||
}
|
||||
|
||||
int air_modes_framer::work(int noutput_items,
|
||||
@ -57,8 +62,8 @@ int air_modes_framer::work(int noutput_items,
|
||||
{
|
||||
//do things!
|
||||
const float *inraw = (const float *) input_items[0];
|
||||
//float *outraw = (float *) output_items[0];
|
||||
unsigned char *outattrib = (unsigned char *) output_items[0];
|
||||
float *outraw = (float *) output_items[0];
|
||||
//unsigned char *outattrib = (unsigned char *) output_items[0];
|
||||
int size = noutput_items - d_check_width*2;
|
||||
float reference_level;
|
||||
framer_packet_type packet_attrib;
|
||||
@ -68,7 +73,7 @@ int air_modes_framer::work(int noutput_items,
|
||||
get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + size, pmt::pmt_string_to_symbol("preamble_found"));
|
||||
std::vector<pmt::pmt_t>::iterator tag_iter;
|
||||
|
||||
memset(outattrib, 0x00, size * sizeof(unsigned char));
|
||||
memcpy(outraw, inraw, size * sizeof(float));
|
||||
|
||||
for(tag_iter = tags.begin(); tag_iter != tags.end(); tag_iter++) {
|
||||
uint64_t i = gr_tags::get_nitems(*tag_iter) - abs_sample_cnt;
|
||||
@ -106,7 +111,13 @@ int air_modes_framer::work(int noutput_items,
|
||||
get_tags_in_range(fruit_tags, 0, abs_sample_cnt+i+1, abs_sample_cnt+i+lookahead, pmt::pmt_string_to_symbol("preamble_found"));
|
||||
if(fruit_tags.size() > 0) packet_attrib = Fruited_Packet;
|
||||
|
||||
outattrib[i] = packet_attrib;
|
||||
//insert tag here
|
||||
add_item_tag(0, //stream ID
|
||||
nitems_written(0)+i, //sample
|
||||
d_key, //preamble_found
|
||||
pmt::pmt_from_long((long)packet_attrib),
|
||||
d_me //block src id
|
||||
);
|
||||
}
|
||||
|
||||
return size;
|
||||
|
||||
@ -44,6 +44,7 @@ private:
|
||||
int d_chip_rate;
|
||||
int d_samples_per_chip;
|
||||
int d_samples_per_symbol;
|
||||
pmt::pmt_t d_me, d_key;
|
||||
|
||||
public:
|
||||
int work (int noutput_items,
|
||||
|
||||
@ -51,7 +51,7 @@ air_modes_preamble::air_modes_preamble(int channel_rate, float threshold_db) :
|
||||
str << name() << unique_id();
|
||||
d_me = pmt::pmt_string_to_symbol(str.str());
|
||||
d_key = pmt::pmt_string_to_symbol("preamble_found");
|
||||
//set_history(d_check_width);
|
||||
set_history(d_check_width);
|
||||
}
|
||||
|
||||
int air_modes_preamble::work(int noutput_items,
|
||||
@ -64,7 +64,7 @@ int air_modes_preamble::work(int noutput_items,
|
||||
|
||||
float *outraw = (float *) output_items[0];
|
||||
|
||||
int size = noutput_items - d_check_width;
|
||||
int size = noutput_items;// - d_check_width;
|
||||
int pulse_offsets[4];
|
||||
float bit_energies[4];
|
||||
|
||||
|
||||
@ -46,7 +46,7 @@ air_modes_slicer_sptr air_make_modes_slicer(int channel_rate, gr_msg_queue_sptr
|
||||
|
||||
air_modes_slicer::air_modes_slicer(int channel_rate, gr_msg_queue_sptr queue) :
|
||||
gr_sync_block ("modes_slicer",
|
||||
gr_make_io_signature2 (2, 2, sizeof(float), sizeof(unsigned char)), //stream 0 is received data, stream 1 is binary preamble detector output
|
||||
gr_make_io_signature (1, 1, sizeof(float)), //stream 0 is received data, stream 1 is binary preamble detector output
|
||||
gr_make_io_signature (0, 0, 0) )
|
||||
{
|
||||
//initialize private data here
|
||||
@ -74,222 +74,222 @@ int air_modes_slicer::work(int noutput_items,
|
||||
{
|
||||
//do things!
|
||||
const float *inraw = (const float *) input_items[0];
|
||||
const unsigned char *inattrib = (const unsigned char *) input_items[1];
|
||||
int size = noutput_items - d_check_width; //since it's a sync block, i assume that it runs with ninput_items = noutput_items
|
||||
|
||||
int i;
|
||||
|
||||
std::vector<pmt::pmt_t> tags;
|
||||
uint64_t abs_sample_cnt = nitems_read(0);
|
||||
get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + size, pmt::pmt_string_to_symbol("frame_info"));
|
||||
std::vector<pmt::pmt_t>::iterator tag_iter;
|
||||
|
||||
for(tag_iter = tags.begin(); tag_iter != tags.end(); tag_iter++) {
|
||||
uint64_t i = gr_tags::get_nitems(*tag_iter) - abs_sample_cnt;
|
||||
modes_packet rx_packet;
|
||||
framer_packet_type packet_type = framer_packet_type(pmt::pmt_to_long(gr_tags::get_value(*tag_iter)));
|
||||
|
||||
for(i = 0; i < size; i++) {
|
||||
if(inattrib[i] == framer_packet_type(Short_Packet) || inattrib[i] == framer_packet_type(Long_Packet)) { //if there's a packet starting here....
|
||||
modes_packet rx_packet;
|
||||
int packet_length;
|
||||
packet_length = packet_type == framer_packet_type(Short_Packet) ? 56 : 112;
|
||||
|
||||
int packet_length = 112;
|
||||
if(inattrib[i] == framer_packet_type(Short_Packet)) packet_length = 56;
|
||||
|
||||
rx_packet.type = framer_packet_type(inattrib[i]);
|
||||
memset(&rx_packet.data, 0x00, 14 * sizeof(unsigned char));
|
||||
memset(&rx_packet.lowconfbits, 0x00, 24 * sizeof(unsigned char));
|
||||
rx_packet.numlowconf = 0;
|
||||
rx_packet.type = packet_type;
|
||||
memset(&rx_packet.data, 0x00, 14 * sizeof(unsigned char));
|
||||
memset(&rx_packet.lowconfbits, 0x00, 24 * sizeof(unsigned char));
|
||||
rx_packet.numlowconf = 0;
|
||||
|
||||
//let's use the preamble marker to get a reference level for the packet
|
||||
rx_packet.reference_level = (bit_energy(&inraw[i], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(1.0*d_samples_per_symbol)], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(3.5*d_samples_per_symbol)], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(4.5*d_samples_per_symbol)], d_samples_per_chip)) / 4;
|
||||
rx_packet.reference_level = (bit_energy(&inraw[i], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(1.0*d_samples_per_symbol)], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(3.5*d_samples_per_symbol)], d_samples_per_chip)
|
||||
+ bit_energy(&inraw[i+int(4.5*d_samples_per_symbol)], d_samples_per_chip)) / 4;
|
||||
|
||||
i += 8 * d_samples_per_symbol; //move to the center of the first bit of the data
|
||||
i += 8 * d_samples_per_symbol; //move to the center of the first bit of the data
|
||||
|
||||
//here we calculate the total energy contained in each chip of the symbol
|
||||
for(int j = 0; j < packet_length; j++) {
|
||||
int firstchip = i+j*d_samples_per_symbol;
|
||||
int secondchip = firstchip + d_samples_per_chip;
|
||||
bool slice, confidence;
|
||||
float firstchip_energy=0, secondchip_energy=0;
|
||||
//here we calculate the total energy contained in each chip of the symbol
|
||||
for(int j = 0; j < packet_length; j++) {
|
||||
int firstchip = i+j*d_samples_per_symbol;
|
||||
int secondchip = firstchip + d_samples_per_chip;
|
||||
bool slice, confidence;
|
||||
float firstchip_energy=0, secondchip_energy=0;
|
||||
|
||||
firstchip_energy = bit_energy(&inraw[firstchip], d_samples_per_chip);
|
||||
secondchip_energy = bit_energy(&inraw[secondchip], d_samples_per_chip);
|
||||
firstchip_energy = bit_energy(&inraw[firstchip], d_samples_per_chip);
|
||||
secondchip_energy = bit_energy(&inraw[secondchip], d_samples_per_chip);
|
||||
|
||||
//3dB limits for bit slicing and confidence measurement
|
||||
float highlimit=rx_packet.reference_level*2;
|
||||
float lowlimit=rx_packet.reference_level*0.5;
|
||||
bool firstchip_inref = ((firstchip_energy > lowlimit) && (firstchip_energy < highlimit));
|
||||
bool secondchip_inref = ((secondchip_energy > lowlimit) && (secondchip_energy < highlimit));
|
||||
//3dB limits for bit slicing and confidence measurement
|
||||
float highlimit=rx_packet.reference_level*2;
|
||||
float lowlimit=rx_packet.reference_level*0.5;
|
||||
bool firstchip_inref = ((firstchip_energy > lowlimit) && (firstchip_energy < highlimit));
|
||||
bool secondchip_inref = ((secondchip_energy > lowlimit) && (secondchip_energy < highlimit));
|
||||
|
||||
//these two lines for a super simple naive slicer.
|
||||
// slice = firstchip_energy > secondchip_energy;
|
||||
// confidence = bool(int(firstchip_inref) + int(secondchip_inref)); //one and only one chip in the reference zone
|
||||
//these two lines for a super simple naive slicer.
|
||||
// slice = firstchip_energy > secondchip_energy;
|
||||
// confidence = bool(int(firstchip_inref) + int(secondchip_inref)); //one and only one chip in the reference zone
|
||||
|
||||
//below is the Lincoln Labs slicer. it may produce greater bit errors. supposedly it is more resistant to mode A/C FRUIT.
|
||||
//below is the Lincoln Labs slicer. it may produce greater bit errors. supposedly it is more resistant to mode A/C FRUIT.
|
||||
//see http://adsb.tc.faa.gov/WG3_Meetings/Meeting8/Squitter-Lon.pdf
|
||||
if(firstchip_inref && !secondchip_inref) {
|
||||
slice = 1;
|
||||
confidence = 1;
|
||||
}
|
||||
else if(secondchip_inref && !firstchip_inref) {
|
||||
slice = 0;
|
||||
confidence = 1;
|
||||
}
|
||||
else if(firstchip_inref && secondchip_inref) {
|
||||
slice = firstchip_energy > secondchip_energy;
|
||||
confidence = 0;
|
||||
}
|
||||
else if(!firstchip_inref && !secondchip_inref) { //in this case, we determine the bit by whichever is larger, and we determine high confidence if the low chip is 6dB below reference.
|
||||
slice = firstchip_energy > secondchip_energy;
|
||||
if(slice) {
|
||||
if(secondchip_energy < lowlimit * 0.5) confidence = 1;
|
||||
else confidence = 0;
|
||||
} else {
|
||||
if(firstchip_energy < lowlimit * 0.5) confidence = 1;
|
||||
else confidence = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//put the data into the packet
|
||||
if(firstchip_inref && !secondchip_inref) {
|
||||
slice = 1;
|
||||
confidence = 1;
|
||||
}
|
||||
else if(secondchip_inref && !firstchip_inref) {
|
||||
slice = 0;
|
||||
confidence = 1;
|
||||
}
|
||||
else if(firstchip_inref && secondchip_inref) {
|
||||
slice = firstchip_energy > secondchip_energy;
|
||||
confidence = 0;
|
||||
}
|
||||
else if(!firstchip_inref && !secondchip_inref) { //in this case, we determine the bit by whichever is larger, and we determine high confidence if the low chip is 6dB below reference.
|
||||
slice = firstchip_energy > secondchip_energy;
|
||||
if(slice) {
|
||||
rx_packet.data[j/8] += 1 << (7-(j%8));
|
||||
}
|
||||
//put the confidence decision into the packet
|
||||
if(confidence) {
|
||||
//rx_packet.confidence[j/8] += 1 << (7-(j%8));
|
||||
if(secondchip_energy < lowlimit * 0.5) confidence = 1;
|
||||
else confidence = 0;
|
||||
} else {
|
||||
if(rx_packet.numlowconf < 24) rx_packet.lowconfbits[rx_packet.numlowconf++] = j;
|
||||
if(firstchip_energy < lowlimit * 0.5) confidence = 1;
|
||||
else confidence = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/******************** BEGIN TIMESTAMP BS ******************/
|
||||
rx_packet.timestamp_secs = 0;
|
||||
rx_packet.timestamp_frac = 0;
|
||||
|
||||
uint64_t abs_sample_cnt = nitems_read(0);
|
||||
std::vector<pmt::pmt_t> tags;
|
||||
uint64_t timestamp_secs, timestamp_sample, timestamp_delta;
|
||||
double timestamp_frac;
|
||||
|
||||
pmt::pmt_t timestamp;
|
||||
|
||||
get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + i, pmt::pmt_string_to_symbol("packet_time_stamp"));
|
||||
//tags.back() is the most recent timestamp, then.
|
||||
if(tags.size() > 0) {
|
||||
//if nobody but the USRP is producing timestamps this isn't necessary
|
||||
//std::sort(tags.begin(), tags.end(), pmtcompare);
|
||||
timestamp = tags.back();
|
||||
|
||||
timestamp_secs = pmt_to_uint64(pmt_tuple_ref(gr_tags::get_value(timestamp), 0));
|
||||
timestamp_frac = pmt_to_double(pmt_tuple_ref(gr_tags::get_value(timestamp), 1));
|
||||
timestamp_sample = gr_tags::get_nitems(timestamp);
|
||||
//now we have to offset the timestamp based on the current sample number
|
||||
timestamp_delta = (abs_sample_cnt + i) - timestamp_sample;
|
||||
|
||||
timestamp_frac += timestamp_delta * d_secs_per_sample;
|
||||
if(timestamp_frac > 1.0) {
|
||||
timestamp_frac -= 1.0;
|
||||
timestamp_secs++;
|
||||
}
|
||||
|
||||
rx_packet.timestamp_secs = timestamp_secs;
|
||||
rx_packet.timestamp_frac = timestamp_frac;
|
||||
//put the data into the packet
|
||||
if(slice) {
|
||||
rx_packet.data[j/8] += 1 << (7-(j%8));
|
||||
}
|
||||
|
||||
/******************* END TIMESTAMP BS *********************/
|
||||
|
||||
//increment for the next round
|
||||
i += packet_length * d_samples_per_symbol;
|
||||
|
||||
//here you might want to traverse the whole packet and if you find all 0's, just toss it. don't know why these packets turn up, but they pass ECC.
|
||||
bool zeroes = 1;
|
||||
for(int m = 0; m < 14; m++) {
|
||||
if(rx_packet.data[m]) zeroes = 0;
|
||||
//put the confidence decision into the packet
|
||||
if(confidence) {
|
||||
//rx_packet.confidence[j/8] += 1 << (7-(j%8));
|
||||
} else {
|
||||
if(rx_packet.numlowconf < 24) rx_packet.lowconfbits[rx_packet.numlowconf++] = j;
|
||||
}
|
||||
if(zeroes) continue; //toss it
|
||||
|
||||
rx_packet.message_type = (rx_packet.data[0] >> 3) & 0x1F; //get the message type for the parser to conveniently use, and to make decisions on ECC methods
|
||||
|
||||
//we note that short packets other than type 11 CANNOT be reliably decoded, since the a/c address is encoded with the parity bits.
|
||||
//mode S in production ATC use relies on the fact that these short packets are reply squitters to transponder requests,
|
||||
//and so the radar should already know the expected a/c reply address. so, error-correction makes no sense on short packets (other than type 11)
|
||||
//this means two things: first, we will DROP short packets (other than type 11) with ANY low-confidence bits, since we can't be confident that we're seeing real data
|
||||
//second, we will only perform error correction on LONG type S packets.
|
||||
|
||||
//the limitation on short packets means in practice a short packet has to be at least 6dB above the noise floor in order to be output. long packets can theoretically
|
||||
//be decoded at the 3dB SNR point. below that and the preamble detector won't fire.
|
||||
}
|
||||
|
||||
//in practice, this limitation causes you to see a HUGE number of type 11 packets which pass CRC through random luck.
|
||||
//these packets necessarily have large numbers of low-confidence bits, so we toss them with an arbitrary limit of 10.
|
||||
//that's a pretty dang low threshold so i don't think we'll drop many legit packets
|
||||
|
||||
if(rx_packet.type == Short_Packet && rx_packet.message_type != 11 && rx_packet.numlowconf != 0) continue;
|
||||
if(rx_packet.type == Short_Packet && rx_packet.message_type == 11 && rx_packet.numlowconf >= 10) continue;
|
||||
/******************** BEGIN TIMESTAMP BS ******************/
|
||||
rx_packet.timestamp_secs = 0;
|
||||
rx_packet.timestamp_frac = 0;
|
||||
|
||||
uint64_t abs_sample_cnt = nitems_read(0);
|
||||
std::vector<pmt::pmt_t> tags;
|
||||
uint64_t timestamp_secs, timestamp_sample, timestamp_delta;
|
||||
double timestamp_frac;
|
||||
|
||||
pmt::pmt_t timestamp;
|
||||
|
||||
get_tags_in_range(tags, 0, abs_sample_cnt, abs_sample_cnt + i, pmt::pmt_string_to_symbol("packet_time_stamp"));
|
||||
//tags.back() is the most recent timestamp, then.
|
||||
if(tags.size() > 0) {
|
||||
//if nobody but the USRP is producing timestamps this isn't necessary
|
||||
//std::sort(tags.begin(), tags.end(), pmtcompare);
|
||||
timestamp = tags.back();
|
||||
|
||||
timestamp_secs = pmt_to_uint64(pmt_tuple_ref(gr_tags::get_value(timestamp), 0));
|
||||
timestamp_frac = pmt_to_double(pmt_tuple_ref(gr_tags::get_value(timestamp), 1));
|
||||
timestamp_sample = gr_tags::get_nitems(timestamp);
|
||||
//now we have to offset the timestamp based on the current sample number
|
||||
timestamp_delta = (abs_sample_cnt + i) - timestamp_sample;
|
||||
|
||||
//if(rx_packet.numlowconf >= 24) continue; //don't even try, this is the maximum number of errors ECC could possibly correct
|
||||
//the above line should be part of ECC, and only checked if the message has parity errors
|
||||
|
||||
rx_packet.parity = modes_check_parity(rx_packet.data, packet_length);
|
||||
|
||||
if(rx_packet.parity && rx_packet.type == Long_Packet) {
|
||||
// long before = rx_packet.parity;
|
||||
bruteResultTypeDef bruteResult = modes_ec_brute(rx_packet);
|
||||
|
||||
if(bruteResult == No_Solution) {
|
||||
//printf("No solution!\n");
|
||||
continue;
|
||||
} else if(bruteResult == Multiple_Solutions) {
|
||||
// printf("Multiple solutions!\n");
|
||||
continue;
|
||||
} else if(bruteResult == Too_Many_LCBs) {
|
||||
//printf("Too many LCBs (%i)!\n", rx_packet.numlowconf);
|
||||
continue;
|
||||
} else if(bruteResult == No_Error) {
|
||||
// printf("No error!\n");
|
||||
} else if(bruteResult == Solution_Found) {
|
||||
// printf("Solution found for %i LCBs!\n", rx_packet.numlowconf);
|
||||
}
|
||||
// rx_packet.parity = modes_check_parity(rx_packet.data, packet_length);
|
||||
// if(rx_packet.parity) printf("Error: packet fails parity check after correction, was %x, now %x\n", before, rx_packet.parity);
|
||||
timestamp_frac += timestamp_delta * d_secs_per_sample;
|
||||
if(timestamp_frac > 1.0) {
|
||||
timestamp_frac -= 1.0;
|
||||
timestamp_secs++;
|
||||
}
|
||||
|
||||
rx_packet.timestamp_secs = timestamp_secs;
|
||||
rx_packet.timestamp_frac = timestamp_frac;
|
||||
}
|
||||
|
||||
// if(rx_packet.parity && rx_packet.type == Long_Packet) printf("Error! Bad packet forwarded to the queue.\n");
|
||||
//now we have a complete packet with confidence data, let's print it to the message queue
|
||||
//here, rather than send the entire packet, since we've already done parity checking and ECC in C++, we'll
|
||||
//send just the data (no confidence bits), separated into fields for easier parsing.
|
||||
/******************* END TIMESTAMP BS *********************/
|
||||
|
||||
//increment for the next round
|
||||
|
||||
//we'll replicate some data by sending the message type as the first field, followed by the first 8+24=32 bits of the packet, followed by
|
||||
//56 long packet data bits if applicable (zero-padded if not), followed by parity
|
||||
//here you might want to traverse the whole packet and if you find all 0's, just toss it. don't know why these packets turn up, but they pass ECC.
|
||||
bool zeroes = 1;
|
||||
for(int m = 0; m < 14; m++) {
|
||||
if(rx_packet.data[m]) zeroes = 0;
|
||||
}
|
||||
if(zeroes) continue; //toss it
|
||||
|
||||
d_payload.str("");
|
||||
rx_packet.message_type = (rx_packet.data[0] >> 3) & 0x1F; //get the message type for the parser to conveniently use, and to make decisions on ECC methods
|
||||
|
||||
d_payload << std::dec << std::setw(2) << std::setfill('0') << rx_packet.message_type << std::hex << " ";
|
||||
//we note that short packets other than type 11 CANNOT be reliably decoded, since the a/c address is encoded with the parity bits.
|
||||
//mode S in production ATC use relies on the fact that these short packets are reply squitters to transponder requests,
|
||||
//and so the radar should already know the expected a/c reply address. so, error-correction makes no sense on short packets (other than type 11)
|
||||
//this means two things: first, we will DROP short packets (other than type 11) with ANY low-confidence bits, since we can't be confident that we're seeing real data
|
||||
//second, we will only perform error correction on LONG type S packets.
|
||||
|
||||
for(int m = 0; m < 4; m++) {
|
||||
//the limitation on short packets means in practice a short packet has to be at least 6dB above the noise floor in order to be output. long packets can theoretically
|
||||
//be decoded at the 3dB SNR point. below that and the preamble detector won't fire.
|
||||
|
||||
//in practice, this limitation causes you to see a HUGE number of type 11 packets which pass CRC through random luck.
|
||||
//these packets necessarily have large numbers of low-confidence bits, so we toss them with an arbitrary limit of 10.
|
||||
//that's a pretty dang low threshold so i don't think we'll drop many legit packets
|
||||
|
||||
if(rx_packet.type == Short_Packet && rx_packet.message_type != 11 && rx_packet.numlowconf != 0) continue;
|
||||
if(rx_packet.type == Short_Packet && rx_packet.message_type == 11 && rx_packet.numlowconf >= 10) continue;
|
||||
|
||||
|
||||
//if(rx_packet.numlowconf >= 24) continue; //don't even try, this is the maximum number of errors ECC could possibly correct
|
||||
//the above line should be part of ECC, and only checked if the message has parity errors
|
||||
|
||||
rx_packet.parity = modes_check_parity(rx_packet.data, packet_length);
|
||||
|
||||
if(rx_packet.parity && rx_packet.type == Long_Packet) {
|
||||
// long before = rx_packet.parity;
|
||||
bruteResultTypeDef bruteResult = modes_ec_brute(rx_packet);
|
||||
|
||||
if(bruteResult == No_Solution) {
|
||||
//printf("No solution!\n");
|
||||
continue;
|
||||
} else if(bruteResult == Multiple_Solutions) {
|
||||
// printf("Multiple solutions!\n");
|
||||
continue;
|
||||
} else if(bruteResult == Too_Many_LCBs) {
|
||||
//printf("Too many LCBs (%i)!\n", rx_packet.numlowconf);
|
||||
continue;
|
||||
} else if(bruteResult == No_Error) {
|
||||
// printf("No error!\n");
|
||||
} else if(bruteResult == Solution_Found) {
|
||||
// printf("Solution found for %i LCBs!\n", rx_packet.numlowconf);
|
||||
}
|
||||
// rx_packet.parity = modes_check_parity(rx_packet.data, packet_length);
|
||||
// if(rx_packet.parity) printf("Error: packet fails parity check after correction, was %x, now %x\n", before, rx_packet.parity);
|
||||
}
|
||||
|
||||
// if(rx_packet.parity && rx_packet.type == Long_Packet) printf("Error! Bad packet forwarded to the queue.\n");
|
||||
//now we have a complete packet with confidence data, let's print it to the message queue
|
||||
//here, rather than send the entire packet, since we've already done parity checking and ECC in C++, we'll
|
||||
//send just the data (no confidence bits), separated into fields for easier parsing.
|
||||
//we'll replicate some data by sending the message type as the first field, followed by the first 8+24=32 bits of the packet, followed by
|
||||
//56 long packet data bits if applicable (zero-padded if not), followed by parity
|
||||
|
||||
d_payload.str("");
|
||||
|
||||
d_payload << std::dec << std::setw(2) << std::setfill('0') << rx_packet.message_type << std::hex << " ";
|
||||
|
||||
for(int m = 0; m < 4; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
d_payload << " ";
|
||||
if(packet_length == 112) {
|
||||
for(int m = 4; m < 11; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
d_payload << " ";
|
||||
if(packet_length == 112) {
|
||||
for(int m = 4; m < 11; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
d_payload << " ";
|
||||
for(int m = 11; m < 14; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
} else {
|
||||
for(int m = 4; m < 11; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(0);
|
||||
}
|
||||
d_payload << " ";
|
||||
for(int m = 4; m < 7; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
for(int m = 11; m < 14; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
} else {
|
||||
for(int m = 4; m < 11; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(0);
|
||||
}
|
||||
d_payload << " ";
|
||||
for(int m = 4; m < 7; m++) {
|
||||
d_payload << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
|
||||
}
|
||||
|
||||
d_payload << " " << std::setw(6) << rx_packet.parity << " " << std::dec << rx_packet.reference_level
|
||||
<< " " << rx_packet.timestamp_secs
|
||||
<< " " << std::setprecision(10) << std::setw(10) << rx_packet.timestamp_frac;
|
||||
|
||||
gr_message_sptr msg = gr_make_message_from_string(std::string(d_payload.str()));
|
||||
d_queue->handle(msg);
|
||||
|
||||
}
|
||||
|
||||
d_payload << " " << std::setw(6) << rx_packet.parity << " " << std::dec << rx_packet.reference_level
|
||||
<< " " << rx_packet.timestamp_secs
|
||||
<< " " << std::setprecision(10) << std::setw(10) << rx_packet.timestamp_frac;
|
||||
gr_message_sptr msg = gr_make_message_from_string(std::string(d_payload.str()));
|
||||
d_queue->handle(msg);
|
||||
|
||||
}
|
||||
|
||||
return size;
|
||||
|
||||
@ -96,28 +96,13 @@ class adsb_rx_block (gr.top_block):
|
||||
self.preamble = air.modes_preamble(rate, options.threshold)
|
||||
self.framer = air.modes_framer(rate)
|
||||
self.slicer = air.modes_slicer(rate, queue)
|
||||
|
||||
#self.nullsink = gr.file_sink(gr.sizeof_gr_complex, "/dev/null")
|
||||
|
||||
#self.connect(self.u, self.nullsink)
|
||||
|
||||
# self.connect(self.u, self.demod, self.filter)
|
||||
# self.connect(self.filter, self.avg)
|
||||
# self.connect(self.filter, (self.preamble, 0))
|
||||
# self.connect(self.avg, (self.preamble, 1))
|
||||
# self.connect(self.filter, (self.framer, 0))
|
||||
# self.connect(self.preamble, (self.framer, 1))
|
||||
# self.connect(self.filter, (self.slicer, 0))
|
||||
# self.connect(self.framer, (self.slicer, 1))
|
||||
|
||||
#use this flowgraph instead to omit the filter
|
||||
self.connect(self.u, self.demod)
|
||||
self.connect(self.demod, self.avg)
|
||||
self.connect(self.demod, (self.preamble, 0))
|
||||
self.connect(self.avg, (self.preamble, 1))
|
||||
self.connect((self.preamble, 0), (self.framer, 0))
|
||||
self.connect(self.demod, (self.slicer, 0))
|
||||
self.connect(self.framer, (self.slicer, 1))
|
||||
self.connect(self.framer, self.slicer)
|
||||
|
||||
def tune(self, freq):
|
||||
result = self.u.set_center_freq(freq, 0)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user