From 355429b0b67f501e22d33d12915850b2ed03f13d Mon Sep 17 00:00:00 2001
From: Philemon Prevot <philemon.prevot@lis-lab.fr>
Date: Fri, 6 Sep 2024 17:28:40 +0200
Subject: [PATCH] Add qhb_version check
---
CMakeLists.txt | 2 +-
src/filewriter.cpp | 120 ++++++++++++++++++++++-----------------------
src/filewriter.h | 25 +++++-----
src/main.cpp | 46 +++++++++++------
4 files changed, 104 insertions(+), 89 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index aa8d40e..ccd70e9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@ if(POLICY CMP0063)
endif()
project(jasonrec)
-set(JASONREC_VERSION "1.3")
+set(JASONREC_VERSION "2.0")
add_definitions(-DJASONREC_VERSION="${JASONREC_VERSION}")
find_path(LIBUSB_INCLUDE_DIR
diff --git a/src/filewriter.cpp b/src/filewriter.cpp
index 2cbb477..01009d0 100644
--- a/src/filewriter.cpp
+++ b/src/filewriter.cpp
@@ -16,8 +16,8 @@
#include <cstring>
#include <cmath>
-FileWriter::FileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth) :
- filename_template(filename_template), num_channels(num_channels), sample_rate(sample_rate), depth(depth) {
+FileWriter::FileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth) :
+ filename_template(filename_template), qhb_version(qhb_version), num_channels(num_channels), sample_rate(sample_rate), depth(depth) {
// nothing
}
@@ -75,14 +75,14 @@ uint32_t read_little_endian(uint8_t (&source)[4]) {
return (source[0] + source[1] << 8 + source[2] << 16 + source[3] << 24);
}
-WavFileWriter::WavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth) :
- WavFileWriter(filename_template, num_channels, sample_rate, depth, 0) {
+WavFileWriter::WavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth) :
+ WavFileWriter(filename_template, qhb_version, num_channels, sample_rate, depth, 0) {
// nothing
}
-WavFileWriter::WavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth,
+WavFileWriter::WavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth,
size_t expected_num_samples) :
- FileWriter(filename_template, num_channels, sample_rate, depth),
+ FileWriter(filename_template, qhb_version, num_channels, sample_rate, depth),
outfile(generate_filename(), std::ios::out | std::ios::binary | std::ios::trunc),
samples_written(0) {
// check if we could open the file
@@ -122,8 +122,8 @@ void WavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t *imu_dat
samples_written += num_samples /(num_channels * depth);
}
-IMUFileWriter::IMUFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate,size_t depth, size_t timestamp) :
- FileWriter(filename_template, num_channels, sample_rate, depth),
+IMUFileWriter::IMUFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate,size_t depth, size_t timestamp) :
+ FileWriter(filename_template, qhb_version, num_channels, sample_rate, depth),
outfile(generate_filename(),
std::ios::out | std::ios::trunc),
last_timestamp(0),
@@ -288,49 +288,49 @@ void IMUFileWriter::ProcessDecodedMessage(int msgFunction, int msgPayloadLength,
uint32_t timeStamp = BUILD_UINT32(msgPayload[13 + i * lengthPerSample+3],msgPayload[13 + i * lengthPerSample+2],msgPayload[13 + i * lengthPerSample+1],msgPayload[13 + i * lengthPerSample]);
switch(sensorType) {
case IMUFileWriter::SensorType::Accel:
- if (lastAccelTimeStamp >= 500000000)
- lastAccelTimeStamp = 0;
- if (timeStamp > lastAccelTimeStamp) {
- lastAccelTimeStamp = timeStamp;
- outfile << "ACCEL, " << timeStamp;
- outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample],msgPayload[17 + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
- outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample],msgPayload[17 +dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
- outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample],msgPayload[17 +2*dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
- outfile << std::endl;
- }
- else {
- //printf("TS Accel Error\n");
- }
+ if (lastAccelTimeStamp >= 500000000)
+ lastAccelTimeStamp = 0;
+ if (timeStamp > lastAccelTimeStamp) {
+ lastAccelTimeStamp = timeStamp;
+ outfile << "ACCEL, " << timeStamp;
+ outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample],msgPayload[17 + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
+ outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample],msgPayload[17 +dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
+ outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample],msgPayload[17 +2*dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue );
+ outfile << std::endl;
+ }
+ else {
+ //printf("TS Accel Error\n");
+ }
break;
case IMUFileWriter::SensorType::Gyro:
- if (lastGyroTimeStamp >= 500000000)
- lastGyroTimeStamp = 0;
- if (timeStamp > lastGyroTimeStamp) {
- lastGyroTimeStamp = timeStamp;
- outfile << "GYRO, " << timeStamp;
- outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample],msgPayload[17 + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
- outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample],msgPayload[17 +dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
- outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample],msgPayload[17 +2*dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
- outfile << std::endl;
- }
- else {
- //printf("TS Gyro Error\n");
- }
+ if (lastGyroTimeStamp >= 500000000)
+ lastGyroTimeStamp = 0;
+ if (timeStamp > lastGyroTimeStamp) {
+ lastGyroTimeStamp = timeStamp;
+ outfile << "GYRO, " << timeStamp;
+ outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample],msgPayload[17 + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
+ outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample],msgPayload[17 +dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
+ outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample],msgPayload[17 +2*dataSize + i * lengthPerSample+1]) * ( rangeScale / dataMaxValue);
+ outfile << std::endl;
+ }
+ else {
+ //printf("TS Gyro Error\n");
+ }
break;
case IMUFileWriter::SensorType::Mag:
- if (lastMagTimeStamp >= 500000000)
- lastMagTimeStamp = 0;
- if (timeStamp > lastMagTimeStamp) {
- lastMagTimeStamp = timeStamp;
- outfile << "MAG, " << timeStamp;
- outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample+1],msgPayload[17 + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
- outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample+1],msgPayload[17 +dataSize + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
- outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample+1],msgPayload[17 +2*dataSize + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
- outfile << std::endl;
- }
- else {
- //printf("TS Mag Error\n");
- }
+ if (lastMagTimeStamp >= 500000000)
+ lastMagTimeStamp = 0;
+ if (timeStamp > lastMagTimeStamp) {
+ lastMagTimeStamp = timeStamp;
+ outfile << "MAG, " << timeStamp;
+ outfile << ", " << BUILD_INT16(msgPayload[17 + i * lengthPerSample+1],msgPayload[17 + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
+ outfile << ", " << BUILD_INT16(msgPayload[17 + dataSize + i * lengthPerSample+1],msgPayload[17 +dataSize + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
+ outfile << ", " << BUILD_INT16(msgPayload[17 + 2*dataSize + i * lengthPerSample+1],msgPayload[17 +2*dataSize + i * lengthPerSample]) * ( rangeScale / dataMaxValue);
+ outfile << std::endl;
+ }
+ else {
+ //printf("TS Mag Error\n");
+ }
break;
case IMUFileWriter::SensorType::Temperature:
if (lastTemperatureTimeStamp >= 500000000)
@@ -450,7 +450,7 @@ void IMUFileWriter::ProcessDecodedMessage(int msgFunction, int msgPayloadLength,
void IMUFileWriter::write(uint8_t *sample, size_t size, uint8_t *imu_data) {
uint8_t *imu_data_cur(imu_data);
- if(!(imu_data[0]==0xFE) && (imu_data[0]>= 2)) {
+ if(this->qhb_version == 3) {
for(int i=1; i<size-1; i++)
{
DecodeMessage(imu_data[i]);
@@ -490,9 +490,9 @@ size_t IMUFileWriter::get_last_timestamp(){
}
-SplitWavFileWriter::SplitWavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate,
+SplitWavFileWriter::SplitWavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate,
size_t depth, size_t samples_per_file) :
- FileWriter(filename_template, num_channels, sample_rate, depth),
+ FileWriter(filename_template, qhb_version, num_channels, sample_rate, depth),
samples_per_file(samples_per_file),
current_file(nullptr),
current_file_samples_written(0) {
@@ -510,7 +510,7 @@ void SplitWavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t *im
// start as many new files as required to write out the samples
while (current_file_samples_written + available >= samples_per_file) {
if (!current_file) {
- current_file = new WavFileWriter(filename_template, num_channels, sample_rate, depth, samples_per_file);
+ current_file = new WavFileWriter(filename_template, qhb_version, num_channels, sample_rate, depth, samples_per_file);
}
// write out as much as fits into the current file and move the pointer
size_t missing = samples_per_file - current_file_samples_written;
@@ -525,7 +525,7 @@ void SplitWavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t *im
// if there are samples left, write them to the current file
if (available) {
if (!current_file) {
- current_file = new WavFileWriter(filename_template, num_channels, sample_rate, depth, samples_per_file);
+ current_file = new WavFileWriter(filename_template, qhb_version, num_channels, sample_rate, depth, samples_per_file);
}
current_file->write(samples, available * num_channels * depth, imu_data);
current_file_samples_written += available;
@@ -533,9 +533,9 @@ void SplitWavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t *im
}
-SplitIMUWavFileWriter::SplitIMUWavFileWriter(std::string &filename_template, std::string &imu_name_template,
+SplitIMUWavFileWriter::SplitIMUWavFileWriter(std::string &filename_template, std::string &imu_name_template, size_t qhb_version,
size_t num_channels, size_t sample_rate, size_t depth, size_t samples_per_file):
- FileWriter(filename_template, num_channels, sample_rate, depth),
+ FileWriter(filename_template, qhb_version, num_channels, sample_rate, depth),
imu_name_template(imu_name_template),
samples_per_file(samples_per_file),
current_file(nullptr),
@@ -559,14 +559,14 @@ void SplitIMUWavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t*
// start as many new files as required to write out the samples
while (current_file_samples_written + available >= samples_per_file) {
if (!current_file) {
- current_file = new WavFileWriter(filename_template, num_channels, sample_rate, depth, samples_per_file);
+ current_file = new WavFileWriter(filename_template, qhb_version, num_channels, sample_rate, depth, samples_per_file);
if (imu_file) {
max_timestamp = imu_file->get_last_timestamp();
delete imu_file;
- imu_file = new IMUFileWriter(imu_name_template, num_channels, sample_rate, depth, max_timestamp);
+ imu_file = new IMUFileWriter(imu_name_template, qhb_version, num_channels, sample_rate, depth, max_timestamp);
}
}
- if (!imu_file) imu_file = new IMUFileWriter(imu_name_template, num_channels, sample_rate, depth, max_timestamp);
+ if (!imu_file) imu_file = new IMUFileWriter(imu_name_template, qhb_version, num_channels, sample_rate, depth, max_timestamp);
// write out as much as fits into the current file and move the pointer
size_t missing = samples_per_file - current_file_samples_written;
current_file->write(samples, missing * num_channels * depth, imu_data);
@@ -585,14 +585,14 @@ void SplitIMUWavFileWriter::write(uint8_t *samples, size_t num_samples, uint8_t*
// if there are samples left, write them to the current file
if (available) {
if (!current_file) {
- current_file = new WavFileWriter(filename_template, num_channels, sample_rate, depth, samples_per_file);
+ current_file = new WavFileWriter(filename_template, qhb_version, num_channels, sample_rate, depth, samples_per_file);
if (imu_file) {
max_timestamp = imu_file->get_last_timestamp();
delete imu_file;
- imu_file = new IMUFileWriter(imu_name_template, num_channels, sample_rate, depth, max_timestamp);
+ imu_file = new IMUFileWriter(imu_name_template, qhb_version, num_channels, sample_rate, depth, max_timestamp);
}
}
- if (!imu_file) imu_file = new IMUFileWriter(imu_name_template, num_channels, sample_rate, depth, max_timestamp);
+ if (!imu_file) imu_file = new IMUFileWriter(imu_name_template, qhb_version, num_channels, sample_rate, depth, max_timestamp);
current_file->write(samples, available * num_channels * depth, imu_data);
if (imu_data) imu_file->write(samples, available * num_channels * depth, imu_data);
imu_data = nullptr;
diff --git a/src/filewriter.h b/src/filewriter.h
index d268766..8cbf897 100644
--- a/src/filewriter.h
+++ b/src/filewriter.h
@@ -29,13 +29,14 @@ protected:
std::string generate_filename();
// sample format options
+ size_t qhb_version;
size_t num_channels;
size_t sample_rate;
size_t depth;
public:
/** Abstract constructor to be used by subclasses.
*/
- FileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth);
+ FileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth);
virtual ~FileWriter();
/** Writes out the given vector of 8-bit samples.
@@ -87,7 +88,7 @@ public:
* \param[in] depth The number of bytes per samples the
* sample data to be written will contain.
*/
- WavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth);
+ WavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth);
/** Instantiates a wave file writer.
* \param[in] filename_template The name of the file to write to. Will be
* created or opened immediately, truncating any existing content. May
@@ -103,7 +104,7 @@ public:
* channel) that will be written. The file header will be written
* accordingly and not rewritten on closing the file if the number matches.
*/
- WavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth,
+ WavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth,
size_t expected_num_samples);
~WavFileWriter() override;
@@ -135,7 +136,7 @@ public:
* \param[in] samples_per_file The target number of samples (per channel)
* that will be written to a file before starting the next one.
*/
- SplitWavFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate,
+ SplitWavFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate,
size_t depth, size_t samples_per_file);
~SplitWavFileWriter() override;
@@ -185,13 +186,13 @@ private:
};
std::ofstream outfile;
- size_t last_timestamp;
- unsigned int lastAccelTimeStamp;
- unsigned int lastGyroTimeStamp;
- unsigned int lastMagTimeStamp;
- unsigned int lastLightTimeStamp;
+ size_t last_timestamp = 0;
+ unsigned int lastAccelTimeStamp = 0;
+ unsigned int lastGyroTimeStamp = 0;
+ unsigned int lastMagTimeStamp = 0;
+ unsigned int lastLightTimeStamp = 0;
unsigned int lastPressureTimeStamp = 0;
- unsigned int lastTemperatureTimeStamp;
+ unsigned int lastTemperatureTimeStamp = 0;
unsigned int lastTimeStamp = 0;
DateTime lastGPSDate;
double lastPPSTimeStampNS;
@@ -236,7 +237,7 @@ public:
int msgPayloadLength, const unsigned char msgPayload[]);
void DecodeMessage(unsigned char c);
- IMUFileWriter(std::string &filename_template, size_t num_channels, size_t sample_rate, size_t depth, size_t timestamp);
+ IMUFileWriter(std::string &filename_template, size_t qhb_version, size_t num_channels, size_t sample_rate, size_t depth, size_t timestamp);
void write(uint8_t *samples, size_t num_samples, uint8_t *imu_data) override;
size_t get_last_timestamp();
};
@@ -268,7 +269,7 @@ public:
* \param[in] samples_per_file The target number of samples (per channel)
* that will be written to a file before starting the next one.
*/
- SplitIMUWavFileWriter(std::string &filename_template, std::string &imu_name_template, size_t num_channels,
+ SplitIMUWavFileWriter(std::string &filename_template, std::string &imu_name_template, size_t qhb_version, size_t num_channels,
size_t sample_rate, size_t depth, size_t samples_per_file);
~SplitIMUWavFileWriter() override;
diff --git a/src/main.cpp b/src/main.cpp
index 0a1cef3..e8a6f59 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -18,10 +18,11 @@ void print_usage(char *name) {
std::cout << " v" << JASONREC_VERSION;
#endif
std::cout << std::endl;
- std::cout << "Usage: " << name << " channels rate filename [--help, -h] [--chunk_len, -c CHUNK_LEN] "
+ std::cout << "Usage: " << name << " qhbversion channels rate filename [--help, -h] [--chunk_len, -c CHUNK_LEN] "
<< "[--total_len, -t TOTAL_LEN] [--device, -d DEVICE] [--bit_depth, -b BIT_DEPTH] "
<< "[--imu, -i IMU] [--filter, -f FILTER] [--verbose, -v]" << std::endl;
std::cout << "Positional arguments:" << std::endl;
+ std::cout << " QHB VERSION:\tversion of the QHB audio card (2 or 3)" << std::endl;
std::cout << " CHANNELS:\tnumber of channels to record (1 to 5)" << std::endl;
std::cout << " RATE:\tsample rate in Hz to record at (integral number)" << std::endl;
std::cout << " FILENAME:\toutput file name. should include strftime() format specifiers" << std::endl;
@@ -41,8 +42,8 @@ void print_usage(char *name) {
std::cout << " --verbose, -v\t\tEnable the printing of status message " << std::endl;
}
-int record(size_t channels, size_t rate, size_t depth, size_t filter, std::string &filename, std::string &imu_name,
- float chunklen, float totallen, size_t device, bool verbose) {
+int record(size_t qhb_version, size_t channels, size_t rate, size_t depth, size_t filter, std::string &filename, std::string &imu_name,
+ float chunklen, float totallen, size_t device, bool verbose, size_t accelSamplingFrequency, size_t gyroSamplingFrequency, size_t magSamplingFrequency, size_t accelRangeScale, size_t gyroRangeScale, size_t magRangeScale) {
JasonRecorder recorder = JasonRecorder(verbose);
std::cout << "Found " << recorder.get_device_count() << " JASON card(s)." << std::endl;
if (recorder.get_device_count() == 0) {
@@ -57,17 +58,17 @@ int record(size_t channels, size_t rate, size_t depth, size_t filter, std::stri
std::unique_ptr<FileWriter> filewriter;
if (chunklen > 0 && imu_name.empty()) {
// implementation note: in C++14 we would use std::make_unique<SplitWavFileWriter>(...)
- filewriter.reset(new SplitWavFileWriter(filename, channels, rate, depth, chunklen * rate));
+ filewriter.reset(new SplitWavFileWriter(filename, qhb_version, channels, rate, depth, chunklen * rate));
}
else if (chunklen > 0) {
// implementation note: in C++14 we would use std::make_unique<SplitWavFileWriter>(...)
- filewriter.reset(new SplitIMUWavFileWriter(filename, imu_name, channels, rate, depth, chunklen * rate));
+ filewriter.reset(new SplitIMUWavFileWriter(filename, imu_name, qhb_version, channels, rate, depth, chunklen * rate));
}
else if (imu_name.empty()){
- filewriter.reset(new WavFileWriter(filename, channels, rate, depth, totallen * rate));
+ filewriter.reset(new WavFileWriter(filename, qhb_version, channels, rate, depth, totallen * rate));
}
else{
- filewriter.reset(new SplitIMUWavFileWriter(filename, imu_name, channels, rate, depth, totallen * rate));
+ filewriter.reset(new SplitIMUWavFileWriter(filename, imu_name, qhb_version, channels, rate, depth, totallen * rate));
}
// start the recording loop
std::cout << "Starting to record..." << std::endl;
@@ -80,7 +81,7 @@ int record(size_t channels, size_t rate, size_t depth, size_t filter, std::stri
std::vector<std::uint8_t> imu_data;
try {
std::cout << "Setting recording format to " << channels << " channels at " << rate << " Hz " << (8 * depth) << " bits" << std::endl;
- recorder.start_recording(channels, rate, depth, filter);
+ recorder.start_recording(qhb_version, channels, rate, depth, filter, accelSamplingFrequency, gyroSamplingFrequency, magSamplingFrequency, accelRangeScale, gyroRangeScale, magRangeScale);
// we will record until we have enough (or forever, if totallen == 0)
while ((total_samples_wanted == 0) || (total_samples_read < total_samples_wanted)) {
if (exit_requested()) {
@@ -122,41 +123,54 @@ int record(size_t channels, size_t rate, size_t depth, size_t filter, std::stri
}
int main(int argc, char *argv[]) {
- if (argc < 4) {
+ if (argc < 5) {
print_usage(argv[0]);
return 2;
}
// parse command line options
+ int qhb_version;
+ try {
+ qhb_version = std::stoi(argv[1]);
+ if ((qhb_version < 2) || (qhb_version > 3)) {
+ std::cout << "Error: QHBVERSION must be 2..3, got " << qhb_version << " instead. Version unsupported." << std::endl;
+ return 2;}
+ }
+ catch (const std::exception& e) {
+ std::cout << "Error: Could not interpret " << argv[1] << " as an integer." << std::endl;
+ return 2;
+ }
int num_channels;
try {
- num_channels = std::stoi(argv[1]);
+ num_channels = std::stoi(argv[2]);
if ((num_channels < 1) || (num_channels > MAX_CHANNELS)) {
std::cout << "Error: CHANNELS must be in 1.." << MAX_CHANNELS << ", got " << num_channels << " instead" << std::endl;
return 2;}
}
catch (const std::exception& e) {
- std::cout << "Error: Could not interpret " << argv[1] << " as an integer." << std::endl;
+ std::cout << "Error: Could not interpret " << argv[2] << " as an integer." << std::endl;
return 2;
}
int rate;
try {
- rate = std::stoi(argv[2]);
+ rate = std::stoi(argv[3]);
if (rate!= 32000 && rate!=64000 && rate!=128000 && rate!=256000 && rate!=512000) {
std::cout << "Error: RATE must be a power 2 times 32kHz, got " << rate << " instead" << std::endl;
return 2;
}
}
catch (const std::exception& e) {
- std::cout << "Error: Could not interpret " << argv[2] << " as an integer." << std::endl;
+ std::cout << "Error: Could not interpret " << argv[3] << " as an integer." << std::endl;
return 2;
}
- std::string filename = argv[3];
+ std::string filename = argv[4];
- int i=4;
+ int i=5;
int device(0), bit_depth(16), filter(0);
float chunklen(0), totallen(0);
+ float accelSamplingFrequency(25), gyroSamplingFrequency(25), magSamplingFrequency(20);
+ float accelRangeScale(8), gyroRangeScale(250), magRangeScale(12);
std::string imu_name;
bool verbose(false);
while (i < argc){
@@ -212,5 +226,5 @@ int main(int argc, char *argv[]) {
i++;
}
// hand over to the recording function
- return record(num_channels, rate, bit_depth/8, filter, filename, imu_name, chunklen, totallen, device, verbose);
+ return record(qhb_version, num_channels, rate, bit_depth/8, filter, filename, imu_name, chunklen, totallen, device, verbose, accelSamplingFrequency, gyroSamplingFrequency, magSamplingFrequency, accelRangeScale, gyroRangeScale, magRangeScale);
}
--
GitLab