Changeset - 3da4b5482573
Parent rev.
Child rev.
[Not reviewed]
settings
0 11 2
Hasan Yavuz ÖZDERYA - 9 years ago 2016-09-04 17:56:19
hy@ozderya.net
implemented settings for simple binary reader
13 files changed with 189 insertions and 14 deletions:
CMakeLists.txt
1
src/binarystreamreader.cpp
10
1
src/binarystreamreader.h
6
src/binarystreamreadersettings.cpp
41
src/binarystreamreadersettings.h
7
src/dataformatpanel.cpp
6
src/endiannessbox.cpp
12
src/endiannessbox.h
4
1
src/numberformat.cpp
42
src/numberformat.h
43
src/numberformatbox.cpp
5
src/numberformatbox.h
6
12
src/setting_defines.h
6
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
@@ -22,192 +22,193 @@ cmake_minimum_required(VERSION 2.8.11)
 
project(serialplot)
 

			




	
	
	
		
 
set(PROGRAM_NAME ${CMAKE_PROJECT_NAME} CACHE STRING "Output program name")

			




	
	
	
		
 
set(PROGRAM_DISPLAY_NAME "SerialPlot" CACHE STRING "Display name (menus etc) of the program")

			




	
	
	
		
 

			




	
	
	
		
 
# Find includes in corresponding build directories

			




	
	
	
		
 
set(CMAKE_INCLUDE_CURRENT_DIR ON)

			




	
	
	
		
 

			




	
	
	
		
 
# Instruct CMake to run moc automatically when needed.

			




	
	
	
		
 
set(CMAKE_AUTOMOC ON)

			




	
	
	
		
 

			




	
	
	
		
 
# add local path for cmake modules

			




	
	
	
		
 
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")

			




	
	
	
		
 

			




	
	
	
		
 
# Find the QtWidgets library

			




	
	
	
		
 
find_package(Qt5Widgets)

			




	
	
	
		
 

			




	
	
	
		
 
# If set, cmake will download Qwt over SVN, build and use it as a static library.

			




	
	
	
		
 
set(BUILD_QWT true CACHE BOOL "Download and build Qwt automatically.")

			




	
	
	
		
 
# Find QWT or use static manually provided by user

			




	
	
	
		
 
set(QWT_USE_STATIC false CACHE BOOL "Use a static version of Qwt provided by user.")

			




	
	
	
		
 
set(QWT_STATIC_LIBRARY "" CACHE FILEPATH "Path to the static Qwt library, libqwt.a.")

			




	
	
	
		
 
set(QWT_STATIC_INCLUDE "" CACHE PATH "Path to the Qwt include directory when building Qwt static.")

			




	
	
	
		
 

			




	
	
	
		
 
if (BUILD_QWT)

			




	
	
	
		
 
  include(BuildQwt)

			




	
	
	
		
 
else (BUILD_QWT)

			




	
	
	
		
 
  if (QWT_USE_STATIC)

			




	
	
	
		
 
	set(QWT_LIBRARY ${QWT_STATIC_LIBRARY})

			




	
	
	
		
 
	set(QWT_INCLUDE_DIR ${QWT_STATIC_INCLUDE})

			




	
	
	
		
 
  else (QWT_USE_STATIC)

			




	
	
	
		
 
	find_package(Qwt 6.1 REQUIRED)

			




	
	
	
		
 
  endif (QWT_USE_STATIC)

			




	
	
	
		
 
