kopia lustrzana https://github.com/rpp0/gr-lora
169 wiersze
12 KiB
C++
169 wiersze
12 KiB
C++
/* -*- c++ -*- */
|
|
/*
|
|
* Copyright 2017 Pieter Robyns, William Thenaers.
|
|
*
|
|
* This 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 3, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This software is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifndef DBUGR_HPP
|
|
#define DBUGR_HPP
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <chrono>
|
|
|
|
#include <lora/utilities.h>
|
|
|
|
#define CLAMP_VAL 0.7e6f //1000000.0f //0.7f
|
|
|
|
//#define DBGR_CHRONO /// Measure execution time
|
|
|
|
#ifndef GRLORA_DEBUG
|
|
#define DBGR_PAUSE(MSG)
|
|
#define DBGR_QUICK_TO_FILE(FILEPATH, APPEND, DATA, SIZE, FORMAT)
|
|
#define DBGR_WRITE_SIGNAL(IDEAL_SIG_FP, SAMPLE_SIG_FP, WINDOW, OFFSET, MIN, MAX, FULL, PAUSE, MSG)
|
|
#else
|
|
#define DBGR_PAUSE(MSG) system("read -rsp $'" #MSG "\nPress any key to continue...\n' -n 1 key")
|
|
|
|
#define DBGR_QUICK_TO_FILE(FILEPATH, APPEND, DATA, SIZE, FORMAT) \
|
|
do { \
|
|
int32_t DBGR_j; \
|
|
char DBGR_buf[20]; \
|
|
std::ofstream DBGR_out_file; \
|
|
DBGR_out_file.open(FILEPATH, std::ios::out | (APPEND ? std::ios::app : std::ios::out )); \
|
|
\
|
|
for (DBGR_j = 0; DBGR_j < int32_t(SIZE); DBGR_j++) { \
|
|
sprintf(DBGR_buf, FORMAT, DATA[DBGR_j]); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} \
|
|
\
|
|
if (APPEND) DBGR_out_file.write("\n", sizeof(char)); \
|
|
\
|
|
} while(0) \
|
|
|
|
#define DBGR_WRITE_SIGNAL(IDEAL_SIG_FP, SAMPLE_SIG_FP, WINDOW, OFFSET, MIN, MAX, FULL, PAUSE, MSG) \
|
|
do { \
|
|
int32_t DBGR_j; \
|
|
char DBGR_buf[20]; \
|
|
const char DBGR_delim[] = "-----------------------------------------------------------------\n\0"; \
|
|
std::ofstream DBGR_out_file; \
|
|
DBGR_out_file.open("/tmp/DBGR.txt", std::ios::out); \
|
|
\
|
|
for (DBGR_j = 0; DBGR_j < int32_t(WINDOW); DBGR_j++) { \
|
|
sprintf(DBGR_buf, "%f\n", IDEAL_SIG_FP[DBGR_j]); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} DBGR_out_file.write(DBGR_delim, strlen(DBGR_delim)); \
|
|
\
|
|
for (DBGR_j = 0; DBGR_j < int32_t(WINDOW); DBGR_j++) { \
|
|
sprintf(DBGR_buf, "%f\n", gr::lora::clamp(SAMPLE_SIG_FP[DBGR_j], -CLAMP_VAL, CLAMP_VAL)); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} DBGR_out_file.write(DBGR_delim, strlen(DBGR_delim)); \
|
|
\
|
|
printf("DBGR_After %d of %d in %d\n", MIN, MAX, WINDOW); \
|
|
for (DBGR_j = OFFSET; DBGR_j < int32_t(OFFSET > 0 ? WINDOW : MAX); DBGR_j++) { \
|
|
sprintf(DBGR_buf, "%f\n", gr::lora::clamp(*(SAMPLE_SIG_FP + DBGR_j), -CLAMP_VAL, CLAMP_VAL)); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} DBGR_out_file.write(DBGR_delim, strlen(DBGR_delim)); \
|
|
\
|
|
printf("%s", DBGR_delim); \
|
|
\
|
|
/*if (FULL) { \
|
|
printf("DBGR_Full\n"); \
|
|
for (DBGR_j = 0; DBGR_j < WINDOW; DBGR_j++) { \
|
|
sprintf(DBGR_buf, "%f\n\0", SAMPLE_SIG_FP[DBGR_j]); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} DBGR_out_file.write(DBGR_delim, strlen(DBGR_delim)); \
|
|
printf("%s", DBGR_delim); \
|
|
}*/ \
|
|
\
|
|
DBGR_out_file.close(); \
|
|
if(PAUSE) DBGR_PAUSE(MSG); \
|
|
} while(0)
|
|
|
|
#endif
|
|
|
|
// Chrono
|
|
#ifndef DBGR_CHRONO
|
|
#define DBGR_START_TIME_MEASUREMENT(OUT, MSG)
|
|
#define DBGR_START_TIME_MEASUREMENT_SAME_SCOPE(OUT, MSG)
|
|
#define DBGR_INTERMEDIATE_TIME_MEASUREMENT()
|
|
#define DBGR_STOP_TIME_MEASUREMENT(OUT)
|
|
#define DBGR_TIME_MEASUREMENT_TO_FILE(PRE)
|
|
#else
|
|
static int64_t DBGR_global_time = 0ll;
|
|
static bool DBGR_totalled_time = false;
|
|
static bool DBGR_intermediate_time = false;
|
|
static bool DBGR_time_to_file = false;
|
|
static std::string DBGR_fileprefix = "";
|
|
static std::string DBGR_filename = "";
|
|
|
|
|
|
#define DBGR_QUICK_TO_FILE(FILEPATH, APPEND, DATA, SIZE, FORMAT) \
|
|
do { \
|
|
int32_t DBGR_j; \
|
|
char DBGR_buf[20]; \
|
|
std::ofstream DBGR_out_file; \
|
|
DBGR_out_file.open(FILEPATH, std::ios::out | (APPEND ? std::ios::app : std::ios::out )); \
|
|
\
|
|
for (DBGR_j = 0; DBGR_j < int32_t(SIZE); DBGR_j++) { \
|
|
sprintf(DBGR_buf, FORMAT, DATA[DBGR_j]); \
|
|
DBGR_out_file.write(DBGR_buf, strlen(DBGR_buf)); \
|
|
} \
|
|
\
|
|
if (APPEND) DBGR_out_file.write("\n", sizeof(char)); \
|
|
\
|
|
} while(0) \
|
|
|
|
|
|
#define DBGR_START_TIME_MEASUREMENT(OUT, MSG) \
|
|
DBGR_intermediate_time = OUT; \
|
|
if (DBGR_intermediate_time) printf("[CHRONO] : Start in % 15s", std::string(MSG).c_str()); \
|
|
if (DBGR_time_to_file) { \
|
|
DBGR_filename = "/tmp/" + DBGR_fileprefix + "_" + std::string(MSG); \
|
|
} \
|
|
DBGR_totalled_time = false; \
|
|
auto DBGR_start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
#define DBGR_START_TIME_MEASUREMENT_SAME_SCOPE(OUT, MSG) \
|
|
DBGR_intermediate_time = OUT; \
|
|
if (DBGR_intermediate_time) printf("[CHRONO] : Start with % 15s", MSG); \
|
|
DBGR_totalled_time = false; \
|
|
DBGR_start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
#define DBGR_INTERMEDIATE_TIME_MEASUREMENT() \
|
|
if (!DBGR_totalled_time) { \
|
|
int64_t DBGR_duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - DBGR_start_time).count(); \
|
|
DBGR_global_time += DBGR_duration; \
|
|
const float DBGR_ms_duration[] = { DBGR_duration / 1e6f }; \
|
|
if (DBGR_intermediate_time) printf(" and took %fms\n", DBGR_ms_duration[0]); \
|
|
if (DBGR_time_to_file) { \
|
|
DBGR_QUICK_TO_FILE(DBGR_filename, true, DBGR_ms_duration, 1, "%f"); \
|
|
} \
|
|
}
|
|
|
|
#define DBGR_STOP_TIME_MEASUREMENT(OUT) \
|
|
if (OUT) printf("[CHRONO] : Packet took %fms to process.\n", DBGR_global_time / 1e6); \
|
|
DBGR_global_time = 0ll; \
|
|
DBGR_totalled_time = true;
|
|
|
|
#define DBGR_TIME_MEASUREMENT_TO_FILE(PRE) \
|
|
DBGR_time_to_file = true; \
|
|
if (DBGR_fileprefix.length() == 0) DBGR_fileprefix = "lora-time_" + std::string(PRE);
|
|
|
|
#endif
|
|
|
|
#endif // DBUGR_HPP
|