mwalbeck/rtl_433
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

minor: Refactor code for pulse_data

Browse source
This commit is contained in:
Christian W. Zuckschwerdt 2022-09-19 09:29:18 +02:00
parent aae921c1db
commit 2119ad6319
7 changed files with 389 additions and 341 deletions

81
include/pulse_data.h Normal file
View file

@ -0,0 +1,81 @@
/** @file
Pulse data structure and functions.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2022 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
*/
#ifndef INCLUDE_PULSE_DATA_H_
#define INCLUDE_PULSE_DATA_H_
#include <stdint.h>
#include <stdio.h>
#include "data.h"
#define PD_MAX_PULSES 1200 // Maximum number of pulses before forcing End Of Package
#define PD_MIN_PULSES 16 // Minimum number of pulses before declaring a proper package
#define PD_MIN_PULSE_SAMPLES 10 // Minimum number of samples in a pulse for proper detection
#define PD_MIN_GAP_MS 10 // Minimum gap size in milliseconds to exceed to declare End Of Package
#define PD_MAX_GAP_MS 100 // Maximum gap size in milliseconds to exceed to declare End Of Package
#define PD_MAX_GAP_RATIO 10 // Ratio gap/pulse width to exceed to declare End Of Package (heuristic)
#define PD_MAX_PULSE_MS 100 // Pulse width in ms to exceed to declare End Of Package (e.g. for non OOK packages)
/// Data for a compact representation of generic pulse train.
typedef struct pulse_data {
uint64_t offset; ///< Offset to first pulse in number of samples from start of stream.
uint32_t sample_rate; ///< Sample rate the pulses are recorded with.
unsigned depth_bits; ///< Sample depth in bits.
unsigned start_ago; ///< Start of first pulse in number of samples ago.
unsigned end_ago; ///< End of last pulse in number of samples ago.
unsigned int num_pulses;
int pulse[PD_MAX_PULSES]; ///< Width of pulses (high) in number of samples.
int gap[PD_MAX_PULSES]; ///< Width of gaps between pulses (low) in number of samples.
int ook_low_estimate; ///< Estimate for the OOK low level (base noise level) at beginning of package.
int ook_high_estimate; ///< Estimate for the OOK high level at end of package.
int fsk_f1_est; ///< Estimate for the F1 frequency for FSK.
int fsk_f2_est; ///< Estimate for the F2 frequency for FSK.
float freq1_hz;
float freq2_hz;
float centerfreq_hz;
float range_db;
float rssi_db;
float snr_db;
float noise_db;
} pulse_data_t;
/// Clear the content of a pulse_data_t structure.
void pulse_data_clear(pulse_data_t *data);
/// Shift out part of the data to make room for more.
void pulse_data_shift(pulse_data_t *data);
/// Print the content of a pulse_data_t structure (for debug).
void pulse_data_print(pulse_data_t const *data);
/// Dump the content of a pulse_data_t structure as raw binary.
void pulse_data_dump_raw(uint8_t *buf, unsigned len, uint64_t buf_offset, pulse_data_t const *data, uint8_t bits);
/// Print a header for the VCD format.
void pulse_data_print_vcd_header(FILE *file, uint32_t sample_rate);
/// Print the content of a pulse_data_t structure in VCD format.
void pulse_data_print_vcd(FILE *file, pulse_data_t const *data, int ch_id);
/// Read the next pulse_data_t structure from OOK text.
void pulse_data_load(FILE *file, pulse_data_t *data, uint32_t sample_rate);
/// Print a header for the OOK text format.
void pulse_data_print_pulse_header(FILE *file);
/// Print the content of a pulse_data_t structure as OOK text.
void pulse_data_dump(FILE *file, pulse_data_t *data);
/// Print the content of a pulse_data_t structure as OOK json.
data_t *pulse_data_print_data(pulse_data_t *data);
#endif /* INCLUDE_PULSE_DATA_H_ */

93
include/pulse_detect.h
View file