endif (BUILD_QWT)

			




	
	
	
		
 

			




	
	
	
		
 
# includes

			




	
	
	
		
 
include_directories("./src" ${QWT_INCLUDE_DIR})

			




	
	
	
		
 

			




	
	
	
		
 
# wrap UI and resource files

			




	
	
	
		
 
qt5_wrap_ui(UI_FILES

			




	
	
	
		
 
  src/mainwindow.ui

			




	
	
	
		
 
  src/portcontrol.ui

			




	
	
	
		
 
  src/about_dialog.ui

			




	
	
	
		
 
  src/snapshotview.ui

			




	
	
	
		
 
  src/commandpanel.ui

			




	
	
	
		
 
  src/commandwidget.ui

			




	
	
	
		
 
  src/dataformatpanel.ui

			




	
	
	
		
 
  src/plotcontrolpanel.ui

			




	
	
	
		
 
  src/numberformatbox.ui

			




	
	
	
		
 
  src/endiannessbox.ui

			




	
	
	
		
 
  src/binarystreamreadersettings.ui

			




	
	
	
		
 
  src/asciireadersettings.ui

			




	
	
	
		
 
  src/framedreadersettings.ui

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  qt5_add_resources(RES_FILES misc/icons.qrc misc/winicons.qrc)

			




	
	
	
		
 
else (WIN32)

			




	
	
	
		
 
  qt5_add_resources(RES_FILES misc/icons.qrc)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
add_executable(${PROGRAM_NAME} WIN32

			




	
	
	
		
 
  src/main.cpp

			




	
	
	
		
 
  src/mainwindow.cpp

			




	
	
	
		
 
  src/portcontrol.cpp

			




	
	
	
		
 
  src/plot.cpp

			




	
	
	
		
 
  src/zoomer.cpp

			




	
	
	
		
 
  src/hidabletabwidget.cpp

			




	
	
	
		
 
  src/framebuffer.cpp

			




	
	
	
		
 
  src/scalepicker.cpp

			




	
	
	
		
 
  src/scalezoomer.cpp

			




	
	
	
		
 
  src/portlist.cpp

			




	
	
	
		
 
  src/snapshot.cpp

			




	
	
	
		
 
  src/snapshotview.cpp

			




	
	
	
		
 
  src/snapshotmanager.cpp

			




	
	
	
		
 
  src/plotsnapshotoverlay.cpp

			




	
	
	
		
 
  src/commandpanel.cpp

			




	
	
	
		
 
  src/commandwidget.cpp

			




	
	
	
		
 
  src/commandedit.cpp

			




	
	
	
		
 
  src/dataformatpanel.cpp

			




	
	
	
		
 
  src/plotcontrolpanel.cpp

			




	
	
	
		
 
  src/tooltipfilter.cpp

			




	
	
	
		
 
  src/sneakylineedit.cpp

			




	
	
	
		
 
  src/channelmanager.cpp

			




	
	
	
		
 
  src/framebufferseries.cpp

			




	
	
	
		
 
  src/numberformatbox.cpp

			




	
	
	
		
 
  src/endiannessbox.cpp

			




	
	
	
		
 
  src/abstractreader.cpp

			




	
	
	
		
 
  src/binarystreamreader.cpp

			




	
	
	
		
 
  src/binarystreamreadersettings.cpp

			




	
	
	
		
 
  src/asciireader.cpp

			




	
	
	
		
 
  src/asciireadersettings.cpp

			




	
	
	
		
 
  src/demoreader.cpp

			




	
	
	
		
 
  src/framedreader.cpp

			




	
	
	
		
 
  src/framedreadersettings.cpp

			




	
	
	
		
 
  src/plotmanager.cpp

			




	
	
	
		
 
  src/numberformat.cpp

			




	
	
	
		
 
  misc/windows_icon.rc

			




	
	
	
		
 
  ${UI_FILES}

			




	
	
	
		
 
  ${RES_FILES}

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
# Use the Widgets module from Qt 5.

			




	
	
	
		
 
target_link_libraries(${PROGRAM_NAME} ${QWT_LIBRARY})

			




	
	
	
		
 
qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Svg)

			




	
	
	
		
 

			




	
	
	
		
 
if (BUILD_QWT)

			




	
	
	
		
 
  add_dependencies(${PROGRAM_NAME} QWT)

			




	
	
	
		
 
endif (BUILD_QWT)

			




	
	
	
		
 

			




	
	
	
		
 
# set compiler flags

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

			




	
	
	
		
 

			




	
	
	
		
 
# Enable C++11 support, fail if not supported

			




	
	
	
		
 
include(CheckCXXCompilerFlag)

			




	
	
	
		
 
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

			




	
	
	
		
 
CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

			




	
	
	
		
 
if(COMPILER_SUPPORTS_CXX11)

			




	
	
	
		
 
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

			




	
	
	
		
 
elseif(COMPILER_SUPPORTS_CXX0X)

			




	
	
	
		
 
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

			




	
	
	
		
 
else()

			




	
	
	
		
 
  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
# version number

			




	
	
	
		
 
set(MAJOR_VERSION 0 CACHE INT "Program major version number.")

			




	
	
	
		
 
set(MINOR_VERSION 7 CACHE INT "Program minor version number.")

			




	
	
	
		
 
set(PATCH_VERSION 1 CACHE INT "Program patch version number.")

			




	
	
	
		
 
set(VERSION_STRING "${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}")

			




	
	
	
		
 

			




	
	
	
		
 
# get revision number from mercurial

			




	
	
	
		
 
find_program(MERCURIAL hg)

			




	
	
	
		
 

			




	
	
	
		
 
if (MERCURIAL)

			




	
	
	
		
 
  execute_process(COMMAND ${MERCURIAL} id -i

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}

			




	
	
	
		
 
    RESULT_VARIABLE MERCURIAL_RESULT

			




	
	
	
		
 
    OUTPUT_VARIABLE VERSION_REVISION

			




	
	
	
		
 
    OUTPUT_STRIP_TRAILING_WHITESPACE)

			




	
	
	
		
 
  if(NOT MERCURIAL_RESULT EQUAL 0)

			




	
	
	
		
 
    set(VERSION_SCM_REVISION false)

			




	
	
	
		
 
  endif(NOT MERCURIAL_RESULT EQUAL 0)

			




	
	
	
		
 
