Commit a7b5da0f authored by enfo's avatar enfo

Moved cpp-code to sentiboard-cpp

parent 6f7cda90
image: gcc-cpplint-cmake-gcov
build:
stage: build
script:
- make -C parsers tests -j 4
artifacts:
paths:
- parsers/build/sentiboard_utils_test
cache:
paths:
- parsers/build/
lint:
stage: build
script:
- make -C parsers lint
test:
stage: test
script:
- ./parsers/build/sentiboard_utils_test
coverage:
stage: test
script:
- make -C parsers coverage
coverage: '/lines[.: ]*\d+.\d+%/'
artifacts:
paths:
- parsers/build_coverage/sentiboard_utils_test
- parsers/coverage/
cache:
paths:
- parsers/build_coverage/
- parsers/coverage/
branch-coverage:
stage: test
script:
- make -C parsers coverage
coverage: '/branches[.: ]*\d+.\d+%/'
artifacts:
paths:
- parsers/build_coverage/sentiboard_utils_test
- parsers/coverage/
cache:
paths:
- parsers/build_coverage/
- parsers/coverage/
Sentiboard Utils
================
Status
------
[![build status](https://kyb.guru/gitlab/enfo/sentiboard-utils/badges/master/pipeline.svg)](https://kyb.guru/gitlab/enfo/sentiboard-utils/commits/master)
Lines: [![coverage report](https://kyb.guru/gitlab/enfo/sentiboard-utils/badges/master/coverage.svg?job=coverage)](https://kyb.guru/gitlab/enfo/sentiboard-utils/commits/master)
Branches: [![coverage report](https://kyb.guru/gitlab/enfo/sentiboard-utils/badges/master/coverage.svg?job=branch-coverage)](https://kyb.guru/gitlab/enfo/sentiboard-utils/commits/master)
Usage
=====
......
cmake_minimum_required (VERSION 3.1.0 FATAL_ERROR)
project (sentiboard-utils)
# The version number.
set (sentiboard_utils_VERSION_MAJOR 0)
set (sentiboard_utils_VERSION_MINOR 1)
set (SENTIBOARD_SRC_DIR "${CMAKE_SOURCE_DIR}/src")
set (SENTIBOARD_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/include")
include_directories(
${SENTIBOARD_INCLUDE_DIR}
)
set(SENTIBOARD_SRCS
${SENTIBOARD_SRC_DIR}/Reader.cpp
${SENTIBOARD_SRC_DIR}/Package.cpp
)
FILE(GLOB_RECURSE SENTIBOARD_HEADERS "include/*.h" "include/*.hpp)")
add_library(sentiboard_utils
${SENTIBOARD_SRCS}
${SENTIBOARD_HEADERS}
)
target_compile_features(sentiboard_utils PRIVATE cxx_auto_type cxx_range_for)
# -- Set up test project --
set (TEST_TARGET "sentiboard_utils_test")
set (TEST_SRC_DIR "${CMAKE_SOURCE_DIR}/tests")
set (TEST_INCLUDE_DIR "${TEST_SRC_DIR}/include")
include_directories(
${TEST_INCLUDE_DIR}
)
# Select wether to use Catch c++ or doctest
option(USE_CATCH_TESTS "Use the Catch c++ test framework" True)
set(SENTIBOARD_TEST_HEADERS "${TEST_SRC_DIR}/include/framework/test_framework.hpp")
if(USE_CATCH_TESTS)
add_definitions(-DUSE_CATCH)
list(APPEND SENTIBOARD_TEST_HEADERS "${TEST_SRC_DIR}/include/framework/catch.hpp")
else()
list(APPEND SENTIBOARD_TEST_HEADERS "${TEST_SRC_DIR}/include/framework/doctest.h")
endif()
set(SENTIBOARD_TEST_SRCS
${TEST_SRC_DIR}/testmain.cpp
${TEST_SRC_DIR}/sentiboard_reader_test.cpp
${TEST_SRC_DIR}/stim_parser_test.cpp
${TEST_SRC_DIR}/test_utils.cpp
)
add_executable(${TEST_TARGET}
${SENTIBOARD_TEST_SRCS}
${SENTIBOARD_TEST_HEADERS}
)
target_compile_features(${TEST_TARGET} PRIVATE cxx_auto_type cxx_nullptr)
target_link_libraries(${TEST_TARGET} sentiboard_utils)
# -- Set up code coverage project --
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake-modules)
if (CMAKE_BUILD_TYPE STREQUAL "Coverage")
SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
include(CodeCoverage)
SETUP_TARGET_FOR_COVERAGE(test_coverage ${TEST_TARGET} ${PROJECT_SOURCE_DIR}/coverage)
endif() #CMAKE_BUILD_TYPE STREQUAL "Coverage"
CPPLINT_EXCLUDES = --exclude=tests/include/framework/* --filter=-readability/casting,-readability/check --repository=.
BIN_DIR = build
BIN_COV_DIR = build_coverage
TEST_TARGET = sentiboard_utils_test
.PHONY: all
all: tests
.PHONY: tests
tests :
mkdir -p $(BIN_DIR)
cd $(BIN_DIR) && cmake ..
make -C $(BIN_DIR) -j 8
.PHONY: lint
lint:
cpplint --recursive $(CPPLINT_EXCLUDES) src include tests simulator
.PHONY: coverage
coverage:
mkdir -p $(BIN_COV_DIR)
cd $(BIN_COV_DIR) && cmake -DCMAKE_BUILD_TYPE=Coverage ..
make -C $(BIN_COV_DIR) -j8 test_coverage
.PHONY: run
run: $(BIN_DIR)/$(TEST_TARGET)
./$(BIN_DIR)/$(TEST_TARGET)
.PHONY: test
test: run
.PHONY: clean
clean:
$(RM) -r build
#
# 2012-01-31, Lars Bilke
# - Enable Code Coverage
#
# 2013-09-17, Joakim Söderberg
# - Added support for Clang.
# - Some additional usage instructions.
#
# USAGE:
# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
# http://stackoverflow.com/a/22404544/80480
#
# 1. Copy this file into your cmake modules path.
#
# 2. Add the following line to your CMakeLists.txt:
# INCLUDE(CodeCoverage)
#
# 3. Set compiler flags to turn off optimization and enable coverage:
# SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
# SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
#
# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
# which runs your test executable and produces a lcov code coverage report:
# Example:
# SETUP_TARGET_FOR_COVERAGE(
# my_coverage_target # Name for custom target.
# test_driver # Name of the test driver executable that runs the tests.
# # NOTE! This should always have a ZERO as exit code
# # otherwise the coverage generation will not complete.
# coverage # Name of output directory.
# )
#
# 4. Build a Debug build:
# cmake -DCMAKE_BUILD_TYPE=Debug ..
# make
# make my_coverage_target
#
#
# Check prereqs
FIND_PROGRAM( GCOV_PATH gcov )
FIND_PROGRAM( LCOV_PATH lcov )
FIND_PROGRAM( GENHTML_PATH genhtml )
FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
IF(NOT GCOV_PATH)
MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
ENDIF() # NOT GCOV_PATH
IF(NOT CMAKE_COMPILER_IS_GNUCXX)
# Clang version 3.0.0 and greater now supports gcov as well.
MESSAGE(WARNING "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.")
IF(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
ENDIF()
ENDIF() # NOT CMAKE_COMPILER_IS_GNUCXX
SET(CMAKE_CXX_FLAGS_COVERAGE
"-Wunused-variable -g -O0 --coverage -fprofile-arcs -ftest-coverage"
CACHE STRING "Flags used by the C++ compiler during coverage builds."
FORCE )
SET(CMAKE_C_FLAGS_COVERAGE
"-Wunused-variable -g -O0 --coverage -fprofile-arcs -ftest-coverage"
CACHE STRING "Flags used by the C compiler during coverage builds."
FORCE )
SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
""
CACHE STRING "Flags used for linking binaries during coverage builds."
FORCE )
SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
""
CACHE STRING "Flags used by the shared libraries linker during coverage builds."
FORCE )
MARK_AS_ADVANCED(
CMAKE_CXX_FLAGS_COVERAGE
CMAKE_C_FLAGS_COVERAGE
CMAKE_EXE_LINKER_FLAGS_COVERAGE
CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
# Param _targetname The name of new the custom make target
# Param _testrunner The name of the target which runs the tests.
# MUST return ZERO always, even on errors.
# If not, no coverage report will be created!
# Param _outputname lcov output is generated as _outputname.info
# HTML report is generated in _outputname/index.html
# Optional fourth parameter is passed as arguments to _testrunner
# Pass them in list form, e.g.: "-j;2" for -j 2
FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
IF(NOT LCOV_PATH)
MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
ENDIF() # NOT LCOV_PATH
IF(NOT GENHTML_PATH)
MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
ENDIF() # NOT GENHTML_PATH
# Setup target
ADD_CUSTOM_TARGET(${_targetname}
# Cleanup lcov
${LCOV_PATH} --directory . --zerocounters
# Run tests
COMMAND ${_testrunner} ${ARGV3}
# Capturing lcov counters and generating report
COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --directory . --capture --output-file ${_outputname}.info
COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --remove ${_outputname}.info '${CMAKE_CURRENT_SOURCE_DIR}/tests/*' '/usr/*' --output-file ${_outputname}.info.cleaned
COMMAND ${GENHTML_PATH} --rc lcov_branch_coverage=1 -o ${_outputname} ${_outputname}.info.cleaned
COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
)
# Show info where to find the report
ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
COMMAND ;
COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
)
ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
# Param _targetname The name of new the custom make target
# Param _testrunner The name of the target which runs the tests
# Param _outputname cobertura output is generated as _outputname.xml
# Optional fourth parameter is passed as arguments to _testrunner
# Pass them in list form, e.g.: "-j;2" for -j 2
FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
find_package(PythonInterp)
IF(NOT PYTHON_EXECUTABLE)
MESSAGE(FATAL_ERROR "Python not found! Aborting...")
ENDIF() # NOT PYTHON_EXECUTABLE
IF(NOT GCOVR_PATH)
MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
ENDIF() # NOT GCOVR_PATH
ADD_CUSTOM_TARGET(${_targetname}
# Run tests
${_testrunner} ${ARGV3}
# Running gcovr
COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/' -s -o ${_outputname}.xml
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
COMMENT "Running gcovr to produce Cobertura code coverage report."
)
# Show info where to find the report
ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
COMMAND ;
COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
)
ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_PACKAGE_HPP_
#define INCLUDE_SENTIBOARD_PACKAGE_HPP_
#include <stdint.h>
#include <vector>
#include <istream>
#include <memory>
namespace sentiboard {
class Package {
private:
std::vector<char> _data;
uint16_t _sensor_ix = -1;
bool SyncPackage(const std::shared_ptr<std::istream> inData);
bool _isGood = false;
bool _hasOnboardTimestamp = false;
double _onboardTimestamp = 0;
uint32_t _tov = 0;
uint32_t _toa = 0;
uint32_t _tot = 0;
uint8_t _protocolVersion;
public:
Package() {
}
~Package() {
}
bool ReadPackage(const std::shared_ptr<std::istream> inData,
bool printErrors);
bool CheckHeader(bool printErrors = false);
bool CheckPackage(bool printErrors = false);
bool IsGood() {
return _isGood;
}
size_t SensorIx() const {
return _sensor_ix;
}
size_t OnboardTimestamp() const {
return _onboardTimestamp;
}
uint32_t tov() const {
return _tov;
}
uint32_t toa() const {
return _toa;
}
uint32_t tot() const {
return _tot;
}
const size_t data_start_position() const;
const uint8_t *data() const {
return reinterpret_cast<const uint8_t *>(&_data[data_start_position()]);
}
const size_t data_len() const {
return _data.size() - data_start_position() - 2;
}
};
} // namespace sentiboard
#endif // INCLUDE_SENTIBOARD_PACKAGE_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_READER_HPP_
#define INCLUDE_SENTIBOARD_READER_HPP_
#include <string>
#include <fstream>
#include <memory>
#include "sentiboard/Package.hpp"
namespace sentiboard {
class Reader {
private:
std::shared_ptr<std::istream> _device;
bool _isOpen = false;
bool _printMessages = true;
public:
explicit Reader(std::string path);
explicit Reader(const std::shared_ptr<std::istream> stream);
~Reader() {}
Package GetPackage();
void PrintMessages(bool value) {
_printMessages = value;
}
bool PrintMessages() {
return _printMessages;
}
bool IsOpen() {
return _device && (*_device);
}
};
} // namespace sentiboard
#endif // INCLUDE_SENTIBOARD_READER_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_MESSAGES_IMUMESSAGE_HPP_
#define INCLUDE_SENTIBOARD_MESSAGES_IMUMESSAGE_HPP_
#include <tuple>
#include "SentiboardMessage.hpp"
#include "sentiboard/Package.hpp"
class ImuMessage : public SentiboardMessage {
public:
ImuMessage() { }
ImuMessage(const sentiboard::Package package,
std::tuple<float, float, float> accl,
std::tuple<float, float, float> gyro,
bool has_delta_values)
: SentiboardMessage(package) {
populate(package, accl, gyro, has_delta_values);
}
bool populate(const sentiboard::Package package,
std::tuple<float, float, float> accl,
std::tuple<float, float, float> gyro,
bool has_delta_values) {
accl_ = accl;
gyro_ = gyro;
has_delta_values_ = has_delta_values;
if (!SentiboardMessage::initialized()) {
SentiboardMessage::populate(package);
}
return true;
}
void has_delta_values(bool val) {
has_delta_values_ = true;
}
bool has_delta_values() {
return has_delta_values_;
}
std::tuple<float, float, float> accl() {
return accl_;
}
std::tuple<float, float, float> gyro() {
return gyro_;
}
private:
std::tuple<float, float, float> accl_;
std::tuple<float, float, float> gyro_;
bool has_delta_values_;
};
#endif // INCLUDE_SENTIBOARD_MESSAGES_IMUMESSAGE_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_MESSAGES_SENTIBOARDMESSAGE_HPP_
#define INCLUDE_SENTIBOARD_MESSAGES_SENTIBOARDMESSAGE_HPP_
#include "sentiboard/Package.hpp"
class SentiboardMessage {
public:
explicit SentiboardMessage(const sentiboard::Package& package) {
populate(package);
}
SentiboardMessage() {
initialized_ = false;
}
bool populate(const sentiboard::Package& package) {
sensor_ix_ = package.SensorIx();
tov_ = package.tov();
toa_ = package.toa();
tot_ = package.tot();
onboard_timestamp_ = package.OnboardTimestamp();
initialized_ = true;
return true;
}
~SentiboardMessage() { }
// Copy constructor
SentiboardMessage(const SentiboardMessage& other) {
sensor_ix_ = other.sensor_ix_;
tov_ = other.tov_;
toa_ = other.toa_;
tot_ = other.tot_;
onboard_timestamp_ = other.onboard_timestamp_;
}
// Copy assignment
SentiboardMessage& operator=(const SentiboardMessage& other) {
sensor_ix_ = other.sensor_ix_;
tov_ = other.tov_;
toa_ = other.toa_;
tot_ = other.tot_;
onboard_timestamp_ = other.onboard_timestamp_;
return *this;
}
// Copy constructor
SentiboardMessage(const SentiboardMessage &&other) {
sensor_ix_ = other.sensor_ix_;
tov_ = other.tov_;
toa_ = other.toa_;
tot_ = other.tot_;
onboard_timestamp_ = other.onboard_timestamp_;
}
// Move assignment
SentiboardMessage& operator=(SentiboardMessage&& other) {
if (this == &other) {
return *this;
}
this->sensor_ix_ = other.sensor_ix_;
this->tov_ = other.tov_;
this->toa_ = other.toa_;
this->tot_ = other.tot_;
this->onboard_timestamp_ = other.onboard_timestamp_;
return *this;
}
uint8_t sensor_ix() const {
return sensor_ix_;
}
uint32_t tov() const {
return tov_;
}
uint32_t toa() const {
return toa_;
}
uint32_t tot() const {
return tot_;
}
double onboard_timestamp() const {
return onboard_timestamp_;
}
bool initialized() {
return initialized_;
}
private:
uint8_t sensor_ix_;
uint32_t tov_;
uint32_t toa_;
uint32_t tot_;
double onboard_timestamp_;
bool initialized_;
};
#endif // INCLUDE_SENTIBOARD_MESSAGES_SENTIBOARDMESSAGE_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_SENSORS_SENTIBOARDPARSER_HPP_
#define INCLUDE_SENTIBOARD_SENSORS_SENTIBOARDPARSER_HPP_
#include "sentiboard/messages/SentiboardMessage.hpp"
class SentiboardParser {
public:
virtual SentiboardMessage parse(const sentiboard::Package package) {
SentiboardMessage msg(package);
return msg;
}
};
#endif // INCLUDE_SENTIBOARD_SENSORS_SENTIBOARDPARSER_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#ifndef INCLUDE_SENTIBOARD_SENSORS_STIMPARSER_HPP_
#define INCLUDE_SENTIBOARD_SENSORS_STIMPARSER_HPP_
#include <tuple>
#include "sentiboard/messages/ImuMessage.hpp"
#include "SentiboardParser.hpp"
class StimParser : public SentiboardParser {
private:
float stim_bytes_to_float(const uint8_t *ptr, uint8_t div) {
return stim_bytes_to_float((int8_t)ptr[0], ptr[1], ptr[2], div);
}
float stim_bytes_to_float(int8_t a, uint8_t b, uint8_t c, uint8_t div) {
float tmp = (a << 16) + (b << 8) + c;
return tmp / (1 << div);
}
public:
bool parse(const sentiboard::Package package, ImuMessage *message,
bool delta_values) {
if (package.data_len() != 38) {
return false;
}
const uint8_t *data = package.data();
if (data[0] != 0x93) {
return false;
}
uint8_t gyro_div = delta_values ? 21 : 14;
float g_x = stim_bytes_to_float(&data[1], gyro_div);
float g_y = stim_bytes_to_float(&data[4], gyro_div);
float g_z = stim_bytes_to_float(&data[7], gyro_div);
std::tuple<float, float, float> gyro(g_x, g_y, g_z);
// TODO(sigurdal): implement other than 10g
uint8_t accl_div = delta_values ? 22 : 19;
float a_x = stim_bytes_to_float(&data[11], accl_div);
float a_y = stim_bytes_to_float(&data[14], accl_div);
float a_z = stim_bytes_to_float(&data[17], accl_div);
std::tuple<float, float, float> accl(a_x, a_y, a_z);
message->populate(package, accl, gyro, delta_values);
return true;
}
};
#endif // INCLUDE_SENTIBOARD_SENSORS_STIMPARSER_HPP_
// Copyright [2017] <Sigurd M. Albrektsen>
#include "sentiboard/Package.hpp"
#include <stdint.h>
#include <iostream>
#include <iomanip>
#define SENTIBOARD_MAX_SKIP 512
#define SENTIBOARD_HEADER_SIZE 8
#define SENTIBOARD_CHECKSUM_SIZE 2
#define SENTIBOARD_HEADER_CHECKSUM_POS (SENTIBOARD_HEADER_SIZE \
- SENTIBOARD_CHECKSUM_SIZE)
#define SENTIBOARD_TOV_POS (SENTIBOARD_HEADER_SIZE)
#define SENTIBOARD_TOA_POS (SENTIBOARD_TOV_POS + 4)
#define SENTIBOARD_TOT_POS (SENTIBOARD_TOA_POS + 4)