@ -2,6 +2,7 @@
Pulse detection functions.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2020 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -14,98 +15,25 @@
#include <stdint.h>
#include <stdio.h>
#include "pulse_data.h"
#include "data.h"
#define PD_MAX_PULSES 1200 // Maximum number of pulses before forcing End Of Package
#define PD_MIN_PULSES 16 // Minimum number of pulses before declaring a proper package
#define PD_MIN_PULSE_SAMPLES 10 // Minimum number of samples in a pulse for proper detection
#define PD_MIN_GAP_MS 10 // Minimum gap size in milliseconds to exceed to declare End Of Package
#define PD_MAX_GAP_MS 100 // Maximum gap size in milliseconds to exceed to declare End Of Package
#define PD_MAX_GAP_RATIO 10 // Ratio gap/pulse width to exceed to declare End Of Package (heuristic)
#define PD_MAX_PULSE_MS 100 // Pulse width in ms to exceed to declare End Of Package (e.g. for non OOK packages)
/// Data for a compact representation of generic pulse train.
typedef struct pulse_data {
uint64_t offset; ///< Offset to first pulse in number of samples from start of stream.
uint32_t sample_rate; ///< Sample rate the pulses are recorded with.
unsigned depth_bits; ///< Sample depth in bits.
unsigned start_ago; ///< Start of first pulse in number of samples ago.
unsigned end_ago; ///< End of last pulse in number of samples ago.
unsigned int num_pulses;
int pulse[PD_MAX_PULSES]; ///< Width of pulses (high) in number of samples.
int gap[PD_MAX_PULSES]; ///< Width of gaps between pulses (low) in number of samples.
int ook_low_estimate; ///< Estimate for the OOK low level (base noise level) at beginning of package.
int ook_high_estimate; ///< Estimate for the OOK high level at end of package.
int fsk_f1_est; ///< Estimate for the F1 frequency for FSK.
int fsk_f2_est; ///< Estimate for the F2 frequency for FSK.
float freq1_hz;
float freq2_hz;
float centerfreq_hz;
float range_db;
float rssi_db;
float snr_db;
float noise_db;
} pulse_data_t;
// Package types
/// Package types.
enum package_types {
PULSE_DATA_OOK = 1,
PULSE_DATA_FSK = 2,
};
/// state data for pulse_detect_fsk_ functions
typedef struct {
unsigned int fsk_pulse_length; ///< Counter for internal FSK pulse detection
enum {
PD_FSK_STATE_INIT = 0, ///< Initial frequency estimation
PD_FSK_STATE_FH = 1, ///< High frequency (pulse)
PD_FSK_STATE_FL = 2, ///< Low frequency (gap)
PD_FSK_STATE_ERROR = 3 ///< Error - stay here until cleared
} fsk_state;
int fm_f1_est; ///< Estimate for the F1 frequency for FSK
int fm_f2_est; ///< Estimate for the F2 frequency for FSK
int16_t var_test_max;
int16_t var_test_min;
int16_t maxx;
int16_t minn;
int16_t midd;
int skip_samples;
} pulse_detect_fsk_t;
/// FSK pulse detector to use.
enum {
FSK_PULSE_DETECT_OLD,
FSK_PULSE_DETECT_NEW,
FSK_PULSE_DETECT_AUTO,
FSK_PULSE_DETECT_END,
};
typedef struct pulse_detect pulse_detect_t;
/// Clear the content of a pulse_data_t structure.
void pulse_data_clear(pulse_data_t *data);
/// Shift out part of the data to make room for more.
void pulse_data_shift(pulse_data_t *data);
/// Print the content of a pulse_data_t structure (for debug).
void pulse_data_print(pulse_data_t const *data);
/// Dump the content of a pulse_data_t structure as raw binary.
void pulse_data_dump_raw(uint8_t *buf, unsigned len, uint64_t buf_offset, pulse_data_t const *data, uint8_t bits);
/// Print a header for the VCD format.
void pulse_data_print_vcd_header(FILE *file, uint32_t sample_rate);
/// Print the content of a pulse_data_t structure in VCD format.
void pulse_data_print_vcd(FILE *file, pulse_data_t const *data, int ch_id);
/// Read the next pulse_data_t structure from OOK text.
void pulse_data_load(FILE *file, pulse_data_t *data, uint32_t sample_rate);
/// Print a header for the OOK text format.
void pulse_data_print_pulse_header(FILE *file);
/// Print the content of a pulse_data_t structure as OOK text.
void pulse_data_dump(FILE *file, pulse_data_t *data);
/// Print the content of a pulse_data_t structure as OOK json.
data_t *pulse_data_print_data(pulse_data_t *data);
pulse_detect_t *pulse_detect_create(void);
void pulse_detect_free(pulse_detect_t *pulse_detect);
@ -139,5 +67,4 @@ void pulse_detect_set_levels(pulse_detect_t *pulse_detect, int use_mag_est, floa
/// @retval 2 FSK package is detected (but all sample data is still not completely processed)
int pulse_detect_package(pulse_detect_t *pulse_detect, int16_t const *envelope_data, int16_t const *fm_data, int len, uint32_t samp_rate, uint64_t sample_offset, pulse_data_t *pulses, pulse_data_t *fsk_pulses, unsigned fpdm);
#endif /* INCLUDE_PULSE_DETECT_H_ */

68
include/pulse_detect_fsk.h
View file

@ -1,9 +1,9 @@
/** @file
Pulse detect functions.
FSK pulse detector
Pulse detect functions, FSK pulse detector.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2019 Benjamin Larsson.
Copyright (C) 2022 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -14,18 +14,64 @@
#ifndef INCLUDE_PULSE_DETECT_FSK_H_
#define INCLUDE_PULSE_DETECT_FSK_H_
#include "pulse_data.h"
#include <stdint.h>
#include "pulse_detect.h"
/// State data for pulse_detect_fsk_ functions.
///
/// This should be private/opaque but the OOK pulse_detect uses this.
typedef struct {
unsigned int fsk_pulse_length; ///< Counter for internal FSK pulse detection
enum {
PD_FSK_STATE_INIT = 0, ///< Initial frequency estimation
PD_FSK_STATE_FH = 1, ///< High frequency (pulse)
PD_FSK_STATE_FL = 2, ///< Low frequency (gap)
PD_FSK_STATE_ERROR = 3 ///< Error - stay here until cleared
} fsk_state;
int fm_f1_est; ///< Estimate for the F1 frequency for FSK
int fm_f2_est; ///< Estimate for the F2 frequency for FSK
int16_t var_test_max;
int16_t var_test_min;
int16_t maxx;
int16_t minn;
int16_t midd;
int skip_samples;
} pulse_detect_fsk_t;
/// Init/clear Demodulate Frequency Shift Keying (FSK) state.
///
/// @param s Internal state
void pulse_detect_fsk_init(pulse_detect_fsk_t *s);
/// Demodulate Frequency Shift Keying (FSK) sample by sample.
///
/// Function is stateful between calls
/// Builds estimate for initial frequency. When frequency deviates more than a
/// threshold value it will determine whether the deviation is positive or negative
/// to classify it as a pulse or gap. It will then transition to other state (F1 or F2)
/// and build an estimate of the other frequency. It will then transition back and forth when current
/// frequency is closer to other frequency estimate.
/// Includes spurious suppression by coalescing pulses when pulse/gap widths are too short.
/// Pulses equal higher frequency (F1) and Gaps equal lower frequency (F2)
/// @param s Internal state
/// @param fm_n One single sample of FM data
/// @param fsk_pulses Will return a pulse_data_t structure for FSK demodulated data
void pulse_detect_fsk_classic(pulse_detect_fsk_t *s, int16_t fm_n, pulse_data_t *fsk_pulses);
/// Wrap up FSK modulation and store last data at End Of Package.
///
/// @param s Internal state
/// @param fsk_pulses Pulse_data_t structure for FSK demodulated data
void pulse_detect_fsk_wrap_up(pulse_detect_fsk_t *s, pulse_data_t *fsk_pulses);
/// Demodulate Frequency Shift Keying (FSK) sample by sample.
///
/// Function is stateful between calls
/// @param s Internal state
/// @param fm_n One single sample of FM data
/// @param fsk_pulses Will return a pulse_data_t structure for FSK demodulated data
void pulse_detect_fsk_minmax(pulse_detect_fsk_t *s, int16_t fm_n, pulse_data_t *fsk_pulses);
#define FSK_PULSE_DETECT_START 0
enum {
FSK_PULSE_DETECT_OLD,
FSK_PULSE_DETECT_NEW,
FSK_PULSE_DETECT_AUTO,
FSK_PULSE_DETECT_END,
};
#endif /* INCLUDE_PULSE_DETECT_FSK_H_ */

1
src/CMakeLists.txt
View file

@ -29,6 +29,7 @@ add_library(r_433 STATIC
output_trigger.c
output_udp.c
pulse_analyzer.c
pulse_data.c
pulse_detect.c
pulse_detect_fsk.c
pulse_slicer.c

227
src/pulse_data.c Normal file
View file

@ -0,0 +1,227 @@
/** @file
Pulse data functions.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2022 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
*/
#include "pulse_data.h"
#include "rfraw.h"
#include "r_util.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void pulse_data_clear(pulse_data_t *data)
{
*data = (pulse_data_t const){0};
}
void pulse_data_shift(pulse_data_t *data)
{
int offs = PD_MAX_PULSES / 2; // shift out half the data
memmove(data->pulse, &data->pulse[offs], (PD_MAX_PULSES - offs) * sizeof(*data->pulse));
memmove(data->gap, &data->gap[offs], (PD_MAX_PULSES - offs) * sizeof(*data->gap));
data->num_pulses -= offs;
data->offset += offs;
}
void pulse_data_print(pulse_data_t const *data)
{
fprintf(stderr, "Pulse data: %u pulses\n", data->num_pulses);
for (unsigned n = 0; n < data->num_pulses; ++n) {
fprintf(stderr, "[%3u] Pulse: %4d, Gap: %4d, Period: %4d\n", n, data->pulse[n], data->gap[n], data->pulse[n] + data->gap[n]);
}
}
static void *bounded_memset(void *b, int c, int64_t size, int64_t offset, int64_t len)
{
if (offset < 0) {
len += offset; // reduce len by negative offset
offset = 0;
}
if (offset + len > size) {
len = size - offset; // clip excessive len
}
if (len > 0)
memset((char *)b + offset, c, (size_t)len);
return b;
}
void pulse_data_dump_raw(uint8_t *buf, unsigned len, uint64_t buf_offset, pulse_data_t const *data, uint8_t bits)
{
int64_t pos = data->offset - buf_offset;
for (unsigned n = 0; n < data->num_pulses; ++n) {
bounded_memset(buf, 0x01 | bits, len, pos, data->pulse[n]);
pos += data->pulse[n];
bounded_memset(buf, 0x01, len, pos, data->gap[n]);
pos += data->gap[n];
}
}
static inline void chk_ret(int ret)
{
if (ret < 0) {
perror("File output error");
exit(1);
}
}
void pulse_data_print_vcd_header(FILE *file, uint32_t sample_rate)
{
char time_str[LOCAL_TIME_BUFLEN];
char *timescale;
if (sample_rate <= 500000)
timescale = "1 us";
else
timescale = "100 ns";
chk_ret(fprintf(file, "$date %s $end\n", format_time_str(time_str, NULL, 0, 0)));
chk_ret(fprintf(file, "$version rtl_433 0.1.0 $end\n"));
chk_ret(fprintf(file, "$comment Acquisition at %s Hz $end\n", nice_freq(sample_rate)));
chk_ret(fprintf(file, "$timescale %s $end\n", timescale));
chk_ret(fprintf(file, "$scope module rtl_433 $end\n"));
chk_ret(fprintf(file, "$var wire 1 / FRAME $end\n"));
chk_ret(fprintf(file, "$var wire 1 ' AM $end\n"));
chk_ret(fprintf(file, "$var wire 1 \" FM $end\n"));
chk_ret(fprintf(file, "$upscope $end\n"));
chk_ret(fprintf(file, "$enddefinitions $end\n"));
chk_ret(fprintf(file, "#0 0/ 0' 0\"\n"));
}
void pulse_data_print_vcd(FILE *file, pulse_data_t const *data, int ch_id)
{
float scale;
if (data->sample_rate <= 500000)
scale = 1000000 / data->sample_rate; // unit: 1 us
else
scale = 10000000 / data->sample_rate; // unit: 100 ns
uint64_t pos = data->offset;
for (unsigned n = 0; n < data->num_pulses; ++n) {
if (n == 0)
chk_ret(fprintf(file, "#%.f 1/ 1%c\n", pos * scale, ch_id));
else
chk_ret(fprintf(file, "#%.f 1%c\n", pos * scale, ch_id));
pos += data->pulse[n];
chk_ret(fprintf(file, "#%.f 0%c\n", pos * scale, ch_id));
pos += data->gap[n];
}
if (data->num_pulses > 0)
chk_ret(fprintf(file, "#%.f 0/\n", pos * scale));
}
void pulse_data_load(FILE *file, pulse_data_t *data, uint32_t sample_rate)
{
char s[1024];
int i = 0;
int size = sizeof(data->pulse) / sizeof(*data->pulse);
pulse_data_clear(data);
data->sample_rate = sample_rate;
double to_sample = sample_rate / 1e6;
// read line-by-line
while (i < size && fgets(s, sizeof(s), file)) {
// TODO: we should parse sample rate and timescale
if (!strncmp(s, ";freq1", 6)) {
data->freq1_hz = strtol(s + 6, NULL, 10);
}
if (!strncmp(s, ";freq2", 6)) {
data->freq2_hz = strtol(s + 6, NULL, 10);
}
if (*s == ';') {
if (i) {
break; // end or next header found
}
else {
continue; // still reading a header
}
}
if (rfraw_check(s)) {
rfraw_parse(data, s);
i = data->num_pulses;
continue;
}
// parse two ints.
char *p = s;
char *endptr;
long mark = strtol(p, &endptr, 10);
p = endptr + 1;
long space = strtol(p, &endptr, 10);
// fprintf(stderr, "read: mark %ld space %ld\n", mark, space);
data->pulse[i] = (int)(to_sample * mark);
data->gap[i++] = (int)(to_sample * space);
}
// fprintf(stderr, "read %d pulses\n", i);
data->num_pulses = i;
}
void pulse_data_print_pulse_header(FILE *file)
{
char time_str[LOCAL_TIME_BUFLEN];
chk_ret(fprintf(file, ";pulse data\n"));
chk_ret(fprintf(file, ";version 1\n"));
chk_ret(fprintf(file, ";timescale 1us\n"));
// chk_ret(fprintf(file, ";samplerate %u\n", data->sample_rate));
chk_ret(fprintf(file, ";created %s\n", format_time_str(time_str, NULL, 1, 0)));
}
void pulse_data_dump(FILE *file, pulse_data_t *data)
{
char time_str[LOCAL_TIME_BUFLEN];
chk_ret(fprintf(file, ";received %s\n", format_time_str(time_str, NULL, 1, 0)));
if (data->fsk_f2_est) {
chk_ret(fprintf(file, ";fsk %u pulses\n", data->num_pulses));
chk_ret(fprintf(file, ";freq1 %.0f\n", data->freq1_hz));
chk_ret(fprintf(file, ";freq2 %.0f\n", data->freq2_hz));
}
else {
chk_ret(fprintf(file, ";ook %u pulses\n", data->num_pulses));
chk_ret(fprintf(file, ";freq1 %.0f\n", data->freq1_hz));
}
chk_ret(fprintf(file, ";centerfreq %.0f Hz\n", data->centerfreq_hz));
chk_ret(fprintf(file, ";samplerate %u Hz\n", data->sample_rate));
chk_ret(fprintf(file, ";sampledepth %u bits\n", data->depth_bits));
chk_ret(fprintf(file, ";range %.1f dB\n", data->range_db));
chk_ret(fprintf(file, ";rssi %.1f dB\n", data->rssi_db));
chk_ret(fprintf(file, ";snr %.1f dB\n", data->snr_db));
chk_ret(fprintf(file, ";noise %.1f dB\n", data->noise_db));
double to_us = 1e6 / data->sample_rate;
for (unsigned i = 0; i < data->num_pulses; ++i) {
chk_ret(fprintf(file, "%.0f %.0f\n", data->pulse[i] * to_us, data->gap[i] * to_us));
}
chk_ret(fprintf(file, ";end\n"));
}
data_t *pulse_data_print_data(pulse_data_t *data)
{
int pulses[2 * PD_MAX_PULSES];
double to_us = 1e6 / data->sample_rate;
for (unsigned i = 0; i < data->num_pulses; ++i) {
pulses[i * 2 + 0] = data->pulse[i] * to_us;
pulses[i * 2 + 1] = data->gap[i] * to_us;
}
/* clang-format off */
return data_make(
"mod", "", DATA_STRING, (data->fsk_f2_est) ? "FSK" : "OOK",
"count", "", DATA_INT, data->num_pulses,
"pulses", "", DATA_ARRAY, data_array(2 * data->num_pulses, DATA_INT, pulses),
"freq1_Hz", "", DATA_FORMAT, "%u Hz", DATA_INT, (unsigned)data->freq1_hz,
"freq2_Hz", "", DATA_COND, data->fsk_f2_est, DATA_FORMAT, "%u Hz", DATA_INT, (unsigned)data->freq2_hz,
"freq_Hz", "", DATA_INT, (unsigned)data->centerfreq_hz,
"rate_Hz", "", DATA_INT, data->sample_rate,
"depth_bits", "", DATA_INT, data->depth_bits,
"range_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->range_db,
"rssi_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->rssi_db,
"snr_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->snr_db,
"noise_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->noise_db,
NULL);
/* clang-format on */
}

221
src/pulse_detect.c
View file

@ -2,6 +2,7 @@
Pulse detection functions.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2020 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -10,226 +11,13 @@
*/
#include "pulse_detect.h"
#include "rfraw.h"
#include "pulse_detect_fsk.h"
#include "pulse_data.h"
#include "baseband.h"
#include "util.h"
#include "r_device.h"
#include "r_util.h"
#include "fatal.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void pulse_data_clear(pulse_data_t *data)
{
*data = (pulse_data_t const){0};
}
void pulse_data_shift(pulse_data_t *data)
{
int offs = PD_MAX_PULSES / 2; // shift out half the data
memmove(data->pulse, &data->pulse[offs], (PD_MAX_PULSES - offs) * sizeof(*data->pulse));
memmove(data->gap, &data->gap[offs], (PD_MAX_PULSES - offs) * sizeof(*data->gap));
data->num_pulses -= offs;
data->offset += offs;
}
void pulse_data_print(pulse_data_t const *data)
{
fprintf(stderr, "Pulse data: %u pulses\n", data->num_pulses);
for (unsigned n = 0; n < data->num_pulses; ++n) {
fprintf(stderr, "[%3u] Pulse: %4d, Gap: %4d, Period: %4d\n", n, data->pulse[n], data->gap[n], data->pulse[n] + data->gap[n]);
}
}
static void *bounded_memset(void *b, int c, int64_t size, int64_t offset, int64_t len)
{
if (offset < 0) {
len += offset; // reduce len by negative offset
offset = 0;
}
if (offset + len > size) {
len = size - offset; // clip excessive len
}
if (len > 0)
memset((char *)b + offset, c, (size_t)len);
return b;
}
void pulse_data_dump_raw(uint8_t *buf, unsigned len, uint64_t buf_offset, pulse_data_t const *data, uint8_t bits)
{
int64_t pos = data->offset - buf_offset;
for (unsigned n = 0; n < data->num_pulses; ++n) {
bounded_memset(buf, 0x01 | bits, len, pos, data->pulse[n]);
pos += data->pulse[n];
bounded_memset(buf, 0x01, len, pos, data->gap[n]);
pos += data->gap[n];
}
}
static inline void chk_ret(int ret)
{
if (ret < 0) {
perror("File output error");
exit(1);
}
}
void pulse_data_print_vcd_header(FILE *file, uint32_t sample_rate)
{
char time_str[LOCAL_TIME_BUFLEN];
char *timescale;
if (sample_rate <= 500000)
timescale = "1 us";
else
timescale = "100 ns";
chk_ret(fprintf(file, "$date %s $end\n", format_time_str(time_str, NULL, 0, 0)));
chk_ret(fprintf(file, "$version rtl_433 0.1.0 $end\n"));
chk_ret(fprintf(file, "$comment Acquisition at %s Hz $end\n", nice_freq(sample_rate)));
chk_ret(fprintf(file, "$timescale %s $end\n", timescale));
chk_ret(fprintf(file, "$scope module rtl_433 $end\n"));
chk_ret(fprintf(file, "$var wire 1 / FRAME $end\n"));
chk_ret(fprintf(file, "$var wire 1 ' AM $end\n"));
chk_ret(fprintf(file, "$var wire 1 \" FM $end\n"));
chk_ret(fprintf(file, "$upscope $end\n"));
chk_ret(fprintf(file, "$enddefinitions $end\n"));
chk_ret(fprintf(file, "#0 0/ 0' 0\"\n"));
}
void pulse_data_print_vcd(FILE *file, pulse_data_t const *data, int ch_id)
{
float scale;
if (data->sample_rate <= 500000)
scale = 1000000 / data->sample_rate; // unit: 1 us
else
scale = 10000000 / data->sample_rate; // unit: 100 ns
uint64_t pos = data->offset;
for (unsigned n = 0; n < data->num_pulses; ++n) {
if (n == 0)
chk_ret(fprintf(file, "#%.f 1/ 1%c\n", pos * scale, ch_id));
else
chk_ret(fprintf(file, "#%.f 1%c\n", pos * scale, ch_id));
pos += data->pulse[n];
chk_ret(fprintf(file, "#%.f 0%c\n", pos * scale, ch_id));
pos += data->gap[n];
}
if (data->num_pulses > 0)
chk_ret(fprintf(file, "#%.f 0/\n", pos * scale));
}
void pulse_data_load(FILE *file, pulse_data_t *data, uint32_t sample_rate)
{
char s[1024];
int i = 0;
int size = sizeof(data->pulse) / sizeof(*data->pulse);
pulse_data_clear(data);
data->sample_rate = sample_rate;
double to_sample = sample_rate / 1e6;
// read line-by-line
while (i < size && fgets(s, sizeof(s), file)) {
// TODO: we should parse sample rate and timescale
if (!strncmp(s, ";freq1", 6)) {
data->freq1_hz = strtol(s + 6, NULL, 10);
}
if (!strncmp(s, ";freq2", 6)) {
data->freq2_hz = strtol(s + 6, NULL, 10);
}
if (*s == ';') {
if (i) {
break; // end or next header found
}
else {
continue; // still reading a header
}
}
if (rfraw_check(s)) {
rfraw_parse(data, s);
i = data->num_pulses;
continue;
}
// parse two ints.
char *p = s;
char *endptr;
long mark = strtol(p, &endptr, 10);
p = endptr + 1;
long space = strtol(p, &endptr, 10);
//fprintf(stderr, "read: mark %ld space %ld\n", mark, space);
data->pulse[i] = (int)(to_sample * mark);
data->gap[i++] = (int)(to_sample * space);
}
//fprintf(stderr, "read %d pulses\n", i);
data->num_pulses = i;
}
void pulse_data_print_pulse_header(FILE *file)
{
char time_str[LOCAL_TIME_BUFLEN];
chk_ret(fprintf(file, ";pulse data\n"));
chk_ret(fprintf(file, ";version 1\n"));
chk_ret(fprintf(file, ";timescale 1us\n"));
//chk_ret(fprintf(file, ";samplerate %u\n", data->sample_rate));
chk_ret(fprintf(file, ";created %s\n", format_time_str(time_str, NULL, 1, 0)));
}
void pulse_data_dump(FILE *file, pulse_data_t *data)
{
char time_str[LOCAL_TIME_BUFLEN];
chk_ret(fprintf(file, ";received %s\n", format_time_str(time_str, NULL, 1, 0)));
if (data->fsk_f2_est) {
chk_ret(fprintf(file, ";fsk %u pulses\n", data->num_pulses));
chk_ret(fprintf(file, ";freq1 %.0f\n", data->freq1_hz));
chk_ret(fprintf(file, ";freq2 %.0f\n", data->freq2_hz));
}
else {
chk_ret(fprintf(file, ";ook %u pulses\n", data->num_pulses));
chk_ret(fprintf(file, ";freq1 %.0f\n", data->freq1_hz));
}
chk_ret(fprintf(file, ";centerfreq %.0f Hz\n", data->centerfreq_hz));
chk_ret(fprintf(file, ";samplerate %u Hz\n", data->sample_rate));
chk_ret(fprintf(file, ";sampledepth %u bits\n", data->depth_bits));
chk_ret(fprintf(file, ";range %.1f dB\n", data->range_db));
chk_ret(fprintf(file, ";rssi %.1f dB\n", data->rssi_db));
chk_ret(fprintf(file, ";snr %.1f dB\n", data->snr_db));
chk_ret(fprintf(file, ";noise %.1f dB\n", data->noise_db));
double to_us = 1e6 / data->sample_rate;
for (unsigned i = 0; i < data->num_pulses; ++i) {
chk_ret(fprintf(file, "%.0f %.0f\n", data->pulse[i] * to_us, data->gap[i] * to_us));
}
chk_ret(fprintf(file, ";end\n"));
}
data_t *pulse_data_print_data(pulse_data_t *data)
{
int pulses[2 * PD_MAX_PULSES];
double to_us = 1e6 / data->sample_rate;
for (unsigned i = 0; i < data->num_pulses; ++i) {
pulses[i * 2 + 0] = data->pulse[i] * to_us;
pulses[i * 2 + 1] = data->gap[i] * to_us;
}
/* clang-format off */
return data_make(
"mod", "", DATA_STRING, (data->fsk_f2_est) ? "FSK" : "OOK",
"count", "", DATA_INT, data->num_pulses,
"pulses", "", DATA_ARRAY, data_array(2 * data->num_pulses, DATA_INT, pulses),
"freq1_Hz", "", DATA_FORMAT, "%u Hz", DATA_INT, (unsigned)data->freq1_hz,
"freq2_Hz", "", DATA_COND, data->fsk_f2_est, DATA_FORMAT, "%u Hz", DATA_INT, (unsigned)data->freq2_hz,
"freq_Hz", "", DATA_INT, (unsigned)data->centerfreq_hz,
"rate_Hz", "", DATA_INT, data->sample_rate,
"depth_bits", "", DATA_INT, data->depth_bits,
"range_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->range_db,
"rssi_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->rssi_db,
"snr_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->snr_db,
"noise_dB", "", DATA_FORMAT, "%.1f dB", DATA_DOUBLE, data->noise_db,
NULL);
/* clang-format on */
}
// OOK adaptive level estimator constants
#define OOK_MAX_HIGH_LEVEL DB_TO_AMP(0) // Maximum estimate for high level (-0 dB)
@ -437,10 +225,7 @@ int pulse_detect_package(pulse_detect_t *pulse_detect, int16_t const *envelope_d
fsk_pulses->start_ago = len - s->data_counter;
s->pulse_length = 0;
s->max_pulse = 0;
s->pulse_detect_fsk = (pulse_detect_fsk_t){0};
s->pulse_detect_fsk.var_test_max = INT16_MIN;
s->pulse_detect_fsk.var_test_min = INT16_MAX;
s->pulse_detect_fsk.skip_samples = 40;
pulse_detect_fsk_init(&s->pulse_detect_fsk);
s->ook_state = PD_OOK_STATE_PULSE;
}
else { // We are still idle..

39
src/pulse_detect_fsk.c
View file

@ -1,9 +1,9 @@
/** @file
Pulse detection functions.
FSK pulse detector
Pulse detection functions, FSK pulse detector.
Copyright (C) 2015 Tommy Vestermark
Copyright (C) 2019 Benjamin Larsson.
Copyright (C) 2022 Christian W. Zuckschwerdt <zany@triq.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -11,7 +11,6 @@
(at your option) any later version.
*/
#include "pulse_detect.h"
#include "pulse_detect_fsk.h"
#include "util.h"
#include <limits.h>
@ -19,26 +18,19 @@
#include <stdlib.h>
#include <string.h>
// FSK adaptive frequency estimator constants
#define FSK_DEFAULT_FM_DELTA 6000 // Default estimate for frequency delta
#define FSK_EST_SLOW 64 // Constant for slowness of FSK estimators
#define FSK_EST_FAST 16 // Constant for slowness of FSK estimators
void pulse_detect_fsk_init(pulse_detect_fsk_t *s)
{
*s = (pulse_detect_fsk_t){0};
s->var_test_max = INT16_MIN;
s->var_test_min = INT16_MAX;
s->skip_samples = 40;
}
/// Demodulate Frequency Shift Keying (FSK) sample by sample.
///
/// Function is stateful between calls
/// Builds estimate for initial frequency. When frequency deviates more than a
/// threshold value it will determine whether the deviation is positive or negative
/// to classify it as a pulse or gap. It will then transition to other state (F1 or F2)
/// and build an estimate of the other frequency. It will then transition back and forth when current
/// frequency is closer to other frequency estimate.
/// Includes spurious suppression by coalescing pulses when pulse/gap widths are too short.
/// Pulses equal higher frequency (F1) and Gaps equal lower frequency (F2)
/// @param fm_n One single sample of FM data
/// @param fsk_pulses Will return a pulse_data_t structure for FSK demodulated data
/// @param s Internal state
void pulse_detect_fsk_classic(pulse_detect_fsk_t *s, int16_t fm_n, pulse_data_t *fsk_pulses)
{
int const fm_f1_delta = abs(fm_n - s->fm_f1_est); // Get delta from F1 frequency estimate
@ -146,10 +138,6 @@ void pulse_detect_fsk_classic(pulse_detect_fsk_t *s, int16_t fm_n, pulse_data_t
} // switch(s->fsk_state)
}
/// Wrap up FSK modulation and store last data at End Of Package.
///
/// @param fsk_pulses Pulse_data_t structure for FSK demodulated data
/// @param s Internal state
void pulse_detect_fsk_wrap_up(pulse_detect_fsk_t *s, pulse_data_t *fsk_pulses)
{
if (fsk_pulses->num_pulses < PD_MAX_PULSES) { // Avoid overflow
@ -165,13 +153,6 @@ void pulse_detect_fsk_wrap_up(pulse_detect_fsk_t *s, pulse_data_t *fsk_pulses)
}
}
/// Demodulate Frequency Shift Keying (FSK) sample by sample.
///
/// Function is stateful between calls
/// @param fm_n One single sample of FM data
/// @param fsk_pulses Will return a pulse_data_t structure for FSK demodulated data
/// @param s Internal state
void pulse_detect_fsk_minmax(pulse_detect_fsk_t *s, int16_t fm_n, pulse_data_t *fsk_pulses)
{
int16_t mid = 0;