endif (MERCURIAL)

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT VERSION_REVISION)

			




	
	
	
		
 
  set(VERSION_REVISION "0")

			




	
	
	
		
 
endif (NOT VERSION_REVISION)

			




	
	
	
		
 

			




	
	
	
		
 
message("SCM revision: ${VERSION_REVISION}")

			




	
	
	
		
 

			




	
	
	
		
 
# configure version file

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")

			




	
	
	
		
 

			




	
	
	
		
 
# add make run target

			




	
	
	
		
 
add_custom_target(run

			




	
	
	
		
 
    COMMAND ${PROGRAM_NAME}

			




	
	
	
		
 
    DEPENDS ${PROGRAM_NAME}

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

			




	
	
	
		
 
)

			




	
	
	
		
 

			




	
	
	
		
 
# installing

			




	
	
	
		
 
install(TARGETS ${PROGRAM_NAME} DESTINATION bin)

			




	
	
	
		
 

			




	
	
	
		
 
# for windows put libraries to install directory

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  file(GLOB WINDOWS_INSTALL_LIBRARIES

			




	
	
	
		
 
    "${CMAKE_BINARY_DIR}/windows_install_libraries/*.*")

			




	
	
	
		
 
  install(FILES ${WINDOWS_INSTALL_LIBRARIES} DESTINATION bin)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
# install menu item and icon

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.desktop.in"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop")

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.png"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png" COPYONLY)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # first copy files to share/serialplot/

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop

			




	
	
	
		
 
    DESTINATION share/applications/)

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png

			




	
	
	
		
 
	DESTINATION share/icons/hicolor/256x256/apps/)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# uninstalling

			




	
	
	
		
 
configure_file(

			




	
	
	
		
 
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

			




	
	
	
		
 
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

			




	
	
	
		
 
  @ONLY)

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/binarystreamreader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -86,121 +86,130 @@ void BinaryStreamReader::pause(bool enab

			




	
	
	
		
 
void BinaryStreamReader::onNumberFormatChanged(NumberFormat numberFormat)

			




	
	
	
		
 
{

			




	
	
	
		
 
    switch(numberFormat)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        case NumberFormat_uint8:

			




	
	
	
		
 
            sampleSize = 1;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<quint8>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int8:

			




	
	
	
		
 
            sampleSize = 1;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<qint8>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_uint16:

			




	
	
	
		
 
            sampleSize = 2;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<quint16>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int16:

			




	
	
	
		
 
            sampleSize = 2;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<qint16>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_uint32:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<quint32>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int32:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<qint32>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_float:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &BinaryStreamReader::readSampleAs<float>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::onNumOfChannelsChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfChannels = value;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::onDataReady()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

			




	
	
	
		
 
    int packageSize = sampleSize * _numOfChannels;

			




	
	
	
		
 
    int bytesAvailable = _device->bytesAvailable();

			




	
	
	
		
 

			




	
	
	
		
 
    // skip 1 byte if requested

			




	
	
	
		
 
    if (bytesAvailable > 0 && skipByteRequested)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _device->read(1);

			




	
	
	
		
 
        skipByteRequested = false;

			




	
	
	
		
 
        bytesAvailable--;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // skip 1 sample (channel) if requested

			




	
	
	
		
 
    if (bytesAvailable >= (int) sampleSize && skipSampleRequested)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _device->read(sampleSize);

			




	
	
	
		
 
        skipSampleRequested = false;

			




	
	
	
		
 
        bytesAvailable--;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (bytesAvailable < packageSize) return;

			




	
	
	
		
 

			




	
	
	
		
 
    int numOfPackagesToRead =

			




	
	
	
		
 
        (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;

			




	
	
	
		
 

			




	
	
	
		
 
    if (paused)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // read and discard data

			




	
	
	
		
 
        _device->read(numOfPackagesToRead*packageSize);

			




	
	
	
		
 
        return;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    double* channelSamples = new double[numOfPackagesToRead*_numOfChannels];

			




	
	
	
		
 

			




	
	
	
		
 
    for (int i = 0; i < numOfPackagesToRead; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned int ci = 0; ci < _numOfChannels; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // channelSamples[ci].replace(i, (this->*readSample)());

			




	
	
	
		
 
            channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned int ci = 0; ci < _numOfChannels; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        addChannelData(ci,

			




	
	
	
		
 
                       channelSamples + ci*numOfPackagesToRead,

			




	
	
	
		
 
                       numOfPackagesToRead);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    emit dataAdded();

			




	
	
	
		
 

			




	
	
	
		
 
    delete channelSamples;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
template<typename T> double BinaryStreamReader::readSampleAs()

			




	
	
	
		
 
{

			




	
	
	
		
 
    T data;

			




	
	
	
		
 

			




	
	
	
		
 
    _device->read((char*) &data, sizeof(data));

			




	
	
	
		
 

			




	
	
	
		
 
    if (_settingsWidget.endianness() == LittleEndian)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        data = qFromLittleEndian(data);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        data = qFromBigEndian(data);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return double(data);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::addChannelData(unsigned int channel,

			




	
	
	
		
 
                                        double* data, unsigned size)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _channelMan->addChannelData(channel, data, size);

			




	
	
	
		
 
    sampleCount += size;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/binarystreamreader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef BINARYSTREAMREADER_H

			




	
	
	
		
 
#define BINARYSTREAMREADER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "abstractreader.h"

			




	
	
	
		
 
#include "binarystreamreadersettings.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * Reads a simple stream of samples in binary form from the

			




	
	
	
		
 
 * device. There is no means of synchronization other than a button

			




	
	
	
		
 
 * that should be manually triggered by user.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class BinaryStreamReader : public AbstractReader

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);

			




	
	
	
		
 
    QWidget* settingsWidget();

			




	
	
	
		
 
    unsigned numOfChannels();

			




	
	
	
		
 
    void enable(bool enabled = true);

			




	
	
	
		
 
    /// Stores settings into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads settings from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    void pause(bool);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    BinaryStreamReaderSettings _settingsWidget;

			




	
	
	
		
 
    unsigned _numOfChannels;

			




	
	
	
		
 
    unsigned sampleSize;

			




	
	
	
		
 
    bool paused;

			




	
	
	
		
 
    bool skipByteRequested;

			




	
	
	
		
 
    bool skipSampleRequested;

			




	
	
	
		
 

			




	
	
	
		
 
    /// points to the readSampleAs function for currently selected number format

			




	
	
	
		
 
    double (BinaryStreamReader::*readSample)();

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Reads 1 sample from the device in given format.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @note Device should already have enough bytes present before

			




	
	
	
		
 
     * calling this function.

			




	
	
	
		
 
     */

			




	
	
	
		
 
    template<typename T> double readSampleAs();

			




	
	
	
		
 

			




	
	
	
		
 
    // `data` contains i th channels data

			




	
	
	
		
 
    void addChannelData(unsigned int channel, double* data, unsigned size);

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onNumberFormatChanged(NumberFormat numberFormat);

			




	
	
	
		
 
    void onNumOfChannelsChanged(unsigned value);

			




	
	
	
		
 
    void onDataReady();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // BINARYSTREAMREADER_H

			




        

    


    
    

    

        

                

                    src/binarystreamreadersettings.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "binarystreamreadersettings.h"

			




	
	
	
		
 
#include "ui_binarystreamreadersettings.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
BinaryStreamReaderSettings::BinaryStreamReaderSettings(QWidget *parent) :

			




	
	
	
		
 
    QWidget(parent),

			




	
	
	
		
 
    ui(new Ui::BinaryStreamReaderSettings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    // Note: if directly connected we get a runtime warning on incompatible signal arguments

			




	
	
	
		
 
    connect(ui->spNumOfChannels, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

			




	
	
	
		
 
            [this](int value)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                emit numOfChannelsChanged(value);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->nfBox, SIGNAL(selectionChanged(NumberFormat)),

			




	
	
	
		
 
            this, SIGNAL(numberFormatChanged(NumberFormat)));

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->pbSkipByte, SIGNAL(clicked()), this, SIGNAL(skipByteRequested()));

			




	
	
	
		
 
    connect(ui->pbSkipSample, SIGNAL(clicked()), this, SIGNAL(skipSampleRequested()));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
BinaryStreamReaderSettings::~BinaryStreamReaderSettings()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned BinaryStreamReaderSettings::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->spNumOfChannels->value();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NumberFormat BinaryStreamReaderSettings::numberFormat()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->nfBox->currentSelection();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Endianness BinaryStreamReaderSettings::endianness()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->endiBox->currentSelection();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReaderSettings::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Binary);

			




	
	
	
		
 
    settings->setValue(SG_Binary_NumOfChannels, numOfChannels());

			




	
	
	
		
 
    settings->setValue(SG_Binary_NumberFormat, numberFormatToStr(numberFormat()));

			




	
	
	
		
 
    settings->setValue(SG_Binary_Endianness,

			




	
	
	
		
 
                       endianness() == LittleEndian ? "little" : "big");

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReaderSettings::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Binary);

			




	
	
	
		
 

			




	
	
	
		
 
    // load number of channels

			




	
	
	
		
 
    ui->spNumOfChannels->setValue(

			




	
	
	
		
 
        settings->value(SG_Binary_NumOfChannels, numOfChannels()).toInt());

			




	
	
	
		
 

			




	
	
	
		
 
    // load number format

			




	
	
	
		
 
    NumberFormat nfSetting =

			




	
	
	
		
 
        strToNumberFormat(settings->value(SG_Binary_NumberFormat,

			




	
	
	
		
 
                                          QString()).toString());

			




	
	
	
		
 
    if (nfSetting == NumberFormat_INVALID) nfSetting = numberFormat();

			




	
	
	
		
 
    ui->nfBox->setSelection(nfSetting);

			




	
	
	
		
 

			




	
	
	
		
 
    // load endianness

			




	
	
	
		
 
    QString endiannessSetting =

			




	
	
	
		
 
        settings->value(SG_Binary_Endianness, QString()).toString();

			




	
	
	
		
 
    if (endiannessSetting == "little")

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->endiBox->setSelection(LittleEndian);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (endiannessSetting == "big")

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->endiBox->setSelection(BigEndian);

			




	
	
	
		
 
    } // else don't change

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/binarystreamreadersettings.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef BINARYSTREAMREADERSETTINGS_H

			




	
	
	
		
 
#define BINARYSTREAMREADERSETTINGS_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "numberformatbox.h"

			




	
	
	
		
 
#include "endiannessbox.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class BinaryStreamReaderSettings;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
class BinaryStreamReaderSettings : public QWidget

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit BinaryStreamReaderSettings(QWidget *parent = 0);

			




	
	
	
		
 
    ~BinaryStreamReaderSettings();

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numOfChannels();

			




	
	
	
		
 
    NumberFormat numberFormat();

			




	
	
	
		
 
    Endianness endianness();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Stores settings into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads settings from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numOfChannelsChanged(unsigned);

			




	
	
	
		
 
    void numberFormatChanged(NumberFormat);

			




	
	
	
		
 
    void skipByteRequested();

			




	
	
	
		
 
    void skipSampleRequested();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::BinaryStreamReaderSettings *ui;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // BINARYSTREAMREADERSETTINGS_H

			




        

    


    
    

    

        

                

                    src/dataformatpanel.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -76,124 +76,130 @@ DataFormatPanel::DataFormatPanel(QSerial

			




	
	
	
		
 
    connect(this, &DataFormatPanel::numOfChannelsChanged,

			




	
	
	
		
 
            &demoReader, &DemoReader::setNumOfChannels);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
DataFormatPanel::~DataFormatPanel()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned DataFormatPanel::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return currentReader->numOfChannels();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::pause(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = enabled;

			




	
	
	
		
 
    currentReader->pause(enabled);

			




	
	
	
		
 
    demoReader.pause(enabled);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::enableDemo(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        demoReader.enable();

			




	
	
	
		
 
        connect(&demoReader, &DemoReader::dataAdded,

			




	
	
	
		
 
                this, &DataFormatPanel::dataAdded);

			




	
	
	
		
 
        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

			




	
	
	
		
 
                this, &DataFormatPanel::samplesPerSecondChanged);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        demoReader.enable(false);

			




	
	
	
		
 
        disconnect(&demoReader, 0, this, 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::addChannelData(unsigned int channel,

			




	
	
	
		
 
                                     double* data, unsigned size)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _channelMan->addChannelData(channel, data, size);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::selectReader(AbstractReader* reader)

			




	
	
	
		
 
{

			




	
	
	
		
 
    currentReader->enable(false);

			




	
	
	
		
 
    reader->enable();

			




	
	
	
		
 

			




	
	
	
		
 
    // re-connect signals

			




	
	
	
		
 
    disconnect(currentReader, 0, this, 0);

			




	
	
	
		
 
    connect(reader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

			




	
	
	
		
 
    connect(reader, SIGNAL(numOfChannelsChanged(unsigned)),

			




	
	
	
		
 
            this, SIGNAL(numOfChannelsChanged(unsigned)));

			




	
	
	
		
 
    connect(reader, SIGNAL(samplesPerSecondChanged(unsigned)),

			




	
	
	
		
 
            this, SIGNAL(samplesPerSecondChanged(unsigned)));

			




	
	
	
		
 

			




	
	
	
		
 
    // switch the settings widget

			




	
	
	
		
 
    ui->horizontalLayout->removeWidget(currentReader->settingsWidget());

			




	
	
	
		
 
    currentReader->settingsWidget()->hide();

			




	
	
	
		
 
    ui->horizontalLayout->addWidget(reader->settingsWidget(), 1);

			




	
	
	
		
 
    reader->settingsWidget()->show();

			




	
	
	
		
 

			




	
	
	
		
 
    // notify if number of channels is different

			




	
	
	
		
 
    if (currentReader->numOfChannels() != reader->numOfChannels())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        emit numOfChannelsChanged(reader->numOfChannels());

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // pause

			




	
	
	
		
 
    reader->pause(paused);

			




	
	
	
		
 

			




	
	
	
		
 
    currentReader = reader;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_DataFormat);

			




	
	
	
		
 

			




	
	
	
		
 
    // save selected format

			




	
	
	
		
 
    QString format;

			




	
	
	
		
 
    if (currentReader == &bsReader)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        format = "binary";

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (currentReader == &asciiReader)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        format = "ascii";

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else // framed reader

			




	
	
	
		
 
    {

			




	
	
	
		
 
        format = "custom";

			




	
	
	
		
 
    }

			




	
	
	
		
 
    settings->setValue(SG_DataFormat_Format, format);

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 

			




	
	
	
		
 
    // save reader settings

			




	
	
	
		
 
    bsReader.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_DataFormat);

			




	
	
	
		
 

			




	
	
	
		
 
    // load selected format

			




	
	
	
		
 
    QString format = settings->value(

			




	
	
	
		
 
        SG_DataFormat_Format, QString()).toString();

			




	
	
	
		
 

			




	
	
	
		
 
    if (format == "binary")

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectReader(&bsReader);

			




	
	
	
		
 
        ui->rbBinary->setChecked(true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (format == "ascii")

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectReader(&asciiReader);

			




	
	
	
		
 
        ui->rbAscii->setChecked(true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (format == "custom")

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectReader(&framedReader);

			




	
	
	
		
 
        ui->rbFramed->setChecked(true);

			




	
	
	
		
 
    } // else current selection stays

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 

			




	
	
	
		
 
    // load reader settings

			




	
	
	
		
 
    bsReader.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/endiannessbox.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "endiannessbox.h"

			




	
	
	
		
 
#include "ui_endiannessbox.h"

			




	
	
	
		
 

			




	
	
	
		
 
EndiannessBox::EndiannessBox(QWidget *parent) :

			




	
	
	
		
 
    QWidget(parent),

			




	
	
	
		
 
    ui(new Ui::EndiannessBox)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->rbLittleE, &QRadioButton::toggled, [this](bool checked)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                emit selectionChanged(currentSelection());

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
EndiannessBox::~EndiannessBox()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Endianness EndiannessBox::currentSelection()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (ui->rbLittleE->isChecked())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return LittleEndian;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return BigEndian;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void EndiannessBox::setSelection(Endianness endianness)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (endianness == LittleEndian)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->rbLittleE->setChecked(true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else // big endian

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->rbBigE->setChecked(true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/endiannessbox.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef ENDIANNESSBOX_H

			




	
	
	
		
 
#define ENDIANNESSBOX_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class EndiannessBox;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
enum Endianness

			




	
	
	
		
 
{

			




	
	
	
		
 
    LittleEndian,

			




	
	
	
		
 
    BigEndian

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
class EndiannessBox : public QWidget

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit EndiannessBox(QWidget *parent = 0);

			




	
	
	
		
 
    ~EndiannessBox();

			




	
	
	
		
 

			




	
	
	
		
 
    Endianness currentSelection(); ///< currently selected endianness

			




	
	
	
		
 
    /// currently selected endianness

			




	
	
	
		
 
    Endianness currentSelection();

			




	
	
	
		
 
    /// change the currently selected endianness

			




	
	
	
		
 
    void setSelection(Endianness endianness);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    /// Signaled when endianness selection is changed

			




	
	
	
		
 
    void selectionChanged(Endianness endianness);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::EndiannessBox *ui;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // ENDIANNESSBOX_H

			




        

    


    
    

    

        

                

                    src/numberformat.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <QMap>

			




	
	
	
		
 

			




	
	
	
		
 
#include "numberformat.h"

			




	
	
	
		
 

			




	
	
	
		
 
QMap<NumberFormat, QString> mapping({

			




	
	
	
		
 
        {NumberFormat_uint8, "uint8"},

			




	
	
	
		
 
        {NumberFormat_uint16, "uint16"},

			




	
	
	
		
 
        {NumberFormat_uint32, "uint32"},

			




	
	
	
		
 
        {NumberFormat_int8, "int8"},

			




	
	
	
		
 
        {NumberFormat_int16, "int16"},

			




	
	
	
		
 
        {NumberFormat_int32, "int32"},

			




	
	
	
		
 
        {NumberFormat_float, "float"}

			




	
	
	
		
 
    });

			




	
	
	
		
 

			




	
	
	
		
 
QString numberFormatToStr(NumberFormat nf)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return mapping.value(nf);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NumberFormat strToNumberFormat(QString str)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return mapping.key(str, NumberFormat_INVALID);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/numberformat.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NUMBERFORMAT_H

			




	
	
	
		
 
#define NUMBERFORMAT_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QString>

			




	
	
	
		
 

			




	
	
	
		
 
enum NumberFormat

			




	
	
	
		
 
{

			




	
	
	
		
 
    NumberFormat_uint8,

			




	
	
	
		
 
    NumberFormat_uint16,

			




	
	
	
		
 
    NumberFormat_uint32,

			




	
	
	
		
 
    NumberFormat_int8,

			




	
	
	
		
 
    NumberFormat_int16,

			




	
	
	
		
 
    NumberFormat_int32,

			




	
	
	
		
 
    NumberFormat_float,

			




	
	
	
		
 
    NumberFormat_INVALID ///< used for error cases

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
/// Convert `NumberFormat` to string for representation

			




	
	
	
		
 
QString numberFormatToStr(NumberFormat nf);

			




	
	
	
		
 

			




	
	
	
		
 
/// Convert string to `NumberFormat`

			




	
	
	
		
 
NumberFormat strToNumberFormat(QString str);

			




	
	
	
		
 

			




	
	
	
		
 
#endif // NUMBERFORMAT_H

			




        

    


    
    

    

        

                

                    src/numberformatbox.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "numberformatbox.h"

			




	
	
	
		
 
#include "ui_numberformatbox.h"

			




	
	
	
		
 

			




	
	
	
		
 
NumberFormatBox::NumberFormatBox(QWidget *parent) :

			




	
	
	
		
 
    QWidget(parent),

			




	
	
	
		
 
    ui(new Ui::NumberFormatBox)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup buttons

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbUint8,  NumberFormat_uint8);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbUint16, NumberFormat_uint16);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbUint32, NumberFormat_uint32);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbInt8,   NumberFormat_int8);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbInt16,  NumberFormat_int16);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbInt32,  NumberFormat_int32);

			




	
	
	
		
 
    buttonGroup.addButton(ui->rbFloat,  NumberFormat_float);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(

			




	
	
	
		
 
        &buttonGroup, SIGNAL(buttonToggled(int, bool)),

			




	
	
	
		
 
        this, SLOT(onButtonToggled(int, bool)));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NumberFormatBox::~NumberFormatBox()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NumberFormatBox::onButtonToggled(int numberFormatId, bool checked)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (checked) emit selectionChanged((NumberFormat) numberFormatId);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
NumberFormat NumberFormatBox::currentSelection()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return (NumberFormat) buttonGroup.checkedId();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void NumberFormatBox::setSelection(NumberFormat nf)

			




	
	
	
		
 
{

			




	
	
	
		
 
    buttonGroup.button(nf)->setChecked(true);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/numberformatbox.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef NUMBERFORMATBOX_H

			




	
	
	
		
 
#define NUMBERFORMATBOX_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QButtonGroup>

			




	
	
	
		
 

			




	
	
	
		
 
#include "numberformat.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class NumberFormatBox;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
enum NumberFormat

			




	
	
	
		
 
{

			




	
	
	
		
 
    NumberFormat_uint8,

			




	
	
	
		
 
    NumberFormat_uint16,

			




	
	
	
		
 
    NumberFormat_uint32,

			




	
	
	
		
 
    NumberFormat_int8,

			




	
	
	
		
 
    NumberFormat_int16,

			




	
	
	
		
 
    NumberFormat_int32,

			




	
	
	
		
 
    NumberFormat_float,

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
class NumberFormatBox : public QWidget

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit NumberFormatBox(QWidget *parent = 0);

			




	
	
	
		
 
    ~NumberFormatBox();

			




	
	
	
		
 

			




	
	
	
		
 
    NumberFormat currentSelection(); ///< returns the currently selected number format

			




	
	
	
		
 
    /// returns the currently selected number format

			




	
	
	
		
 
    NumberFormat currentSelection();

			




	
	
	
		
 
    /// change the currently selected number format

			




	
	
	
		
 
    void setSelection(NumberFormat nf);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    /// Signaled when number format selection is changed

			




	
	
	
		
 
    void selectionChanged(NumberFormat numberFormat);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::NumberFormatBox *ui;

			




	
	
	
		
 
    QButtonGroup buttonGroup;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onButtonToggled(int numberFormatId, bool checked);

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // NUMBERFORMATBOX_H

			




        

    


    
    

    

        

                

                    src/setting_defines.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot 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 serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef SETTING_DEFINES_H

			




	
	
	
		
 
#define SETTING_DEFINES_H

			




	
	
	
		
 

			




	
	
	
		
 
const char SettingGroup_MainWindow[] = "MainWindow";

			




	
	
	
		
 
const char SettingGroup_Port[] = "Port";

			




	
	
	
		
 
const char SettingGroup_DataFormat[] = "DataFormat";

			




	
	
	
		
 
const char SettingGroup_Binary[] = "DataFormat_Binary";

			




	
	
	
		
 
const char SettingGroup_Channels[] = "Channels";

			




	
	
	
		
 
const char SettingGroup_Plot[] = "Plot";

			




	
	
	
		
 
const char SettingGroup_Commands[] = "Commands";

			




	
	
	
		
 

			




	
	
	
		
 
// mainwindow setting keys

			




	
	
	
		
 
const char SG_MainWindow_Size[] = "size";

			




	
	
	
		
 
const char SG_MainWindow_Pos[] = "pos";

			




	
	
	
		
 
const char SG_MainWindow_ActivePanel[] = "activePanel";

			




	
	
	
		
 
const char SG_MainWindow_HidePanels[] = "hidePanels";

			




	
	
	
		
 

			




	
	
	
		
 
// port setting keys

			




	
	
	
		
 
const char SG_Port_SelectedPort[] = "selectedPort";

			




	
	
	
		
 
const char SG_Port_BaudRate[] = "baudRate";

			




	
	
	
		
 
const char SG_Port_Parity[] = "parity";

			




	
	
	
		
 
const char SG_Port_DataBits[] = "dataBits";

			




	
	
	
		
 
const char SG_Port_StopBits[] = "stopBits";

			




	
	
	
		
 
const char SG_Port_FlowControl[] = "flowControl";

			




	
	
	
		
 

			




	
	
	
		
 
// data format panel keys

			




	
	
	
		
 
const char SG_DataFormat_Format[] = "format";

			




	
	
	
		
 

			




	
	
	
		
 
// binary stream reader keys

			




	
	
	
		
 
const char SG_Binary_NumOfChannels[] = "numOfChannels";

			




	
	
	
		
 
const char SG_Binary_NumberFormat[] = "numberFormat";

			




	
	
	
		
 
const char SG_Binary_Endianness[] = "endianness";

			




	
	
	
		
 

			




	
	
	
		
 
#endif // SETTING_DEFINES_H

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-13856
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support