Changeset - ff9d8ead5100
Parent rev.
Child rev.
[Not reviewed]
Merge default
0 22 5
Hasan Yavuz ÖZDERYA - 9 years ago 2017-02-16 08:08:30
hy@ozderya.net
Merge with recording
27 files changed with 970 insertions and 68 deletions:
CMakeLists.txt
7
1
cmake/modules/BuildQColorWidgets.cmake
2
serialplot.pro
6
3
src/abstractreader.cpp
15
2
src/abstractreader.h
23
8
src/asciireader.cpp
4
6
src/asciireader.h
3
2
src/binarystreamreader.cpp
4
6
src/binarystreamreader.h
2
1
src/channelinfomodel.cpp
13
3
src/channelinfomodel.h
5
3
src/channelmanager.cpp
10
src/channelmanager.h
5
1
src/dataformatpanel.cpp
22
10
src/dataformatpanel.h
15
3
src/datarecorder.cpp
89
src/datarecorder.h
77
src/demoreader.cpp
4
5
src/demoreader.h
3
2
src/framedreader.cpp
4
4
src/framedreader.h
3
2
src/mainwindow.cpp
39
4
src/mainwindow.h
5
1
src/recordpanel.cpp
286
src/recordpanel.h
117
src/recordpanel.ui
197
src/setting_defines.h
10
1
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
#
 
# Copyright © 2015-2016 Hasan Yavuz Özderya
 
# Copyright © 2017 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/>.
 
#
 

			




	
	
	
		
 
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)

			




	
	
	
		
 

			




	
	
	
		
 
include(BuildQColorWidgets)

			




	
	
	
		
 

			




	
	
	
		
 
# includes

			




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

			




	
	
	
		
 

			




	
	
	
		
 
# flags

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${QCW_FLAGS}")

			




	
	
	
		
 

			




	
	
	
		
 
# 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/recordpanel.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/scrollzoomer.cpp

			




	
	
	
		
 
  src/scrollbar.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/recordpanel.cpp

			




	
	
	
		
 
  src/datarecorder.cpp

			




	
	
	
		
 
  src/tooltipfilter.cpp

			




	
	
	
		
 
  src/sneakylineedit.cpp

			




	
	
	
		
 
  src/channelmanager.cpp

			




	
	
	
		
 
  src/channelinfomodel.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} ${QCW_LIBRARY})

			




	
	
	
		
 
qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort)

			




	
	
	
		
 

			




	
	
	
		
 
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 8 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)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  add_custom_target(uninstall

			




	
	
	
		
 
    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# packaging

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_GENERATOR "DEB")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_GENERATOR "NSIS")

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(InstallRequiredSystemLibraries)

			




	
	
	
		
 

			




	
	
	
		
 
set(CPACK_PACKAGE_NAME "${PROGRAM_NAME}")

			




	
	
	
		
 
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

			




	
	
	
		
 
set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MAJOR ${MAJOR_VERSION})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MINOR ${MINOR_VERSION})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_PATCH ${PATCH_VERSION})

			




	
	
	
		
 
set(CPACK_STRIP_FILES TRUE)

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5svg5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Small and simple software for plotting data from serial port

			




	
	
	
		
 
 Supports binary data formats ([u]int8, [u]int16, [u]int32, float)

			




	
	
	
		
 
 and ASCII (as CSV). Captured waveforms can be exported in CSV format.

			




	
	
	
		
 
 Can also send simple user defined commands to serial port device.")

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT QWT_USE_STATIC)

			




	
	
	
		
 
  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

			




	
	
	
		
 
endif (NOT QWT_USE_STATIC)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME}")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME};${PROGRAM_DISPLAY_NAME}")

			




	
	
	
		
 
  set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROGRAM_NAME}")

			




	
	
	
		
 
  set(CPACK_CREATE_DESKTOP_LINKS "${PROGRAM_NAME}")

			




	
	
	
		
 
  set(CPACK_NSIS_MODIFY_PATH "ON")

			




	
	
	
		
 
  set(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/misc/serialplot.bmp")

			




	
	
	
		
 
  string(REPLACE "/" "\\\\" CPACK_PACKAGE_ICON ${CPACK_PACKAGE_ICON})

			




	
	
	
		
 
  set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")

			




	
	
	
		
 
  set(CPACK_NSIS_MENU_LINKS

			




	
	
	
		
 
    "https://bitbucket.org/hyOzd/serialplot" "SerialPlot source code on bitbucket.org")

			




	
	
	
		
 
  set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL true)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # set debian package name

			




	
	
	
		
 
  string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_PACKAGE_NAME_LOWERCASE)

			




	
	
	
		
 
  find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")

			




	
	
	
		
 
  if(DPKG_PROGRAM)

			




	
	
	
		
 
    execute_process(

			




	
	
	
		
 
      COMMAND ${DPKG_PROGRAM} --print-architecture

			




	
	
	
		
 
      OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE

			




	
	
	
		
 
      OUTPUT_STRIP_TRAILING_WHITESPACE)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")

			




	
	
	
		
 
  else(DPKG_PROGRAM)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${PROJECT_VERSION}-${PROJECT_VERSION_REVISION}_${CMAKE_SYSTEM_NAME}")

			




	
	
	
		
 
  endif(DPKG_PROGRAM)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(CPack)

			




        

    


    
    

    

        

                

                    cmake/modules/BuildQColorWidgets.cmake
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#

			




	
	
	
		
 
# Copyright © 2017 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(ExternalProject)

			




	
	
	
		
 

			




	
	
	
		
 
ExternalProject_Add(QCW

			




	
	
	
		
 
  PREFIX qcw

			




	
	
	
		
 
  GIT_REPOSITORY https://github.com/mbasaglia/Qt-Color-Widgets

			




	
	
	
		
 
  PATCH_COMMAND patch -t -N -p1 -i ${CMAKE_CURRENT_LIST_DIR}/qt_5_2_moc_creation_namespace_fix.diff

			




	
	
	
		
 
  CMAKE_CACHE_ARGS "-DCMAKE_CXX_FLAGS:string=-D QTCOLORWIDGETS_STATICALLY_LINKED"

			




	
	
	
		
 
  UPDATE_COMMAND ""

			




	
	
	
		
 
  INSTALL_COMMAND "")

			




	
	
	
		
 

			




	
	
	
		
 
ExternalProject_Get_Property(QCW binary_dir source_dir)

			




	
	
	
		
 
set(QCW_FLAGS "-D QTCOLORWIDGETS_STATICALLY_LINKED")

			




	
	
	
		
 
set(QCW_LIBRARY ${binary_dir}/libColorWidgets-qt5.a)

			




	
	
	
		
 
set(QCW_INCLUDE_DIR ${source_dir}/include)

			




        

    


    
    

    

        

                

                    serialplot.pro
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#

			




	
	
	
		
 
# Copyright © 2015 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/>.

			




	
	
	
		
 
#

			




	
	
	
		
 

			




	
	
	
		
 
#-------------------------------------------------

			




	
	
	
		
 
#

			




	
	
	
		
 
# Project created by QtCreator 2015-03-04T08:20:06

			




	
	
	
		
 
#

			




	
	
	
		
 
#-------------------------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
QT       += core gui serialport

			




	
	
	
		
 

			




	
	
	
		
 
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

			




	
	
	
		
 

			




	
	
	
		
 
TARGET = serialplot

			




	
	
	
		
 
TEMPLATE = app

			




	
	
	
		
 

			




	
	
	
		
 
CONFIG += qwt

			




	
	
	
		
 

			




	
	
	
		
 
SOURCES += \

			




	
	
	
		
 
    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/snapshotview.cpp \

			




	
	
	
		
 
    src/snapshotmanager.cpp \

			




	
	
	
		
 
    src/snapshot.cpp \

			




	
	
	
		
 
    src/plotsnapshotoverlay.cpp \

			




	
	
	
		
 
    src/commandpanel.cpp \

			




	
	
	
		
 
    src/commandwidget.cpp \

			




	
	
	
		
 
    src/commandedit.cpp \

			




	
	
	
		
 
    src/dataformatpanel.cpp \

			




	
	
	
		
 
    src/tooltipfilter.cpp \

			




	
	
	
		
 
    src/sneakylineedit.cpp \

			




	
	
	
		
 
    src/channelmanager.cpp \

			




	
	
	
		
 
    src/framebufferseries.cpp \

			




	
	
	
		
 
    src/plotcontrolpanel.cpp \

			




	
	
	
		
 
    src/numberformatbox.cpp \

			




	
	
	
		
 
    src/endiannessbox.cpp \

			




	
	
	
		
 
    src/framedreadersettings.cpp \

			




	
	
	
		
 
    src/abstractreader.cpp \

			




	
	
	
		
 
    src/binarystreamreader.cpp \

			




	
	
	
		
 
    src/binarystreamreadersettings.cpp \

			




	
	
	
		
 
    src/asciireadersettings.cpp \

			




	
	
	
		
 
    src/asciireader.cpp \

			




	
	
	
		
 
    src/demoreader.cpp \

			




	
	
	
		
 
    src/framedreader.cpp \

			




	
	
	
		
 
    src/plotmanager.cpp \

			




	
	
	
		
 
    src/numberformat.cpp

			




	
	
	
		
 
    src/numberformat.cpp \

			




	
	
	
		
 
    src/recordpanel.cpp

			




	
	
	
		
 

			




	
	
	
		
 
HEADERS += \

			




	
	
	
		
 
    src/mainwindow.h \

			




	
	
	
		
 
    src/utils.h \

			




	
	
	
		
 
    src/portcontrol.h \

			




	
	
	
		
 
    src/floatswap.h \

			




	
	
	
		
 
    src/plot.h \

			




	
	
	
		
 
    src/zoomer.h \

			




	
	
	
		
 
    src/hidabletabwidget.h \

			




	
	
	
		
 
    src/framebuffer.h \

			




	
	
	
		
 
    src/scalepicker.h \

			




	
	
	
		
 
    src/scalezoomer.h \

			




	
	
	
		
 
    src/portlist.h \

			




	
	
	
		
 
    src/snapshotview.h \

			




	
	
	
		
 
    src/snapshotmanager.h \

			




	
	
	
		
 
    src/snapshot.h \

			




	
	
	
		
 
    src/plotsnapshotoverlay.h \

			




	
	
	
		
 
    src/commandpanel.h \

			




	
	
	
		
 
    src/commandwidget.h \

			




	
	
	
		
 
    src/commandedit.h \

			




	
	
	
		
 
    src/dataformatpanel.h \

			




	
	
	
		
 
    src/tooltipfilter.h \

			




	
	
	
		
 
    src/sneakylineedit.h \

			




	
	
	
		
 
    src/channelmanager.h \

			




	
	
	
		
 
    src/framebufferseries.h \

			




	
	
	
		
 
    src/plotcontrolpanel.h \

			




	
	
	
		
 
    src/numberformatbox.h \

			




	
	
	
		
 
    src/endiannessbox.h \

			




	
	
	
		
 
    src/framedreadersettings.h \

			




	
	
	
		
 
    src/abstractreader.h \

			




	
	
	
		
 
    src/binarystreamreader.h \

			




	
	
	
		
 
    src/binarystreamreadersettings.h \

			




	
	
	
		
 
    src/asciireadersettings.h \

			




	
	
	
		
 
    src/asciireader.h \

			




	
	
	
		
 
    src/demoreader.h \

			




	
	
	
		
 
    src/framedreader.h \

			




	
	
	
		
 
    src/plotmanager.h \

			




	
	
	
		
 
    src/setting_defines.h \

			




	
	
	
		
 
    src/numberformat.h

			




	
	
	
		
 
    src/numberformat.h \

			




	
	
	
		
 
    src/recordpanel.h

			




	
	
	
		
 

			




	
	
	
		
 
FORMS += \

			




	
	
	
		
 
    src/mainwindow.ui \

			




	
	
	
		
 
    src/about_dialog.ui \

			




	
	
	
		
 
    src/portcontrol.ui \

			




	
	
	
		
 
    src/snapshotview.ui \

			




	
	
	
		
 
    src/commandpanel.ui \

			




	
	
	
		
 
    src/commandwidget.ui \

			




	
	
	
		
 
    src/dataformatpanel.ui \

			




	
	
	
		
 
    src/plotcontrolpanel.ui \

			




	
	
	
		
 
    src/numberformatbox.ui \

			




	
	
	
		
 
    src/endiannessbox.ui \

			




	
	
	
		
 
    src/framedreadersettings.ui \

			




	
	
	
		
 
    src/binarystreamreadersettings.ui \

			




	
	
	
		
 
    src/asciireadersettings.ui

			




	
	
	
		
 
    src/asciireadersettings.ui \

			




	
	
	
		
 
    src/recordpanel.ui

			




	
	
	
		
 

			




	
	
	
		
 
INCLUDEPATH += qmake/ src/

			




	
	
	
		
 

			




	
	
	
		
 
CONFIG += c++11

			




	
	
	
		
 

			




	
	
	
		
 
RESOURCES += misc/icons.qrc

			




	
	
	
		
 

			




	
	
	
		
 
win32 {

			




	
	
	
		
 
    RESOURCES += misc/winicons.qrc

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/abstractreader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 "abstractreader.h"

			




	
	
	
		
 

			




	
	
	
		
 
AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

			




	
	
	
		
 
AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                               DataRecorder* recorder, QObject* parent) :

			




	
	
	
		
 
    QObject(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _device = device;

			




	
	
	
		
 
    _channelMan = channelMan;

			




	
	
	
		
 
    _recorder = recorder;

			




	
	
	
		
 
    recording = false;

			




	
	
	
		
 

			




	
	
	
		
 
    // initialize sps counter

			




	
	
	
		
 
    sampleCount = 0;

			




	
	
	
		
 
    samplesPerSecond = 0;

			




	
	
	
		
 
    QObject::connect(&spsTimer, &QTimer::timeout,

			




	
	
	
		
 
                     this, &AbstractReader::spsTimerTimeout);

			




	
	
	
		
 
    // TODO: start sps timer when reader is enabled

			




	
	
	
		
 
    spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AbstractReader::spsTimerTimeout()

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned currentSps = samplesPerSecond;

			




	
	
	
		
 
    samplesPerSecond = (sampleCount/numOfChannels())/SPS_UPDATE_TIMEOUT;

			




	
	
	
		
 
    if (currentSps != samplesPerSecond)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        emit samplesPerSecondChanged(samplesPerSecond);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    sampleCount = 0;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AbstractReader::addData(double* samples, unsigned length)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _channelMan->addData(samples, length);

			




	
	
	
		
 
    if (recording)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _recorder->addData(samples, length, numOfChannels());

			




	
	
	
		
 
    }

			




	
	
	
		
 
    sampleCount += length;

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/abstractreader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 ABSTRACTREADER_H

			




	
	
	
		
 
#define ABSTRACTREADER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QIODevice>

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QTimer>

			




	
	
	
		
 

			




	
	
	
		
 
#include "channelmanager.h"

			




	
	
	
		
 
#include "datarecorder.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * All reader classes must inherit this class.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class AbstractReader : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 
public:

			




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

			




	
	
	
		
 
    explicit AbstractReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                            DataRecorder* recorder, QObject* parent = 0);

			




	
	
	
		
 

			




	
	
	
		
 
    bool recording;                 /// is recording started

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Returns a widget to be shown in data format panel when reader

			




	
	
	
		
 
     * is selected.

			




	
	
	
		
 
     */

			




	
	
	
		
 
    virtual QWidget* settingsWidget() = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Number of channels being read.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * This number may be user selected or automatically determined

			




	
	
	
		
 
     * from incoming stream.

			




	
	
	
		
 
     */

			




	
	
	
		
 
    virtual unsigned numOfChannels() = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Reader should only read when enabled. Default state should be

			




	
	
	
		
 
    /// 'disabled'.

			




	
	
	
		
 
    virtual void enable(bool enabled = true) = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Starts sending data to recorder.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @note recorder must have been started!

			




	
	
	
		
 
     */

			




	
	
	
		
 
    void startRecording();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Stops recording.

			




	
	
	
		
 
    void stopRecording();

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numOfChannelsChanged(unsigned);

			




	
	
	
		
 
    // TODO: this must be signaled by 'channel man' for better abstraction

			




	
	
	
		
 
    void dataAdded(); ///< emitted when data added to channel man.

			




	
	
	
		
 
    // TODO: this should be a part of 'channel man'

			




	
	
	
		
 
    void samplesPerSecondChanged(unsigned);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Pauses the reading.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * Reader should actually continue reading to keep the

			




	
	
	
		
 
     * synchronization but shouldn't commit data.

			




	
	
	
		
 
     */

			




	
	
	
		
 
    virtual void pause(bool) = 0;

			




	
	
	
		
 

			




	
	
	
		
 
protected:

			




	
	
	
		
 
    QIODevice* _device;

			




	
	
	
		
 
    ChannelManager* _channelMan;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Implementing class should simply increase this count as samples are read

			




	
	
	
		
 
    unsigned sampleCount;

			




	
	
	
		
 
    /// Should be called with read data

			




	
	
	
		
 
    void addData(double* samples, unsigned length);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    const int SPS_UPDATE_TIMEOUT = 1;  // second

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned sampleCount;

			




	
	
	
		
 
    unsigned samplesPerSecond;

			




	
	
	
		
 

			




	
	
	
		
 
    ChannelManager* _channelMan;

			




	
	
	
		
 
    DataRecorder* _recorder;

			




	
	
	
		
 
    QTimer spsTimer;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void spsTimerTimeout();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // ABSTRACTREADER_H

			




        

    


    
    

    

        

                

                    src/asciireader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "asciireader.h"

			




	
	
	
		
 

			




	
	
	
		
 
/// If set to this value number of channels is determined from input

			




	
	
	
		
 
#define NUMOFCHANNELS_AUTO   (0)

			




	
	
	
		
 

			




	
	
	
		
 
AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, parent)

			




	
	
	
		
 
AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                         DataRecorder* recorder, QObject* parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, recorder, parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = false;

			




	
	
	
		
 
    discardFirstLine = true;

			




	
	
	
		
 
    sampleCount = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    _numOfChannels = _settingsWidget.numOfChannels();

			




	
	
	
		
 
    autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

			




	
	
	
		
 
            [this](unsigned value)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                _numOfChannels = value;

			




	
	
	
		
 
                autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);

			




	
	
	
		
 
                if (!autoNumOfChannels)

			




	
	
	
		
 
                {

			




	
	
	
		
 
                    emit numOfChannelsChanged(value);

			




	
	
	
		
 
                }

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QWidget* AsciiReader::settingsWidget()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_settingsWidget;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned AsciiReader::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // do not allow '0'

			




	
	
	
		
 
    if (_numOfChannels == 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return 1;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return _numOfChannels;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: this could be a part of AbstractReader

			




	
	
	
		
 
void AsciiReader::enable(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        discardFirstLine = true;

			




	
	
	
		
 
        QObject::connect(_device, &QIODevice::readyRead,

			




	
	
	
		
 
                         this, &AsciiReader::onDataReady);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QObject::disconnect(_device, 0, this, 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AsciiReader::pause(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = enabled;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AsciiReader::onDataReady()

			




	
	
	
		
 
{

			




	
	
	
		
 
    while(_device->canReadLine())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QByteArray line = _device->readLine();

			




	
	
	
		
 

			




	
	
	
		
 
        // discard only once when we just started reading

			




	
	
	
		
 
        if (discardFirstLine)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            discardFirstLine = false;

			




	
	
	
		
 
            continue;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // discard data if paused

			




	
	
	
		
 
        if (paused)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            continue;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // parse data

			




	
	
	
		
 
        line = line.trimmed();

			




	
	
	
		
 

			




	
	
	
		
 
        // Note: When data coming from pseudo terminal is buffered by

			




	
	
	
		
 
        // system CR is converted to LF for some reason. This causes

			




	
	
	
		
 
        // empty lines in the input when the port is just opened.

			




	
	
	
		
 
        if (line.isEmpty())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            continue;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        auto separatedValues = line.split(',');

			




	
	
	
		
 

			




	
	
	
		
 
        unsigned numReadChannels; // effective number of channels to read

			




	
	
	
		
 
        unsigned numComingChannels = separatedValues.length();

			




	
	
	
		
 

			




	
	
	
		
 
        if (autoNumOfChannels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // did number of channels changed?

			




	
	
	
		
 
            if (numComingChannels != _numOfChannels)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                _numOfChannels = numComingChannels;

			




	
	
	
		
 
                emit numOfChannelsChanged(numComingChannels);

			




	
	
	
		
 
            }

			




	
	
	
		
 
            numReadChannels = numComingChannels;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else if (numComingChannels >= _numOfChannels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            numReadChannels = _numOfChannels;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else // there is missing channel data

			




	
	
	
		
 
        {

			




	
	
	
		
 
            numReadChannels = separatedValues.length();

			




	
	
	
		
 
            qWarning() << "Incoming data is missing data for some channels!";

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // parse read line

			




	
	
	
		
 
        double* channelSamples = new double[_numOfChannels]();

			




	
	
	
		
 
        for (unsigned ci = 0; ci < numReadChannels; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            bool ok;

			




	
	
	
		
 
            channelSamples[ci] = separatedValues[ci].toDouble(&ok);

			




	
	
	
		
 
            if (!ok)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                qWarning() << "Data parsing error for channel: " << ci;

			




	
	
	
		
 
                channelSamples[ci] = 0;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // commit data

			




	
	
	
		
 
        _channelMan->addData(channelSamples, _numOfChannels);

			




	
	
	
		
 
        sampleCount += numReadChannels;

			




	
	
	
		
 
        emit dataAdded();

			




	
	
	
		
 
        addData(channelSamples, _numOfChannels);

			




	
	
	
		
 

			




	
	
	
		
 
        delete[] channelSamples;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AsciiReader::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void AsciiReader::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/asciireader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 ASCIIREADER_H

			




	
	
	
		
 
#define ASCIIREADER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "abstractreader.h"

			




	
	
	
		
 
#include "asciireadersettings.h"

			




	
	
	
		
 

			




	
	
	
		
 
class AsciiReader : public AbstractReader

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




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

			




	
	
	
		
 
    explicit AsciiReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                         DataRecorder* recorder, 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:

			




	
	
	
		
 
    AsciiReaderSettings _settingsWidget;

			




	
	
	
		
 
    unsigned _numOfChannels;

			




	
	
	
		
 
    /// number of channels will be determined from incoming data

			




	
	
	
		
 
    unsigned autoNumOfChannels;

			




	
	
	
		
 
    bool paused;

			




	
	
	
		
 

			




	
	
	
		
 
    // We may have (usually true) started reading in the middle of a

			




	
	
	
		
 
    // line, so its a better idea to just discard first line.

			




	
	
	
		
 
    bool discardFirstLine;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onDataReady();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // ASCIIREADER_H

			




        

    


    
    

    

        

                

                    src/binarystreamreader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <QtEndian>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "binarystreamreader.h"

			




	
	
	
		
 
#include "floatswap.h"

			




	
	
	
		
 

			




	
	
	
		
 
BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, parent)

			




	
	
	
		
 
BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                                       DataRecorder* recorder, QObject* parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, recorder, parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = false;

			




	
	
	
		
 
    skipByteRequested = false;

			




	
	
	
		
 
    skipSampleRequested = false;

			




	
	
	
		
 
    sampleCount = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    _numOfChannels = _settingsWidget.numOfChannels();

			




	
	
	
		
 
    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

			




	
	
	
		
 
            this, &BinaryStreamReader::numOfChannelsChanged);

			




	
	
	
		
 
    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

			




	
	
	
		
 
            this, &BinaryStreamReader::onNumOfChannelsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    // initial number format selection

			




	
	
	
		
 
    onNumberFormatChanged(_settingsWidget.numberFormat());

			




	
	
	
		
 
    connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,

			




	
	
	
		
 
            this, &BinaryStreamReader::onNumberFormatChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    // enable skip byte and sample buttons

			




	
	
	
		
 
    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,

			




	
	
	
		
 
            [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                skipByteRequested = true;

			




	
	
	
		
 
            });

			




	
	
	
		
 
    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,

			




	
	
	
		
 
            [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                skipSampleRequested = true;

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QWidget* BinaryStreamReader::settingsWidget()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_settingsWidget;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned BinaryStreamReader::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numOfChannels;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::enable(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QObject::connect(_device, &QIODevice::readyRead,

			




	
	
	
		
 
                         this, &BinaryStreamReader::onDataReady);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QObject::disconnect(_device, 0, this, 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::pause(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = enabled;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
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;

			




	
	
	
		
 
        case NumberFormat_INVALID:

			




	
	
	
		
 
            Q_ASSERT(1); // never

			




	
	
	
		
 
            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)();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    _channelMan->addData(channelSamples, numOfPackagesToRead*_numOfChannels);

			




	
	
	
		
 
    sampleCount += numOfPackagesToRead*_numOfChannels;

			




	
	
	
		
 
    emit dataAdded();

			




	
	
	
		
 
    addData(channelSamples, numOfPackagesToRead*_numOfChannels);

			




	
	
	
		
 

			




	
	
	
		
 
    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::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void BinaryStreamReader::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/binarystreamreader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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);

			




	
	
	
		
 
    explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                                DataRecorder* recorder, 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();

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onNumberFormatChanged(NumberFormat numberFormat);

			




	
	
	
		
 
    void onNumOfChannelsChanged(unsigned value);

			




	
	
	
		
 
    void onDataReady();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // BINARYSTREAMREADER_H

			




        

    


    
    

    

        

                

                    src/channelinfomodel.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 "channelinfomodel.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
#define NUMOF_COLORS  (32)

			




	
	
	
		
 

			




	
	
	
		
 
const QColor colors[NUMOF_COLORS] =

			




	
	
	
		
 
{

			




	
	
	
		
 
    QColor("#ff0056"),

			




	
	
	
		
 
    QColor("#7e2dd2"),

			




	
	
	
		
 
    QColor("#00ae7e"),

			




	
	
	
		
 
    QColor("#fe8900"),

			




	
	
	
		
 
    QColor("#ff937e"),

			




	
	
	
		
 
    QColor("#6a826c"),

			




	
	
	
		
 
    QColor("#ff029d"),

			




	
	
	
		
 
    QColor("#00b917"),

			




	
	
	
		
 
    QColor("#7a4782"),

			




	
	
	
		
 
    QColor("#85a900"),

			




	
	
	
		
 
    QColor("#a42400"),

			




	
	
	
		
 
    QColor("#683d3b"),

			




	
	
	
		
 
    QColor("#bdc6ff"),

			




	
	
	
		
 
    QColor("#263400"),

			




	
	
	
		
 
    QColor("#bdd393"),

			




	
	
	
		
 
    QColor("#d5ff00"),

			




	
	
	
		
 
    QColor("#9e008e"),

			




	
	
	
		
 
    QColor("#001544"),

			




	
	
	
		
 
    QColor("#c28c9f"),

			




	
	
	
		
 
    QColor("#ff74a3"),

			




	
	
	
		
 
    QColor("#01d0ff"),

			




	
	
	
		
 
    QColor("#004754"),

			




	
	
	
		
 
    QColor("#e56ffe"),

			




	
	
	
		
 
    QColor("#788231"),

			




	
	
	
		
 
    QColor("#0e4ca1"),

			




	
	
	
		
 
    QColor("#91d0cb"),

			




	
	
	
		
 
    QColor("#be9970"),

			




	
	
	
		
 
    QColor("#968ae8"),

			




	
	
	
		
 
    QColor("#bb8800"),

			




	
	
	
		
 
    QColor("#43002c"),

			




	
	
	
		
 
    QColor("#deff74"),

			




	
	
	
		
 
    QColor("#00ffc6")

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel::ChannelInfoModel(unsigned numberOfChannels, QObject* parent) :

			




	
	
	
		
 
    QAbstractTableModel(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfChannels = 0;

			




	
	
	
		
 
    setNumOfChannels(numberOfChannels);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel::ChannelInfoModel(const ChannelInfoModel& other) :

			




	
	
	
		
 
    ChannelInfoModel(other.rowCount(), other.parent())

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (int i = 0; i < other.rowCount(); i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setData(index(i, COLUMN_NAME),

			




	
	
	
		
 
                other.data(other.index(i, COLUMN_NAME), Qt::EditRole),

			




	
	
	
		
 
                Qt::EditRole);

			




	
	
	
		
 
        setData(index(i, COLUMN_NAME),

			




	
	
	
		
 
                other.data(other.index(i, COLUMN_NAME), Qt::ForegroundRole),

			




	
	
	
		
 
                Qt::ForegroundRole);

			




	
	
	
		
 
        setData(index(i, COLUMN_VISIBILITY),

			




	
	
	
		
 
                other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),

			




	
	
	
		
 
                Qt::CheckStateRole);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :

			




	
	
	
		
 
    ChannelInfoModel(channelNames.length(), NULL)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (int i = 0; i < channelNames.length(); i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)

			




	
	
	
		
 
{

			




	
	
	
		
 
    name = tr("Channel %1").arg(index + 1);

			




	
	
	
		
 
    visibility = true;

			




	
	
	
		
 
    color = colors[index % NUMOF_COLORS];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QString ChannelInfoModel::name(unsigned i)

			




	
	
	
		
 
QString ChannelInfoModel::name(unsigned i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return infos[i].name;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QColor ChannelInfoModel::color(unsigned i)

			




	
	
	
		
 
QColor ChannelInfoModel::color(unsigned i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return infos[i].color;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool ChannelInfoModel::isVisible(unsigned i)

			




	
	
	
		
 
bool ChannelInfoModel::isVisible(unsigned i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return infos[i].visibility;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QStringList ChannelInfoModel::channelNames() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QStringList r;

			




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

			




	
	
	
		
 
    {

			




	
	
	
		
 
        r << name(ci);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return r;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int ChannelInfoModel::rowCount(const QModelIndex &parent) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numOfChannels;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int ChannelInfoModel::columnCount(const QModelIndex & parent) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return COLUMN_COUNT;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (index.column() == COLUMN_NAME)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (index.column() == COLUMN_VISIBILITY)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return Qt::NoItemFlags;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QVariant ChannelInfoModel::data(const QModelIndex &index, int role) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    // check index

			




	
	
	
		
 
    if (index.row() >= (int) _numOfChannels || index.row() < 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QVariant();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // get color

			




	
	
	
		
 
    if (role == Qt::ForegroundRole)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return infos[index.row()].color;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // get name

			




	
	
	
		
 
    if (index.column() == COLUMN_NAME)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (role == Qt::DisplayRole || role == Qt::EditRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            return QVariant(infos[index.row()].name);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    } // get visibility

			




	
	
	
		
 
    else if (index.column() == COLUMN_VISIBILITY)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (role == Qt::CheckStateRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            bool visible = infos[index.row()].visibility;

			




	
	
	
		
 
            return visible ? Qt::Checked : Qt::Unchecked;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return QVariant();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (orientation == Qt::Horizontal)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (role == Qt::DisplayRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            if (section == COLUMN_NAME)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                return tr("Channel");

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if (section == COLUMN_VISIBILITY)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                return tr("Visible");

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else                        // vertical

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (section < (int) _numOfChannels && role == Qt::DisplayRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            return QString::number(section + 1);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return QVariant();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // check index

			




	
	
	
		
 
    if (index.row() >= (int) _numOfChannels || index.row() < 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return false;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // set color

			




	
	
	
		
 
    if (role == Qt::ForegroundRole)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        infos[index.row()].color = value.value<QColor>();

			




	
	
	
		
 
        emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));

			




	
	
	
		
 
        return true;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // set name

			




	
	
	
		
 
    if (index.column() == COLUMN_NAME)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (role == Qt::DisplayRole || role == Qt::EditRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            infos[index.row()].name = value.toString();

			




	
	
	
		
 
            emit dataChanged(index, index, QVector<int>({role}));

			




	
	
	
		
 
            return true;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    } // set visibility

			




	
	
	
		
 
    else if (index.column() == COLUMN_VISIBILITY)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (role == Qt::CheckStateRole)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            bool checked = value.toInt() == Qt::Checked;

			




	
	
	
		
 
            infos[index.row()].visibility = checked;

			




	
	
	
		
 
            emit dataChanged(index, index, QVector<int>({role}));

			




	
	
	
		
 
            return true;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // invalid index/role

			




	
	
	
		
 
    return false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::setNumOfChannels(unsigned number)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (number == _numOfChannels) return;

			




	
	
	
		
 

			




	
	
	
		
 
    bool isInserting = number > _numOfChannels;

			




	
	
	
		
 
    if (isInserting)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        beginInsertRows(QModelIndex(), _numOfChannels, number-1);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        beginRemoveRows(QModelIndex(), number, _numOfChannels-1);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // we create channel info but never remove channel info to

			




	
	
	
		
 
    // remember user entered info

			




	
	
	
		
 
    if ((int) number > infos.length())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned ci = _numOfChannels; ci < number; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            infos.append(ChannelInfo(ci));

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // make sure newly available channels are visible, we don't

			




	
	
	
		
 
    // remember visibility option intentionally so that user doesn't

			




	
	
	
		
 
    // get confused

			




	
	
	
		
 
    if (number > _numOfChannels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned ci = _numOfChannels; ci < number; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            infos[ci].visibility = true;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    _numOfChannels = number;

			




	
	
	
		
 

			




	
	
	
		
 
    if (isInserting)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        endInsertRows();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        endRemoveRows();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::resetInfos()

			




	
	
	
		
 
{

			




	
	
	
		
 
    beginResetModel();

			




	
	
	
		
 
    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        infos[ci] = ChannelInfo(ci);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    endResetModel();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::resetNames()

			




	
	
	
		
 
{

			




	
	
	
		
 
    beginResetModel();

			




	
	
	
		
 
    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        infos[ci].name = ChannelInfo(ci).name;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    endResetModel();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::resetColors()

			




	
	
	
		
 
{

			




	
	
	
		
 
    beginResetModel();

			




	
	
	
		
 
    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        infos[ci].color = ChannelInfo(ci).color;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    endResetModel();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::resetVisibility()

			




	
	
	
		
 
{

			




	
	
	
		
 
    beginResetModel();

			




	
	
	
		
 
    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        infos[ci].visibility = true;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    endResetModel();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Channels);

			




	
	
	
		
 
    settings->beginWriteArray(SG_Channels_Channel);

			




	
	
	
		
 

			




	
	
	
		
 
    // save all channel information regardless of current number of channels

			




	
	
	
		
 
    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settings->setArrayIndex(ci);

			




	
	
	
		
 
        settings->setValue(SG_Channels_Name, infos[ci].name);

			




	
	
	
		
 
        settings->setValue(SG_Channels_Color, infos[ci].color);

			




	
	
	
		
 
        settings->setValue(SG_Channels_Visible, infos[ci].visibility);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endArray();

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelInfoModel::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Channels);

			




	
	
	
		
 
    unsigned size = settings->beginReadArray(SG_Channels_Channel);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < size; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settings->setArrayIndex(ci);

			




	
	
	
		
 

			




	
	
	
		
 
        ChannelInfo chanInfo(ci);

			




	
	
	
		
 
        chanInfo.name       = settings->value(SG_Channels_Name, chanInfo.name).toString();

			




	
	
	
		
 
        chanInfo.color      = settings->value(SG_Channels_Color, chanInfo.color).value<QColor>();

			




	
	
	
		
 
        chanInfo.visibility = settings->value(SG_Channels_Visible, true).toBool();

			




	
	
	
		
 

			




	
	
	
		
 
        if ((int) ci < infos.size())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            infos[ci] = chanInfo;

			




	
	
	
		
 

			




	
	
	
		
 
            if (ci < _numOfChannels)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                auto roles = QVector<int>({

			




	
	
	
		
 
                    Qt::DisplayRole, Qt::EditRole, Qt::ForegroundRole, Qt::CheckStateRole});

			




	
	
	
		
 
                emit dataChanged(index(ci, 0), index(ci, COLUMN_COUNT-1), roles);

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            infos.append(chanInfo);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endArray();

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/channelinfomodel.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 CHANNELINFOMODEL_H

			




	
	
	
		
 
#define CHANNELINFOMODEL_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QAbstractTableModel>

			




	
	
	
		
 
#include <QColor>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 
#include <QStringList>

			




	
	
	
		
 

			




	
	
	
		
 
class ChannelInfoModel : public QAbstractTableModel

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    enum ChannelInfoColumn

			




	
	
	
		
 
    {

			




	
	
	
		
 
        COLUMN_NAME = 0,

			




	
	
	
		
 
        COLUMN_VISIBILITY,

			




	
	
	
		
 
        COLUMN_COUNT

			




	
	
	
		
 
    };

			




	
	
	
		
 

			




	
	
	
		
 
    explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);

			




	
	
	
		
 
    ChannelInfoModel(const ChannelInfoModel& other);

			




	
	
	
		
 
    explicit ChannelInfoModel(const QStringList& channelNames);

			




	
	
	
		
 

			




	
	
	
		
 
    QString name     (unsigned i);

			




	
	
	
		
 
    QColor  color    (unsigned i);

			




	
	
	
		
 
    bool    isVisible(unsigned i);

			




	
	
	
		
 
    QString name     (unsigned i) const;

			




	
	
	
		
 
    QColor  color    (unsigned i) const;

			




	
	
	
		
 
    bool    isVisible(unsigned i) const;

			




	
	
	
		
 
    /// Returns a list of channel names

			




	
	
	
		
 
    QStringList channelNames() const;

			




	
	
	
		
 

			




	
	
	
		
 
    // implemented from QAbstractItemModel

			




	
	
	
		
 
    int           rowCount(const QModelIndex &parent = QModelIndex()) const;

			




	
	
	
		
 
    int           columnCount(const QModelIndex &parent = QModelIndex()) const;

			




	
	
	
		
 
    QVariant      data(const QModelIndex &index, int role = Qt::DisplayRole) const;

			




	
	
	
		
 
    bool          setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);

			




	
	
	
		
 
    Qt::ItemFlags flags(const QModelIndex &index) const;

			




	
	
	
		
 
    QVariant      headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;

			




	
	
	
		
 

			




	
	
	
		
 
    void setNumOfChannels(unsigned number);

			




	
	
	
		
 
    /// Stores all channel info into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads all channel info from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    /// reset all channel info (names, color etc.)

			




	
	
	
		
 
    void resetInfos();

			




	
	
	
		
 
    /// reset all channel names

			




	
	
	
		
 
    void resetNames();

			




	
	
	
		
 
    /// reset all channel colors

			




	
	
	
		
 
    void resetColors();

			




	
	
	
		
 
    /// reset visibility

			




	
	
	
		
 
    void resetVisibility();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    struct ChannelInfo

			




	
	
	
		
 
    {

			




	
	
	
		
 
        explicit ChannelInfo(unsigned index);

			




	
	
	
		
 

			




	
	
	
		
 
        QString name;

			




	
	
	
		
 
        bool visibility;

			




	
	
	
		
 
        QColor color;

			




	
	
	
		
 
    };

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned _numOfChannels;     ///< @note this is not necessarily the length of `infos`

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Channel info is added here but never removed so that we can

			




	
	
	
		
 
     * remember user entered info (names, colors etc.).

			




	
	
	
		
 
     */

			




	
	
	
		
 
    QList<ChannelInfo> infos;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // CHANNELINFOMODEL_H

			




        

    


    
    

    

        

                

                    src/channelmanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <QModelIndex>

			




	
	
	
		
 

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "channelmanager.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
ChannelManager::ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent) :

			




	
	
	
		
 
    QObject(parent),

			




	
	
	
		
 
    _infoModel(numberOfChannels)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfChannels = numberOfChannels;

			




	
	
	
		
 
    _numOfSamples = numberOfSamples;

			




	
	
	
		
 
    _paused = false;

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned int i = 0; i < numberOfChannels; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelBuffers.append(new FrameBuffer(numberOfSamples));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_infoModel, &ChannelInfoModel::dataChanged,

			




	
	
	
		
 
            this, &ChannelManager::onChannelInfoChanged);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelManager::~ChannelManager()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto buffer : channelBuffers)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete buffer;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned ChannelManager::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return channelBuffers.size();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned ChannelManager::numOfSamples()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numOfSamples;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::setNumOfChannels(unsigned number)

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned int oldNum = channelBuffers.size();

			




	
	
	
		
 

			




	
	
	
		
 
    if (number > oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add new channels

			




	
	
	
		
 
        for (unsigned int i = 0; i < number - oldNum; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            channelBuffers.append(new FrameBuffer(_numOfSamples));

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if(number < oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // remove channels

			




	
	
	
		
 
        for (unsigned int i = oldNum-1; i > number-1; i--)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            delete channelBuffers.takeLast();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    _numOfChannels = number;

			




	
	
	
		
 
    _infoModel.setNumOfChannels(number);

			




	
	
	
		
 

			




	
	
	
		
 
    emit numOfChannelsChanged(number);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::setNumOfSamples(unsigned number)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfSamples = number;

			




	
	
	
		
 

			




	
	
	
		
 
    for (int ci = 0; ci < channelBuffers.size(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelBuffers[ci]->resize(_numOfSamples);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    emit numOfSamplesChanged(number);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::pause(bool paused)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _paused = paused;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
FrameBuffer* ChannelManager::channelBuffer(unsigned channel)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return channelBuffers[channel];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel* ChannelManager::infoModel()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_infoModel;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QString ChannelManager::channelName(unsigned channel)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _infoModel.data(_infoModel.index(channel, ChannelInfoModel::COLUMN_NAME),

			




	
	
	
		
 
                           Qt::DisplayRole).toString();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QStringList ChannelManager::channelNames()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QStringList list;

			




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

			




	
	
	
		
 
    {

			




	
	
	
		
 
        list << channelName(ci);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return list;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::onChannelInfoChanged(const QModelIndex & topLeft,

			




	
	
	
		
 
                                          const QModelIndex & bottomRight,

			




	
	
	
		
 
                                          const QVector<int> & roles)

			




	
	
	
		
 
{

			




	
	
	
		
 
    int start = topLeft.row();

			




	
	
	
		
 
    int end = bottomRight.row();

			




	
	
	
		
 
    int col = topLeft.column();

			




	
	
	
		
 

			




	
	
	
		
 
    for (int ci = start; ci <= end; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (auto role : roles)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            switch (role)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                case Qt::EditRole:

			




	
	
	
		
 
                    if (col == ChannelInfoModel::COLUMN_NAME)

			




	
	
	
		
 
                    {

			




	
	
	
		
 
                        emit channelNameChanged(ci, channelName(ci));

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    break;

			




	
	
	
		
 
                case Qt::ForegroundRole:

			




	
	
	
		
 
                    if (col == ChannelInfoModel::COLUMN_NAME)

			




	
	
	
		
 
                    {

			




	
	
	
		
 
                        // TODO: emit channel color changed

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    break;

			




	
	
	
		
 
                case Qt::CheckStateRole:

			




	
	
	
		
 
                    if (col == ChannelInfoModel::COLUMN_VISIBILITY)

			




	
	
	
		
 
                    {

			




	
	
	
		
 
                        // TODO: emit visibility

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                    break;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
        // emit channelNameChanged(i, channelName(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::addData(double* data, unsigned size)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(size % _numOfChannels == 0);

			




	
	
	
		
 

			




	
	
	
		
 
    if (_paused) return;

			




	
	
	
		
 

			




	
	
	
		
 
    int n = size / _numOfChannels;

			




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

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelBuffers[ci]->addSamples(&data[ci*n], n);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    emit dataAdded();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void ChannelManager::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/channelmanager.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 CHANNELMANAGER_H

			




	
	
	
		
 
#define CHANNELMANAGER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QStringList>

			




	
	
	
		
 
#include <QModelIndex>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 
#include "channelinfomodel.h"

			




	
	
	
		
 

			




	
	
	
		
 
class ChannelManager : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);

			




	
	
	
		
 
    ~ChannelManager();

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numOfChannels();

			




	
	
	
		
 
    unsigned numOfSamples();

			




	
	
	
		
 
    FrameBuffer* channelBuffer(unsigned channel);

			




	
	
	
		
 
    // QStringListModel* channelNames();

			




	
	
	
		
 
    QString channelName(unsigned channel);

			




	
	
	
		
 
    /// Stores channel names into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads channel names from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 
    /// Returns a model that manages channel information (name, color etc)

			




	
	
	
		
 
    ChannelInfoModel* infoModel();

			




	
	
	
		
 
    /// Returns a list of channel names

			




	
	
	
		
 
    QStringList channelNames();

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numOfChannelsChanged(unsigned value);

			




	
	
	
		
 
    void numOfSamplesChanged(unsigned value);

			




	
	
	
		
 
    void channelNameChanged(unsigned channel, QString name);

			




	
	
	
		
 
    void dataAdded(); ///< emitted when data added to channel man.

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    void setNumOfChannels(unsigned number);

			




	
	
	
		
 
    void setNumOfSamples(unsigned number);

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Add data for all channels.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * All channels data is provided in a single array which contains equal

			




	
	
	
		
 
     * number of samples for all channels. Structure is as shown below:

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param data samples for all channels

			




	
	
	
		
 
     * @param size size of `data`, must be multiple of `numOfChannels`

			




	
	
	
		
 
     */

			




	
	
	
		
 
    void addData(double* data, unsigned size);

			




	
	
	
		
 

			




	
	
	
		
 
    /// When paused `addData` does nothing.

			




	
	
	
		
 
    void pause(bool paused);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned _numOfChannels;

			




	
	
	
		
 
    unsigned _numOfSamples;

			




	
	
	
		
 
    bool _paused;

			




	
	
	
		
 
    QList<FrameBuffer*> channelBuffers;

			




	
	
	
		
 
    // QStringListModel _channelNames;

			




	
	
	
		
 
    ChannelInfoModel _infoModel;

			




	
	
	
		
 

			




	
	
	
		
 
    void addChannelName(QString name); ///< appends a new channel name at the end of list

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onChannelInfoChanged(const QModelIndex & topLeft,

			




	
	
	
		
 
                              const QModelIndex & bottomRight,

			




	
	
	
		
 
                              const QVector<int> & roles = QVector<int> ());

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // CHANNELMANAGER_H

			




        

    


    
    

    

        

                

                    src/dataformatpanel.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 "dataformatpanel.h"

			




	
	
	
		
 
#include "ui_dataformatpanel.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include <QRadioButton>

			




	
	
	
		
 
#include <QtEndian>

			




	
	
	
		
 
#include <QMap>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 
#include "floatswap.h"

			




	
	
	
		
 

			




	
	
	
		
 
DataFormatPanel::DataFormatPanel(QSerialPort* port,

			




	
	
	
		
 
                                 ChannelManager* channelMan,

			




	
	
	
		
 
                                 DataRecorder* recorder,

			




	
	
	
		
 
                                 QWidget *parent) :

			




	
	
	
		
 
    QWidget(parent),

			




	
	
	
		
 
    ui(new Ui::DataFormatPanel),

			




	
	
	
		
 
    bsReader(port, channelMan, this),

			




	
	
	
		
 
    asciiReader(port, channelMan, this),

			




	
	
	
		
 
    framedReader(port, channelMan, this),

			




	
	
	
		
 
    demoReader(port, channelMan, this)

			




	
	
	
		
 
    bsReader(port, channelMan, recorder, this),

			




	
	
	
		
 
    asciiReader(port, channelMan, recorder, this),

			




	
	
	
		
 
    framedReader(port, channelMan, recorder, this),

			




	
	
	
		
 
    demoReader(port, channelMan, recorder, this)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    serialPort = port;

			




	
	
	
		
 
    _channelMan = channelMan;

			




	
	
	
		
 
    paused = false;

			




	
	
	
		
 
    demoEnabled = false;

			




	
	
	
		
 

			




	
	
	
		
 
    // initalize default reader

			




	
	
	
		
 
    currentReader = &bsReader;

			




	
	
	
		
 
    bsReader.enable();

			




	
	
	
		
 
    ui->rbBinary->setChecked(true);

			




	
	
	
		
 
    ui->horizontalLayout->addWidget(bsReader.settingsWidget(), 1);

			




	
	
	
		
 
    connect(&bsReader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

			




	
	
	
		
 
    connect(&bsReader, SIGNAL(numOfChannelsChanged(unsigned)),

			




	
	
	
		
 
            this, SIGNAL(numOfChannelsChanged(unsigned)));

			




	
	
	
		
 
    connect(&bsReader, SIGNAL(samplesPerSecondChanged(unsigned)),

			




	
	
	
		
 
            this, SIGNAL(samplesPerSecondChanged(unsigned)));

			




	
	
	
		
 

			




	
	
	
		
 
    // initalize reader selection buttons

			




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

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (checked) selectReader(&bsReader);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




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

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (checked) selectReader(&asciiReader);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




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

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (checked) selectReader(&framedReader);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    // re-purpose numofchannels settings from actual reader settings to demo reader

			




	
	
	
		
 
    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);

			




	
	
	
		
 
        demoReader.recording = currentReader->recording;

			




	
	
	
		
 
        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

			




	
	
	
		
 
                this, &DataFormatPanel::samplesPerSecondChanged);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        demoReader.enable(false);

			




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

			




	
	
	
		
 
    }

			




	
	
	
		
 
    demoEnabled = enabled;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::startRecording()

			




	
	
	
		
 
{

			




	
	
	
		
 
    currentReader->recording = true;

			




	
	
	
		
 
    if (demoEnabled) demoReader.recording = true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataFormatPanel::stopRecording()

			




	
	
	
		
 
{

			




	
	
	
		
 
    currentReader->recording = false;

			




	
	
	
		
 
    if (demoEnabled) demoReader.recording = false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
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);

			




	
	
	
		
 
    reader->recording = currentReader->recording;

			




	
	
	
		
 

			




	
	
	
		
 
    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);

			




	
	
	
		
 
    asciiReader.saveSettings(settings);

			




	
	
	
		
 
    framedReader.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);

			




	
	
	
		
 
    asciiReader.loadSettings(settings);

			




	
	
	
		
 
    framedReader.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/dataformatpanel.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 DATAFORMATPANEL_H

			




	
	
	
		
 
#define DATAFORMATPANEL_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QButtonGroup>

			




	
	
	
		
 
#include <QTimer>

			




	
	
	
		
 
#include <QSerialPort>

			




	
	
	
		
 
#include <QList>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 
#include <QtGlobal>

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 
#include "channelmanager.h"

			




	
	
	
		
 
#include "binarystreamreader.h"

			




	
	
	
		
 
#include "asciireader.h"

			




	
	
	
		
 
#include "demoreader.h"

			




	
	
	
		
 
#include "framedreader.h"

			




	
	
	
		
 
#include "datarecorder.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class DataFormatPanel;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
class DataFormatPanel : public QWidget

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit DataFormatPanel(QSerialPort* port,

			




	
	
	
		
 
                             ChannelManager* channelMan,

			




	
	
	
		
 
                             QWidget *parent = 0);

			




	
	
	
		
 
                             DataRecorder* recorder,

			




	
	
	
		
 
                             QWidget* parent = 0);

			




	
	
	
		
 
    ~DataFormatPanel();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Returns currently selected number of channels

			




	
	
	
		
 
    unsigned numOfChannels();

			




	
	
	
		
 
    /// Stores data format panel settings into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads data format panel settings from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    void pause(bool);

			




	
	
	
		
 
    void enableDemo(bool); // demo shouldn't be enabled when port is open

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Starts sending data to recorder.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @note recorder must have been started!

			




	
	
	
		
 
     */

			




	
	
	
		
 
    void startRecording();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Stops recording.

			




	
	
	
		
 
    void stopRecording();

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numOfChannelsChanged(unsigned);

			




	
	
	
		
 
    void samplesPerSecondChanged(unsigned);

			




	
	
	
		
 
    void dataAdded();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::DataFormatPanel *ui;

			




	
	
	
		
 

			




	
	
	
		
 
    QSerialPort* serialPort;

			




	
	
	
		
 
    ChannelManager* _channelMan;

			




	
	
	
		
 

			




	
	
	
		
 
    BinaryStreamReader bsReader;

			




	
	
	
		
 
    AsciiReader asciiReader;

			




	
	
	
		
 
    FramedReader framedReader;

			




	
	
	
		
 
    /// Currently selected reader

			




	
	
	
		
 
    AbstractReader* currentReader;

			




	
	
	
		
 
    /// Disable current reader and enable a another one

			




	
	
	
		
 
    void selectReader(AbstractReader* reader);

			




	
	
	
		
 

			




	
	
	
		
 
    bool paused;

			




	
	
	
		
 

			




	
	
	
		
 
    bool demoEnabled;

			




	
	
	
		
 
    DemoReader demoReader;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // DATAFORMATPANEL_H

			




        

    


    
    

    

        

                

                    src/datarecorder.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 "datarecorder.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
DataRecorder::DataRecorder(QObject *parent) :

			




	
	
	
		
 
    QObject(parent),

			




	
	
	
		
 
    fileStream(&file)

			




	
	
	
		
 
{

			




	
	
	
		
 
    lastNumChannels = 0;

			




	
	
	
		
 
    disableBuffering = false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool DataRecorder::startRecording(QString fileName, QString separator, QStringList channelNames)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(!file.isOpen());

			




	
	
	
		
 
    _sep =  separator;

			




	
	
	
		
 

			




	
	
	
		
 
    // open file

			




	
	
	
		
 
    file.setFileName(fileName);

			




	
	
	
		
 
    if (!file.open(QIODevice::WriteOnly))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        qCritical() << "Opening file " << fileName

			




	
	
	
		
 
                    << " for recording failed with error: " << file.error();

			




	
	
	
		
 
        return false;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // write header line

			




	
	
	
		
 
    if (!channelNames.isEmpty())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        fileStream << channelNames.join(_sep);

			




	
	
	
		
 
        fileStream << "\n";

			




	
	
	
		
 
        lastNumChannels = channelNames.length();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataRecorder::addData(double* data, unsigned length, unsigned numOfChannels)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(length > 0);

			




	
	
	
		
 
    Q_ASSERT(length % numOfChannels == 0);

			




	
	
	
		
 

			




	
	
	
		
 
    if (lastNumChannels != 0 && numOfChannels != lastNumChannels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        qWarning() << "Number of channels changed from " << lastNumChannels

			




	
	
	
		
 
                   << " to " << numOfChannels <<

			




	
	
	
		
 
            " during recording, CSV file is corrupted but no data will be lost.";

			




	
	
	
		
 
    }

			




	
	
	
		
 
    lastNumChannels = numOfChannels;

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numOfSamples = length / numOfChannels; // per channel

			




	
	
	
		
 
    for (unsigned int i = 0; i < numOfSamples; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned ci = 0; ci < numOfChannels; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            fileStream << data[ci * numOfSamples + i];

			




	
	
	
		
 
            if (ci != numOfChannels-1) fileStream << _sep;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        fileStream << '\n';

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (disableBuffering) fileStream.flush();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DataRecorder::stopRecording()

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(file.isOpen());

			




	
	
	
		
 

			




	
	
	
		
 
    file.close();

			




	
	
	
		
 
    lastNumChannels = 0;

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/datarecorder.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 DATARECORDER_H

			




	
	
	
		
 
#define DATARECORDER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QFile>

			




	
	
	
		
 
#include <QTextStream>

			




	
	
	
		
 

			




	
	
	
		
 
class DataRecorder : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit DataRecorder(QObject *parent = 0);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Disables file buffering

			




	
	
	
		
 
    bool disableBuffering;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Starts recording data to a file in CSV format.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * File is opened and header line (names of channels) is written.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param fileName name of the recording file

			




	
	
	
		
 
     * @param separator column separator

			




	
	
	
		
 
     * @param channelNames names of the channels for header line, if empty no header line is written

			




	
	
	
		
 
     * @return false if file operation fails (read only etc.)

			




	
	
	
		
 
     */

			




	
	
	
		
 
    bool startRecording(QString fileName, QString separator, QStringList channelNames);

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Adds data to a channel.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * Multiple rows of data can be added at a time. Each channels

			




	
	
	
		
 
     * data should be ordered consecutively in the `data` array:

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * If `numOfChannels` changes during recording, no data will be

			




	
	
	
		
 
     * lost (ie. it will be written to the file) but this will produce

			




	
	
	
		
 
     * an invalid CSV file. An error message will be written to the

			




	
	
	
		
 
     * console.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param data samples array

			




	
	
	
		
 
     * @param length number of samples in `data`, must be multiple of `numOfChannels`

			




	
	
	
		
 
     * @param numOfChannels how many channels samples this data carries

			




	
	
	
		
 
     */

			




	
	
	
		
 
    void addData(double* data, unsigned length, unsigned numOfChannels);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Stops recording, closes file.

			




	
	
	
		
 
    void stopRecording();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned lastNumChannels;   ///< used for error message only

			




	
	
	
		
 
    QFile file;

			




	
	
	
		
 
    QTextStream fileStream;

			




	
	
	
		
 
    QString _sep;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // DATARECORDER_H

			




        

    


    
    

    

        

                

                    src/demoreader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <math.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "demoreader.h"

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef M_PI

			




	
	
	
		
 
#define M_PI 3.14159265358979323846

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, parent)

			




	
	
	
		
 
DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                       DataRecorder* recorder, QObject* parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, recorder, parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = false;

			




	
	
	
		
 
    _numOfChannels = 1;

			




	
	
	
		
 
    count = 0;

			




	
	
	
		
 
    timer.setInterval(100);

			




	
	
	
		
 
    QObject::connect(&timer, &QTimer::timeout,

			




	
	
	
		
 
                     this, &DemoReader::demoTimerTimeout);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QWidget* DemoReader::settingsWidget()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return NULL;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DemoReader::enable(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        timer.start();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        timer.stop();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned DemoReader::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numOfChannels;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DemoReader::setNumOfChannels(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfChannels = value;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DemoReader::pause(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = enabled;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void DemoReader::demoTimerTimeout()

			




	
	
	
		
 
{

			




	
	
	
		
 
    const double period = 100;

			




	
	
	
		
 
    count++;

			




	
	
	
		
 
    if (count >= 100) count = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    if (!paused)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        double* samples = new double[_numOfChannels];

			




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

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // we are calculating the fourier components of square wave

			




	
	
	
		
 
            samples[ci] = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);

			




	
	
	
		
 
            sampleCount++;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        _channelMan->addData(samples, _numOfChannels);

			




	
	
	
		
 
        addData(samples, _numOfChannels);

			




	
	
	
		
 
        delete[] samples;

			




	
	
	
		
 
        emit dataAdded();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/demoreader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 DEMOREADER_H

			




	
	
	
		
 
#define DEMOREADER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QTimer>

			




	
	
	
		
 

			




	
	
	
		
 
#include "abstractreader.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * This is a special case of reader implementation and should be used

			




	
	
	
		
 
 * with care.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * There is no settings widget. Number of channels should be set from

			




	
	
	
		
 
 * currently selected actual readers settings widget.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * This reader should not be enabled when port is open!

			




	
	
	
		
 
 */

			




	
	
	
		
 
class DemoReader : public AbstractReader

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




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

			




	
	
	
		
 
    explicit DemoReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                        DataRecorder* recorder, QObject* parent = 0);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Demo reader is an exception so this function returns NULL

			




	
	
	
		
 
    QWidget* settingsWidget();

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numOfChannels();

			




	
	
	
		
 

			




	
	
	
		
 
    void enable(bool enabled = true);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    void pause(bool);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Sets the number of channels, this doesn't trigger a `numOfChannelsChanged` signal.

			




	
	
	
		
 
    void setNumOfChannels(unsigned value);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    bool paused;

			




	
	
	
		
 
    unsigned _numOfChannels;

			




	
	
	
		
 
    QTimer timer;

			




	
	
	
		
 
    int count;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void demoTimerTimeout();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // DEMOREADER_H

			




        

    


    
    

    

        

                

                    src/framedreader.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <QtDebug>

			




	
	
	
		
 
#include <QtEndian>

			




	
	
	
		
 
#include "floatswap.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "framedreader.h"

			




	
	
	
		
 

			




	
	
	
		
 
FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, parent)

			




	
	
	
		
 
FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                           DataRecorder* recorder, QObject* parent) :

			




	
	
	
		
 
    AbstractReader(device, channelMan, recorder, parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = false;

			




	
	
	
		
 

			




	
	
	
		
 
    // initial settings

			




	
	
	
		
 
    settingsInvalid = 0;

			




	
	
	
		
 
    _numOfChannels = _settingsWidget.numOfChannels();

			




	
	
	
		
 
    hasSizeByte = _settingsWidget.frameSize() == 0;

			




	
	
	
		
 
    frameSize = _settingsWidget.frameSize();

			




	
	
	
		
 
    syncWord = _settingsWidget.syncWord();

			




	
	
	
		
 
    checksumEnabled = _settingsWidget.isChecksumEnabled();

			




	
	
	
		
 
    onNumberFormatChanged(_settingsWidget.numberFormat());

			




	
	
	
		
 
    debugModeEnabled = _settingsWidget.isDebugModeEnabled();

			




	
	
	
		
 
    checkSettings();

			




	
	
	
		
 

			




	
	
	
		
 
    // init setting connections

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::numberFormatChanged,

			




	
	
	
		
 
            this, &FramedReader::onNumberFormatChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::numOfChannelsChanged,

			




	
	
	
		
 
            this, &FramedReader::onNumOfChannelsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::syncWordChanged,

			




	
	
	
		
 
            this, &FramedReader::onSyncWordChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::frameSizeChanged,

			




	
	
	
		
 
            this, &FramedReader::onFrameSizeChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::checksumChanged,

			




	
	
	
		
 
            [this](bool enabled){checksumEnabled = enabled; reset();});

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_settingsWidget, &FramedReaderSettings::debugModeChanged,

			




	
	
	
		
 
            [this](bool enabled){debugModeEnabled = enabled;});

			




	
	
	
		
 

			




	
	
	
		
 
    // init reader state

			




	
	
	
		
 
    reset();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::enable(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        connect(_device, &QIODevice::readyRead,

			




	
	
	
		
 
                this, &FramedReader::onDataReady);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QObject::disconnect(_device, 0, this, 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QWidget* FramedReader::settingsWidget()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_settingsWidget;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned FramedReader::numOfChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numOfChannels;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::pause(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    paused = enabled;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)

			




	
	
	
		
 
{

			




	
	
	
		
 
    switch(numberFormat)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        case NumberFormat_uint8:

			




	
	
	
		
 
            sampleSize = 1;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<quint8>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int8:

			




	
	
	
		
 
            sampleSize = 1;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<qint8>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_uint16:

			




	
	
	
		
 
            sampleSize = 2;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<quint16>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int16:

			




	
	
	
		
 
            sampleSize = 2;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<qint16>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_uint32:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<quint32>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_int32:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<qint32>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_float:

			




	
	
	
		
 
            sampleSize = 4;

			




	
	
	
		
 
            readSample = &FramedReader::readSampleAs<float>;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case NumberFormat_INVALID:

			




	
	
	
		
 
            Q_ASSERT(1); // never

			




	
	
	
		
 
            break;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    checkSettings();

			




	
	
	
		
 
    reset();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::checkSettings()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // sync word is invalid (empty or missing a nibble at the end)

			




	
	
	
		
 
    if (!syncWord.size())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settingsInvalid |= SYNCWORD_INVALID;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else // sync word is valid

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settingsInvalid &= ~SYNCWORD_INVALID;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // check if fixed frame size is multiple of a sample set size

			




	
	
	
		
 
    if (!hasSizeByte && frameSize % (_numOfChannels * sampleSize) != 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settingsInvalid |= FRAMESIZE_INVALID;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        settingsInvalid &= ~FRAMESIZE_INVALID;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // show an error message

			




	
	
	
		
 
    if (settingsInvalid & SYNCWORD_INVALID)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _settingsWidget.showMessage("Sync word is invalid!", true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (settingsInvalid & FRAMESIZE_INVALID)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QString errorMessage =

			




	
	
	
		
 
            QString("Frame size must be multiple of %1 (#channels * sample size)!")\

			




	
	
	
		
 
            .arg(_numOfChannels * sampleSize);

			




	
	
	
		
 

			




	
	
	
		
 
        _settingsWidget.showMessage(errorMessage, true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _settingsWidget.showMessage("All is well!");

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::onNumOfChannelsChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfChannels = value;

			




	
	
	
		
 
    checkSettings();

			




	
	
	
		
 
    reset();

			




	
	
	
		
 
    emit numOfChannelsChanged(value);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::onSyncWordChanged(QByteArray word)

			




	
	
	
		
 
{

			




	
	
	
		
 
    syncWord = word;

			




	
	
	
		
 
    checkSettings();

			




	
	
	
		
 
    reset();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::onFrameSizeChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (value == 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        hasSizeByte = true;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        hasSizeByte = false;

			




	
	
	
		
 
        frameSize = value;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    checkSettings();

			




	
	
	
		
 
    reset();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::onDataReady()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (settingsInvalid) return;

			




	
	
	
		
 

			




	
	
	
		
 
    // loop until we run out of bytes or more bytes is required

			




	
	
	
		
 
    unsigned bytesAvailable;

			




	
	
	
		
 
    while ((bytesAvailable = _device->bytesAvailable()))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!gotSync) // read sync word

			




	
	
	
		
 
        {

			




	
	
	
		
 
            char c;

			




	
	
	
		
 
            _device->getChar(&c);

			




	
	
	
		
 
            if (c == syncWord[sync_i]) // correct sync byte?

			




	
	
	
		
 
            {

			




	
	
	
		
 
                sync_i++;

			




	
	
	
		
 
                if (sync_i == (unsigned) syncWord.length())

			




	
	
	
		
 
                {

			




	
	
	
		
 
                    gotSync = true;

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (debugModeEnabled) qCritical() << "Missed " << sync_i+1 << "th sync byte.";

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else if (hasSizeByte && !gotSize) // skipped if fixed frame size

			




	
	
	
		
 
        {

			




	
	
	
		
 
            frameSize = 0;

			




	
	
	
		
 
            _device->getChar((char*) &frameSize);

			




	
	
	
		
 

			




	
	
	
		
 
            if (frameSize == 0) // check size

			




	
	
	
		
 
            {

			




	
	
	
		
 
                qCritical() << "Frame size is 0!";

			




	
	
	
		
 
                reset();

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if (frameSize % (_numOfChannels * sampleSize) != 0)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                qCritical() <<

			




	
	
	
		
 
                    QString("Frame size is not multiple of %1 (#channels * sample size)!") \

			




	
	
	
		
 
                    .arg(_numOfChannels * sampleSize);

			




	
	
	
		
 
                reset();

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (debugModeEnabled) qDebug() << "Frame size:" << frameSize;

			




	
	
	
		
 
                gotSize = true;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else // read data bytes

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // have enough data bytes? (+1 for checksum)

			




	
	
	
		
 
            if (bytesAvailable < (checksumEnabled ? frameSize+1 : frameSize))

			




	
	
	
		
 
            {

			




	
	
	
		
 
                break;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else // read data bytes and checksum

			




	
	
	
		
 
            {

			




	
	
	
		
 
                readFrameDataAndCheck();

			




	
	
	
		
 
                reset();

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::reset()

			




	
	
	
		
 
{

			




	
	
	
		
 
    sync_i = 0;

			




	
	
	
		
 
    gotSync = false;

			




	
	
	
		
 
    gotSize = false;

			




	
	
	
		
 
    if (hasSizeByte) frameSize = 0;

			




	
	
	
		
 
    calcChecksum = 0;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Important: this function assumes device has enough bytes to read a full frames data and checksum

			




	
	
	
		
 
void FramedReader::readFrameDataAndCheck()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // if paused just read and waste data

			




	
	
	
		
 
    if (paused)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _device->read((checksumEnabled ? frameSize+1 : frameSize));

			




	
	
	
		
 
        return;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // a package is 1 set of samples for all channels

			




	
	
	
		
 
    unsigned numOfPackagesToRead = frameSize / (_numOfChannels * sampleSize);

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    {

			




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

			




	
	
	
		
 
        {

			




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

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // read checksum

			




	
	
	
		
 
    unsigned rChecksum = 0;

			




	
	
	
		
 
    bool checksumPassed = false;

			




	
	
	
		
 
    if (checksumEnabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _device->read((char*) &rChecksum, 1);

			




	
	
	
		
 
        calcChecksum &= 0xFF;

			




	
	
	
		
 
        checksumPassed = (calcChecksum == rChecksum);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (!checksumEnabled || checksumPassed)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // commit data

			




	
	
	
		
 
        _channelMan->addData(channelSamples, numOfPackagesToRead * _numOfChannels);

			




	
	
	
		
 
        emit dataAdded();

			




	
	
	
		
 
        addData(channelSamples, numOfPackagesToRead*_numOfChannels);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        qCritical() << "Checksum failed! Received:" << rChecksum << "Calculated:" << calcChecksum;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    delete[] channelSamples;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
{

			




	
	
	
		
 
    T data;

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    if (checksumEnabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < sizeof(data); i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            calcChecksum += ((unsigned char*) &data)[i];

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (_settingsWidget.endianness() == LittleEndian)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        data = qFromLittleEndian(data);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        data = qFromBigEndian(data);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return double(data);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FramedReader::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _settingsWidget.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/framedreader.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 FRAMEDREADER_H

			




	
	
	
		
 
#define FRAMEDREADER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "abstractreader.h"

			




	
	
	
		
 
#include "framedreadersettings.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * Reads data in a customizable framed format.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class FramedReader : public AbstractReader

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




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

			




	
	
	
		
 
    explicit FramedReader(QIODevice* device, ChannelManager* channelMan,

			




	
	
	
		
 
                          DataRecorder* recorder, 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:

			




	
	
	
		
 
    /// bit wise fields for `settingsValid` member

			




	
	
	
		
 
    enum SettingInvalidFlag

			




	
	
	
		
 
    {

			




	
	
	
		
 
        SYNCWORD_INVALID = 1,

			




	
	
	
		
 
        FRAMESIZE_INVALID = 2

			




	
	
	
		
 
    };

			




	
	
	
		
 

			




	
	
	
		
 
    // settings related members

			




	
	
	
		
 
    FramedReaderSettings _settingsWidget;

			




	
	
	
		
 
    unsigned _numOfChannels;

			




	
	
	
		
 
    unsigned sampleSize;

			




	
	
	
		
 
    bool paused;

			




	
	
	
		
 
    unsigned settingsInvalid;   /// settings are all valid if this is 0, if not no reading is done

			




	
	
	
		
 
    QByteArray syncWord;

			




	
	
	
		
 
    bool checksumEnabled;

			




	
	
	
		
 
    bool hasSizeByte;

			




	
	
	
		
 
    unsigned frameSize;

			




	
	
	
		
 
    bool debugModeEnabled;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Checks the validity of syncWord and frameSize then shows an

			




	
	
	
		
 
    /// error message. Also updates `settingsInvalid`. If settings are

			




	
	
	
		
 
    /// valid `settingsInvalid` should be `0`.

			




	
	
	
		
 
    void checkSettings();

			




	
	
	
		
 

			




	
	
	
		
 
    // read state related members

			




	
	
	
		
 
    unsigned sync_i; /// sync byte index to be read next

			




	
	
	
		
 
    bool gotSync;    /// indicates if sync word is captured

			




	
	
	
		
 
    bool gotSize;    /// indicates if size is captured, ignored if size byte is disabled (fixed size)

			




	
	
	
		
 
    unsigned calcChecksum;

			




	
	
	
		
 

			




	
	
	
		
 
    void reset();    /// Resets the reading state. Used in case of error or setting change.

			




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

			




	
	
	
		
 
    double (FramedReader::*readSample)();

			




	
	
	
		
 
    template<typename T> double readSampleAs();

			




	
	
	
		
 
    /// reads payload portion of the frame, calculates checksum and commits data

			




	
	
	
		
 
    /// @note should be called only if there are enough bytes on device

			




	
	
	
		
 
    void readFrameDataAndCheck();

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onDataReady();

			




	
	
	
		
 

			




	
	
	
		
 
    void onNumberFormatChanged(NumberFormat numberFormat);

			




	
	
	
		
 
    void onNumOfChannelsChanged(unsigned value);

			




	
	
	
		
 
    void onSyncWordChanged(QByteArray);

			




	
	
	
		
 
    void onFrameSizeChanged(unsigned);

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // FRAMEDREADER_H

			




        

    


    
    

    

        

                

                    src/mainwindow.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 "mainwindow.h"

			




	
	
	
		
 
#include "ui_mainwindow.h"

			




	
	
	
		
 
#include <QByteArray>

			




	
	
	
		
 
#include <QApplication>

			




	
	
	
		
 
#include <QFileDialog>

			




	
	
	
		
 
#include <QMessageBox>

			




	
	
	
		
 
#include <QFile>

			




	
	
	
		
 
#include <QTextStream>

			




	
	
	
		
 
#include <QMenu>

			




	
	
	
		
 
#include <QDesktopServices>

			




	
	
	
		
 
#include <QMap>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 
#include <qwt_plot.h>

			




	
	
	
		
 
#include <limits.h>

			




	
	
	
		
 
#include <cmath>

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 

			




	
	
	
		
 
#include <plot.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebufferseries.h"

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "defines.h"

			




	
	
	
		
 
#include "version.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(Q_OS_WIN) && defined(QT_STATIC)

			




	
	
	
		
 
#include <QtPlugin>

			




	
	
	
		
 
Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
const QMap<int, QString> panelSettingMap({

			




	
	
	
		
 
        {0, "Port"},

			




	
	
	
		
 
        {1, "DataFormat"},

			




	
	
	
		
 
        {2, "Plot"},

			




	
	
	
		
 
        {3, "Commands"}

			




	
	
	
		
 
    });

			




	
	
	
		
 

			




	
	
	
		
 
MainWindow::MainWindow(QWidget *parent) :

			




	
	
	
		
 
    QMainWindow(parent),

			




	
	
	
		
 
    ui(new Ui::MainWindow),

			




	
	
	
		
 
    aboutDialog(this),

			




	
	
	
		
 
    portControl(&serialPort),

			




	
	
	
		
 
    channelMan(1, 1, this),

			




	
	
	
		
 
    snapshotMan(this, &channelMan),

			




	
	
	
		
 
    commandPanel(&serialPort),

			




	
	
	
		
 
    dataFormatPanel(&serialPort, &channelMan)

			




	
	
	
		
 
    dataFormatPanel(&serialPort, &channelMan, &recorder),

			




	
	
	
		
 
    recordPanel(&recorder, &channelMan)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());

			




	
	
	
		
 

			




	
	
	
		
 
    ui->tabWidget->insertTab(0, &portControl, "Port");

			




	
	
	
		
 
    ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");

			




	
	
	
		
 
    ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");

			




	
	
	
		
 
    ui->tabWidget->insertTab(3, &commandPanel, "Commands");

			




	
	
	
		
 
    ui->tabWidget->insertTab(4, &recordPanel, "Record");

			




	
	
	
		
 
    ui->tabWidget->setCurrentIndex(0);

			




	
	
	
		
 
    auto tbPortControl = portControl.toolBar();

			




	
	
	
		
 
    addToolBar(tbPortControl);

			




	
	
	
		
 
    addToolBar(recordPanel.toolbar());

			




	
	
	
		
 

			




	
	
	
		
 
    ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());

			




	
	
	
		
 
    ui->menuBar->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());

			




	
	
	
		
 
    ui->menuBar->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&commandPanel, &CommandPanel::focusRequested, [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                this->ui->tabWidget->setCurrentWidget(&commandPanel);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    tbPortControl->setObjectName("tbPortControl");

			




	
	
	
		
 
    ui->plotToolBar->setObjectName("tbPlot");

			




	
	
	
		
 

			




	
	
	
		
 
    setupAboutDialog();

			




	
	
	
		
 

			




	
	
	
		
 
    // init view menu

			




	
	
	
		
 
    for (auto a : plotMan->menuActions())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->menuView->addAction(a);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    ui->menuView->addSeparator();

			




	
	
	
		
 

			




	
	
	
		
 
    QMenu* tbMenu = ui->menuView->addMenu("Toolbars");

			




	
	
	
		
 
    tbMenu->addAction(ui->plotToolBar->toggleViewAction());

			




	
	
	
		
 
    tbMenu->addAction(portControl.toolBar()->toggleViewAction());

			




	
	
	
		
 

			




	
	
	
		
 
    // init UI signals

			




	
	
	
		
 

			




	
	
	
		
 
    // Help menu signals

			




	
	
	
		
 
    QObject::connect(ui->actionHelpAbout, &QAction::triggered,

			




	
	
	
		
 
              &aboutDialog, &QWidget::show);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionReportBug, &QAction::triggered,

			




	
	
	
		
 
                     [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});

			




	
	
	
		
 

			




	
	
	
		
 
    // File menu signals

			




	
	
	
		
 
    QObject::connect(ui->actionExportCsv, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onExportCsv);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionSaveSettings, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onSaveSettings);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionLoadSettings, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onLoadSettings);

			




	
	
	
		
 

			




	
	
	
		
 
    ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionQuit, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::close);

			




	
	
	
		
 

			




	
	
	
		
 
    // port control signals

			




	
	
	
		
 
    QObject::connect(&portControl, &PortControl::portToggled,

			




	
	
	
		
 
                     this, &MainWindow::onPortToggled);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            this, &MainWindow::onNumOfSamplesChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::onNumOfSamplesChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::scaleChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

			




	
	
	
		
 
                     this, SLOT(clearPlot()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

			




	
	
	
		
 
                     plotMan, &PlotManager::flashSnapshotOverlay);

			




	
	
	
		
 

			




	
	
	
		
 
    // init port signals

			




	
	
	
		
 
    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

			




	
	
	
		
 
                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

			




	
	
	
		
 

			




	
	
	
		
 
    // TODO: `replot` must be triggered from ChannelManager

			




	
	
	
		
 
    // init data format and reader

			




	
	
	
		
 
    QObject::connect(&dataFormatPanel, &DataFormatPanel::dataAdded,

			




	
	
	
		
 
    QObject::connect(&channelMan, &ChannelManager::dataAdded,

			




	
	
	
		
 
                     plotMan, &PlotManager::replot);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionPause, &QAction::triggered,

			




	
	
	
		
 
                     &dataFormatPanel, &DataFormatPanel::pause);

			




	
	
	
		
 
                     &channelMan, &ChannelManager::pause);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&recordPanel, &RecordPanel::recordStarted,

			




	
	
	
		
 
                     &dataFormatPanel, &DataFormatPanel::startRecording);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&recordPanel, &RecordPanel::recordStopped,

			




	
	
	
		
 
                     &dataFormatPanel, &DataFormatPanel::stopRecording);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionPause, &QAction::triggered,

			




	
	
	
		
 
                     [this](bool enabled)

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                         if (enabled && !recordPanel.recordPaused())

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(true);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                         else

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(false);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                     });

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,

			




	
	
	
		
 
                     [this](bool enabled)

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                         if (ui->actionPause->isChecked() && enabled)

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(false);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                     });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&serialPort, &QIODevice::aboutToClose,

			




	
	
	
		
 
            &recordPanel, &RecordPanel::onPortClose);

			




	
	
	
		
 

			




	
	
	
		
 
    // init data arrays and plot

			




	
	
	
		
 
    numOfSamples = plotControlPanel.numOfSamples();

			




	
	
	
		
 
    unsigned numOfChannels = dataFormatPanel.numOfChannels();

			




	
	
	
		
 

			




	
	
	
		
 
    channelMan.setNumOfSamples(numOfSamples);

			




	
	
	
		
 
    channelMan.setNumOfChannels(dataFormatPanel.numOfChannels());

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&dataFormatPanel, &DataFormatPanel::numOfChannelsChanged,

			




	
	
	
		
 
            &channelMan, &ChannelManager::setNumOfChannels);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&channelMan, &ChannelManager::numOfChannelsChanged,

			




	
	
	
		
 
            this, &MainWindow::onNumOfChannelsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    plotControlPanel.setChannelInfoModel(channelMan.infoModel());

			




	
	
	
		
 

			




	
	
	
		
 
    // init curve list

			




	
	
	
		
 
    for (unsigned int i = 0; i < numOfChannels; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // init auto scale

			




	
	
	
		
 
    plotMan->setAxis(plotControlPanel.autoScale(),

			




	
	
	
		
 
                     plotControlPanel.yMin(), plotControlPanel.yMax());

			




	
	
	
		
 

			




	
	
	
		
 
    // Init sps (sample per second) counter

			




	
	
	
		
 
    spsLabel.setText("0sps");

			




	
	
	
		
 
    spsLabel.setToolTip("samples per second (per channel)");

			




	
	
	
		
 
    ui->statusBar->addPermanentWidget(&spsLabel);

			




	
	
	
		
 
    QObject::connect(&dataFormatPanel,

			




	
	
	
		
 
                     &DataFormatPanel::samplesPerSecondChanged,

			




	
	
	
		
 
                     this, &MainWindow::onSpsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    // init demo

			




	
	
	
		
 
    QObject::connect(ui->actionDemoMode, &QAction::toggled,

			




	
	
	
		
 
                     this, &MainWindow::enableDemo);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionDemoMode, &QAction::toggled,

			




	
	
	
		
 
                     plotMan, &PlotManager::showDemoIndicator);

			




	
	
	
		
 

			




	
	
	
		
 
    // load default settings

			




	
	
	
		
 
    QSettings settings("serialplot", "serialplot");

			




	
	
	
		
 
    loadAllSettings(&settings);

			




	
	
	
		
 

			




	
	
	
		
 
    // ensure command panel has 1 command if none loaded

			




	
	
	
		
 
    if (!commandPanel.numOfCommands())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        commandPanel.newCommandAction()->trigger();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Important: This should be after newCommandAction is triggered

			




	
	
	
		
 
    // (above) we don't want user to be greeted with command panel on

			




	
	
	
		
 
    // the very first run.

			




	
	
	
		
 
    connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                this->ui->tabWidget->setCurrentWidget(&commandPanel);

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
MainWindow::~MainWindow()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // save settings

			




	
	
	
		
 
    QSettings settings("serialplot", "serialplot");

			




	
	
	
		
 
    saveAllSettings(&settings);

			




	
	
	
		
 

			




	
	
	
		
 
    if (serialPort.isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        serialPort.close();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    delete plotMan;

			




	
	
	
		
 

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
    ui = NULL; // we check if ui is deleted in messageHandler

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::closeEvent(QCloseEvent * event)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (!snapshotMan.isAllSaved())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        auto clickedButton = QMessageBox::warning(

			




	
	
	
		
 
            this, "Closing SerialPlot",

			




	
	
	
		
 
            "There are un-saved snapshots. If you close you will loose the data.",

			




	
	
	
		
 
            QMessageBox::Discard | QMessageBox::Discard,

			




	
	
	
		
 
            QMessageBox::Cancel);

			




	
	
	
		
 
        if (clickedButton == QMessageBox::Cancel)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            event->ignore();

			




	
	
	
		
 
            return;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    QMainWindow::closeEvent(event);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::setupAboutDialog()

			




	
	
	
		
 
{

			




	
	
	
		
 
    Ui_AboutDialog uiAboutDialog;

			




	
	
	
		
 
    uiAboutDialog.setupUi(&aboutDialog);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,

			




	
	
	
		
 
                     [](){ QApplication::aboutQt();});

			




	
	
	
		
 

			




	
	
	
		
 
    QString aboutText = uiAboutDialog.lbAbout->text();

			




	
	
	
		
 
    aboutText.replace("$VERSION_STRING$", VERSION_STRING);

			




	
	
	
		
 
    aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);

			




	
	
	
		
 
    uiAboutDialog.lbAbout->setText(aboutText);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onPortToggled(bool open)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // make sure demo mode is disabled

			




	
	
	
		
 
    if (open && isDemoRunning()) enableDemo(false);

			




	
	
	
		
 
    ui->actionDemoMode->setEnabled(!open);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onPortError(QSerialPort::SerialPortError error)

			




	
	
	
		
 
{

			




	
	
	
		
 
    switch(error)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        case QSerialPort::NoError :

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::ResourceError :

			




	
	
	
		
 
            qWarning() << "Port error: resource unavaliable; most likely device removed.";

			




	
	
	
		
 
            if (serialPort.isOpen())

			




	
	
	
		
 
            {

			




	
	
	
		
 
                qWarning() << "Closing port on resource error: " << serialPort.portName();

			




	
	
	
		
 
                portControl.togglePort();

			




	
	
	
		
 
            }

			




	
	
	
		
 
            portControl.loadPortList();

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::DeviceNotFoundError:

			




	
	
	
		
 
            qCritical() << "Device doesn't exists: " << serialPort.portName();

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::PermissionError:

			




	
	
	
		
 
            qCritical() << "Permission denied. Either you don't have \

			




	
	
	
		
 
required privileges or device is already opened by another process.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::OpenError:

			




	
	
	
		
 
            qWarning() << "Device is already opened!";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::NotOpenError:

			




	
	
	
		
 
            qCritical() << "Device is not open!";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::ParityError:

			




	
	
	
		
 
            qCritical() << "Parity error detected.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::FramingError:

			




	
	
	
		
 
            qCritical() << "Framing error detected.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::BreakConditionError:

			




	
	
	
		
 
            qCritical() << "Break condition is detected.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::WriteError:

			




	
	
	
		
 
            qCritical() << "An error occurred while writing data.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::ReadError:

			




	
	
	
		
 
            qCritical() << "An error occurred while reading data.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::UnsupportedOperationError:

			




	
	
	
		
 
            qCritical() << "Operation is not supported.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::TimeoutError:

			




	
	
	
		
 
            qCritical() << "A timeout error occurred.";

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QSerialPort::UnknownError:

			




	
	
	
		
 
            qCritical() << "Unknown error! Error: " << serialPort.errorString();

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        default:

			




	
	
	
		
 
            qCritical() << "Unhandled port error: " << error;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::clearPlot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (unsigned ci = 0; ci < channelMan.numOfChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelMan.channelBuffer(ci)->clear();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    plotMan->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onNumOfSamplesChanged(int value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    numOfSamples = value;

			




	
	
	
		
 
    channelMan.setNumOfSamples(value);

			




	
	
	
		
 
    plotMan->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onNumOfChannelsChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned int oldNum = plotMan->numOfCurves();

			




	
	
	
		
 
    unsigned numOfChannels = value;

			




	
	
	
		
 

			




	
	
	
		
 
    if (numOfChannels > oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add new channels

			




	
	
	
		
 
        for (unsigned int i = oldNum; i < numOfChannels; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if(numOfChannels < oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plotMan->removeCurves(oldNum - numOfChannels);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    plotMan->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onSpsChanged(unsigned sps)

			




	
	
	
		
 
{

			




	
	
	
		
 
    spsLabel.setText(QString::number(sps) + "sps");

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool MainWindow::isDemoRunning()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->actionDemoMode->isChecked();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::enableDemo(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!serialPort.isOpen())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            dataFormatPanel.enableDemo(true);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            ui->actionDemoMode->setChecked(false);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        dataFormatPanel.enableDemo(false);

			




	
	
	
		
 
        ui->actionDemoMode->setChecked(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onExportCsv()

			




	
	
	
		
 
{

			




	
	
	
		
 
    bool wasPaused = ui->actionPause->isChecked();

			




	
	
	
		
 
    ui->actionPause->setChecked(true); // pause plotting

			




	
	
	
		
 

			




	
	
	
		
 
    QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));

			




	
	
	
		
 

			




	
	
	
		
 
    if (fileName.isNull())  // user canceled export

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->actionPause->setChecked(wasPaused);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        Snapshot* snapshot = snapshotMan.makeSnapshot();

			




	
	
	
		
 
        snapshot->save(fileName);

			




	
	
	
		
 
        delete snapshot;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::messageHandler(QtMsgType type,

			




	
	
	
		
 
                                const QMessageLogContext &context,

			




	
	
	
		
 
                                const QString &msg)

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString logString;

			




	
	
	
		
 

			




	
	
	
		
 
    switch (type)

			




	
	
	
		
 
    {

			




	
	
	
		
 
#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))

			




	
	
	
		
 
        case QtInfoMsg:

			




	
	
	
		
 
            logString = "[Info] " + msg;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
#endif

			




	
	
	
		
 
        case QtDebugMsg:

			




	
	
	
		
 
            logString = "[Debug] " + msg;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QtWarningMsg:

			




	
	
	
		
 
            logString = "[Warning] " + msg;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QtCriticalMsg:

			




	
	
	
		
 
            logString = "[Error] " + msg;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
        case QtFatalMsg:

			




	
	
	
		
 
            logString = "[Fatal] " + msg;

			




	
	
	
		
 
            break;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (ui != NULL) ui->ptLog->appendPlainText(logString);

			




	
	
	
		
 
    std::cerr << logString.toStdString() << std::endl;

			




	
	
	
		
 

			




	
	
	
		
 
    if (type != QtDebugMsg && ui != NULL)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->statusBar->showMessage(msg, 5000);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (type == QtFatalMsg)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        __builtin_trap();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::saveAllSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    saveMWSettings(settings);

			




	
	
	
		
 
    portControl.saveSettings(settings);

			




	
	
	
		
 
    dataFormatPanel.saveSettings(settings);

			




	
	
	
		
 
    channelMan.saveSettings(settings);

			




	
	
	
		
 
    plotControlPanel.saveSettings(settings);

			




	
	
	
		
 
    plotMan->saveSettings(settings);

			




	
	
	
		
 
    commandPanel.saveSettings(settings);

			




	
	
	
		
 
    recordPanel.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::loadAllSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    loadMWSettings(settings);

			




	
	
	
		
 
    portControl.loadSettings(settings);

			




	
	
	
		
 
    dataFormatPanel.loadSettings(settings);

			




	
	
	
		
 
    channelMan.loadSettings(settings);

			




	
	
	
		
 
    plotControlPanel.loadSettings(settings);

			




	
	
	
		
 
    plotMan->loadSettings(settings);

			




	
	
	
		
 
    commandPanel.loadSettings(settings);

			




	
	
	
		
 
    recordPanel.loadSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::saveMWSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // save window geometry

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_MainWindow);

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_Size, size());

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_Pos, pos());

			




	
	
	
		
 
    // save active panel

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_ActivePanel,

			




	
	
	
		
 
                       panelSettingMap.value(ui->tabWidget->currentIndex()));

			




	
	
	
		
 
    // save panel minimization

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_HidePanels,

			




	
	
	
		
 
                       ui->tabWidget->hideAction.isChecked());

			




	
	
	
		
 
    // save window maximized state

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_Maximized,

			




	
	
	
		
 
                       bool(windowState() & Qt::WindowMaximized));

			




	
	
	
		
 
    // save toolbar/dockwidgets state

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_State, saveState());

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::loadMWSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_MainWindow);

			




	
	
	
		
 
    // load window geometry

			




	
	
	
		
 
    resize(settings->value(SG_MainWindow_Size, size()).toSize());

			




	
	
	
		
 
    move(settings->value(SG_MainWindow_Pos, pos()).toPoint());

			




	
	
	
		
 

			




	
	
	
		
 
    // set active panel

			




	
	
	
		
 
    QString tabSetting =

			




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

			




	
	
	
		
 
    ui->tabWidget->setCurrentIndex(

			




	
	
	
		
 
        panelSettingMap.key(tabSetting, ui->tabWidget->currentIndex()));

			




	
	
	
		
 

			




	
	
	
		
 
    // hide panels

			




	
	
	
		
 
    ui->tabWidget->hideAction.setChecked(

			




	
	
	
		
 
        settings->value(SG_MainWindow_HidePanels,

			




	
	
	
		
 
                        ui->tabWidget->hideAction.isChecked()).toBool());

			




	
	
	
		
 

			




	
	
	
		
 
    // maximize window

			




	
	
	
		
 
    if (settings->value(SG_MainWindow_Maximized).toBool())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        showMaximized();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // load toolbar/dockwidgets state

			




	
	
	
		
 
    restoreState(settings->value(SG_MainWindow_State).toByteArray());

			




	
	
	
		
 
    settings->setValue(SG_MainWindow_State, saveState());

			




	
	
	
		
 

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onSaveSettings()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString fileName = QFileDialog::getSaveFileName(

			




	
	
	
		
 
        this, tr("Save Settings"), QString(), "INI (*.ini)");

			




	
	
	
		
 

			




	
	
	
		
 
    if (!fileName.isNull()) // user canceled

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QSettings settings(fileName, QSettings::IniFormat);

			




	
	
	
		
 
        saveAllSettings(&settings);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onLoadSettings()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString fileName = QFileDialog::getOpenFileName(

			




	
	
	
		
 
        this, tr("Load Settings"), QString(), "INI (*.ini)");

			




	
	
	
		
 

			




	
	
	
		
 
    if (!fileName.isNull()) // user canceled

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QSettings settings(fileName, QSettings::IniFormat);

			




	
	
	
		
 
        loadAllSettings(&settings);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/mainwindow.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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 MAINWINDOW_H

			




	
	
	
		
 
#define MAINWINDOW_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QMainWindow>

			




	
	
	
		
 
#include <QButtonGroup>

			




	
	
	
		
 
#include <QLabel>

			




	
	
	
		
 
#include <QString>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QList>

			




	
	
	
		
 
#include <QSerialPort>

			




	
	
	
		
 
#include <QSignalMapper>

			




	
	
	
		
 
#include <QTimer>

			




	
	
	
		
 
#include <QColor>

			




	
	
	
		
 
#include <QtGlobal>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 
#include <qwt_plot_curve.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "portcontrol.h"

			




	
	
	
		
 
#include "commandpanel.h"

			




	
	
	
		
 
#include "dataformatpanel.h"

			




	
	
	
		
 
#include "plotcontrolpanel.h"

			




	
	
	
		
 
#include "recordpanel.h"

			




	
	
	
		
 
#include "ui_about_dialog.h"

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 
#include "channelmanager.h"

			




	
	
	
		
 
#include "snapshotmanager.h"

			




	
	
	
		
 
#include "plotmanager.h"

			




	
	
	
		
 
#include "datarecorder.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class MainWindow;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
class MainWindow : public QMainWindow

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit MainWindow(QWidget *parent = 0);

			




	
	
	
		
 
    ~MainWindow();

			




	
	
	
		
 

			




	
	
	
		
 
    void messageHandler(QtMsgType type, const QMessageLogContext &context,

			




	
	
	
		
 
                        const QString &msg);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::MainWindow *ui;

			




	
	
	
		
 

			




	
	
	
		
 
    QDialog aboutDialog;

			




	
	
	
		
 
    void setupAboutDialog();

			




	
	
	
		
 

			




	
	
	
		
 
    QSerialPort serialPort;

			




	
	
	
		
 
    PortControl portControl;

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned int numOfSamples;

			




	
	
	
		
 

			




	
	
	
		
 
    QList<QwtPlotCurve*> curves;

			




	
	
	
		
 
    ChannelManager channelMan;

			




	
	
	
		
 
    PlotManager* plotMan;

			




	
	
	
		
 
    SnapshotManager snapshotMan;

			




	
	
	
		
 
    DataRecorder recorder;       // operated by `recordPanel`

			




	
	
	
		
 

			




	
	
	
		
 
    QLabel spsLabel;

			




	
	
	
		
 
    CommandPanel commandPanel;

			




	
	
	
		
 
    DataFormatPanel dataFormatPanel;

			




	
	
	
		
 
    RecordPanel recordPanel;

			




	
	
	
		
 
    PlotControlPanel plotControlPanel;

			




	
	
	
		
 

			




	
	
	
		
 
    bool isDemoRunning();

			




	
	
	
		
 
    /// Stores settings for all modules

			




	
	
	
		
 
    void saveAllSettings(QSettings* settings);

			




	
	
	
		
 
    /// Load settings for all modules

			




	
	
	
		
 
    void loadAllSettings(QSettings* settings);

			




	
	
	
		
 
    /// Stores main window settings into a `QSettings`

			




	
	
	
		
 
    void saveMWSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads main window settings from a `QSettings`

			




	
	
	
		
 
    void loadMWSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
    /// `QWidget::closeEvent` handler

			




	
	
	
		
 
    void closeEvent(QCloseEvent * event);

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void onPortToggled(bool open);

			




	
	
	
		
 
    void onPortError(QSerialPort::SerialPortError error);

			




	
	
	
		
 

			




	
	
	
		
 
    void onNumOfSamplesChanged(int value);

			




	
	
	
		
 
    void onNumOfChannelsChanged(unsigned value);

			




	
	
	
		
 

			




	
	
	
		
 
    void clearPlot();

			




	
	
	
		
 
    void onSpsChanged(unsigned sps);

			




	
	
	
		
 
    void enableDemo(bool enabled);

			




	
	
	
		
 
    void onExportCsv();

			




	
	
	
		
 
    void onSaveSettings();

			




	
	
	
		
 
    void onLoadSettings();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // MAINWINDOW_H

			




        

    


    
    

    

        

                

                    src/recordpanel.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 <QIcon>

			




	
	
	
		
 
#include <QFile>

			




	
	
	
		
 
#include <QFileInfo>

			




	
	
	
		
 
#include <QMessageBox>

			




	
	
	
		
 
#include <QFileDialog>

			




	
	
	
		
 
#include <QRegularExpression>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "recordpanel.h"

			




	
	
	
		
 
#include "ui_recordpanel.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
RecordPanel::RecordPanel(DataRecorder* recorder, ChannelManager* channelMan, QWidget *parent) :

			




	
	
	
		
 
    QWidget(parent),

			




	
	
	
		
 
    ui(new Ui::RecordPanel),

			




	
	
	
		
 
    recordToolBar(tr("Record Toolbar")),

			




	
	
	
		
 
    recordAction(QIcon::fromTheme("media-record"), tr("Record"), this)

			




	
	
	
		
 
{

			




	
	
	
		
 
    overwriteSelected = false;

			




	
	
	
		
 
    _recorder = recorder;

			




	
	
	
		
 
    _channelMan = channelMan;

			




	
	
	
		
 

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    recordToolBar.setObjectName("tbRecord");

			




	
	
	
		
 

			




	
	
	
		
 
    recordAction.setCheckable(true);

			




	
	
	
		
 
    recordToolBar.addAction(&recordAction);

			




	
	
	
		
 
    ui->pbRecord->setDefaultAction(&recordAction);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->pbBrowse, &QPushButton::clicked,

			




	
	
	
		
 
            this, &RecordPanel::selectFile);

			




	
	
	
		
 
    connect(&recordAction, &QAction::triggered,

			




	
	
	
		
 
            this, &RecordPanel::onRecord);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->cbRecordPaused, SIGNAL(toggled(bool)),

			




	
	
	
		
 
            this, SIGNAL(recordPausedChanged(bool)));

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->cbDisableBuffering, &QCheckBox::toggled,

			




	
	
	
		
 
            [this](bool enabled)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                _recorder->disableBuffering = enabled;

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
RecordPanel::~RecordPanel()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QToolBar* RecordPanel::toolbar()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &recordToolBar;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool RecordPanel::isRecording()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return recordAction.isChecked();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool RecordPanel::recordPaused()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->cbRecordPaused->isChecked();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool RecordPanel::selectFile()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString fileName = QFileDialog::getSaveFileName(

			




	
	
	
		
 
        parentWidget(), tr("Select recording file"));

			




	
	
	
		
 

			




	
	
	
		
 
    if (fileName.isEmpty())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return false;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectedFile = fileName;

			




	
	
	
		
 
        ui->lbFileName->setText(selectedFile);

			




	
	
	
		
 
        overwriteSelected = QFile::exists(fileName);

			




	
	
	
		
 
        return true;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::onRecord(bool start)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (!start)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        stopRecording();

			




	
	
	
		
 
        return;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    bool canceled = false;

			




	
	
	
		
 
    if (ui->leSeparator->text().isEmpty())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QMessageBox::critical(this, "Error",

			




	
	
	
		
 
                              "Column separator cannot be empty! Please select a separator.");

			




	
	
	
		
 
        ui->leSeparator->setFocus(Qt::OtherFocusReason);

			




	
	
	
		
 
        canceled = true;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // check file name

			




	
	
	
		
 
    if (!canceled && selectedFile.isEmpty() && !selectFile())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        canceled = true;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (!canceled && !overwriteSelected && QFile::exists(selectedFile))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (ui->cbAutoIncrement->isChecked())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // TODO: should we increment even if user selected to replace?

			




	
	
	
		
 
            canceled = !incrementFileName();

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            canceled = !confirmOverwrite(selectedFile);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (canceled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        recordAction.setChecked(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        overwriteSelected = false;

			




	
	
	
		
 
        startRecording();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool RecordPanel::incrementFileName(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    QFileInfo fileInfo(selectedFile);

			




	
	
	
		
 

			




	
	
	
		
 
    QString base = fileInfo.completeBaseName();

			




	
	
	
		
 
    QRegularExpression regex("(.*?)(\\d+)(?!.*\\d)(.*)");

			




	
	
	
		
 
    auto match = regex.match(base);

			




	
	
	
		
 

			




	
	
	
		
 
    if (match.hasMatch())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        bool ok;

			




	
	
	
		
 
        int fileNum = match.captured(2).toInt(&ok);

			




	
	
	
		
 
        base = match.captured(1) + QString::number(fileNum + 1) + match.captured(3);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        base += "_1";

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    QString suffix = fileInfo.suffix();;

			




	
	
	
		
 
    if (!suffix.isEmpty())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        suffix = "." + suffix;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    QString autoFileName = fileInfo.path() + "/" + base + suffix;

			




	
	
	
		
 

			




	
	
	
		
 
    // check if auto generated file name exists, ask user another name

			




	
	
	
		
 
    if (QFile::exists(autoFileName))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!confirmOverwrite(autoFileName))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            return false;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectedFile = autoFileName;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    ui->lbFileName->setText(selectedFile);

			




	
	
	
		
 
    return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool RecordPanel::confirmOverwrite(QString fileName)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // prepare message box

			




	
	
	
		
 
    QMessageBox mb(parentWidget());

			




	
	
	
		
 
    mb.setWindowTitle(tr("File Already Exists"));

			




	
	
	
		
 
    mb.setIcon(QMessageBox::Warning);

			




	
	
	
		
 
    mb.setText(tr("File (%1) already exists. How to continue?").arg(fileName));

			




	
	
	
		
 

			




	
	
	
		
 
    auto bCancel    = mb.addButton(QMessageBox::Cancel);

			




	
	
	
		
 
    auto bOverwrite = mb.addButton(tr("Overwrite"), QMessageBox::DestructiveRole);

			




	
	
	
		
 
    mb.addButton(tr("Select Another File"), QMessageBox::YesRole);

			




	
	
	
		
 

			




	
	
	
		
 
    mb.setEscapeButton(bCancel);

			




	
	
	
		
 

			




	
	
	
		
 
    // show message box

			




	
	
	
		
 
    mb.exec();

			




	
	
	
		
 

			




	
	
	
		
 
    if (mb.clickedButton() == bCancel)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return false;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (mb.clickedButton() == bOverwrite)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectedFile = fileName;

			




	
	
	
		
 
        return true;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else                    // select button

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return selectFile();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::startRecording(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    QStringList channelNames;

			




	
	
	
		
 
    if (ui->cbHeader->isChecked())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelNames = _channelMan->infoModel()->channelNames();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    _recorder->startRecording(selectedFile, getSeparator(), channelNames);

			




	
	
	
		
 
    emit recordStarted();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::stopRecording(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    emit recordStopped();

			




	
	
	
		
 
    _recorder->stopRecording();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::onPortClose()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (recordAction.isChecked() && ui->cbStopOnClose->isChecked())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        stopRecording();

			




	
	
	
		
 
        recordAction.setChecked(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QString RecordPanel::getSeparator() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString sep = ui->leSeparator->text();

			




	
	
	
		
 
    sep.replace("\\t", "\t");

			




	
	
	
		
 
    return sep;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::saveSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Record);

			




	
	
	
		
 
    settings->setValue(SG_Record_AutoIncrement, ui->cbAutoIncrement->isChecked());

			




	
	
	
		
 
    settings->setValue(SG_Record_RecordPaused, ui->cbRecordPaused->isChecked());

			




	
	
	
		
 
    settings->setValue(SG_Record_StopOnClose, ui->cbStopOnClose->isChecked());

			




	
	
	
		
 
    settings->setValue(SG_Record_Header, ui->cbHeader->isChecked());

			




	
	
	
		
 
    settings->setValue(SG_Record_DisableBuffering, ui->cbDisableBuffering->isChecked());

			




	
	
	
		
 
    settings->setValue(SG_Record_Separator, ui->leSeparator->text());

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void RecordPanel::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    settings->beginGroup(SettingGroup_Record);

			




	
	
	
		
 
    ui->cbAutoIncrement->setChecked(

			




	
	
	
		
 
        settings->value(SG_Record_AutoIncrement, ui->cbAutoIncrement->isChecked()).toBool());

			




	
	
	
		
 
    ui->cbRecordPaused->setChecked(

			




	
	
	
		
 
        settings->value(SG_Record_RecordPaused, ui->cbRecordPaused->isChecked()).toBool());

			




	
	
	
		
 
    ui->cbStopOnClose->setChecked(

			




	
	
	
		
 
        settings->value(SG_Record_StopOnClose, ui->cbStopOnClose->isChecked()).toBool());

			




	
	
	
		
 
    ui->cbHeader->setChecked(

			




	
	
	
		
 
        settings->value(SG_Record_Header, ui->cbHeader->isChecked()).toBool());

			




	
	
	
		
 
    ui->cbDisableBuffering->setChecked(

			




	
	
	
		
 
        settings->value(SG_Record_DisableBuffering, ui->cbDisableBuffering->isChecked()).toBool());

			




	
	
	
		
 
    ui->leSeparator->setText(settings->value(SG_Record_Separator, ui->leSeparator->text()).toString());

			




	
	
	
		
 
    settings->endGroup();

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/recordpanel.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2017 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 RECORDPANEL_H

			




	
	
	
		
 
#define RECORDPANEL_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QString>

			




	
	
	
		
 
#include <QToolBar>

			




	
	
	
		
 
#include <QAction>

			




	
	
	
		
 

			




	
	
	
		
 
#include "datarecorder.h"

			




	
	
	
		
 
#include "channelmanager.h"

			




	
	
	
		
 

			




	
	
	
		
 
namespace Ui {

			




	
	
	
		
 
class RecordPanel;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
class RecordPanel : public QWidget

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit RecordPanel(DataRecorder* recorder, ChannelManager* channelMan,

			




	
	
	
		
 
                         QWidget* parent = 0);

			




	
	
	
		
 
    ~RecordPanel();

			




	
	
	
		
 

			




	
	
	
		
 
    QToolBar* toolbar();

			




	
	
	
		
 

			




	
	
	
		
 
    bool isRecording();

			




	
	
	
		
 
    bool recordPaused();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Stores settings into a `QSettings`

			




	
	
	
		
 
    void saveSettings(QSettings* settings);

			




	
	
	
		
 
    /// Loads settings from a `QSettings`.

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void recordStarted();

			




	
	
	
		
 
    void recordStopped();

			




	
	
	
		
 
    void recordPausedChanged(bool enabled);

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    /// Must be called when port is closed

			




	
	
	
		
 
    void onPortClose();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    Ui::RecordPanel *ui;

			




	
	
	
		
 
    QToolBar recordToolBar;

			




	
	
	
		
 
    QAction recordAction;

			




	
	
	
		
 
    QString selectedFile;

			




	
	
	
		
 
    bool overwriteSelected;

			




	
	
	
		
 
    DataRecorder* _recorder;

			




	
	
	
		
 
    ChannelManager* _channelMan;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Increments the file name.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * If file name doesn't have a number at the end of it, a number is appended

			




	
	
	
		
 
     * with underscore starting from 1.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @return false if user cancels

			




	
	
	
		
 
     */

			




	
	
	
		
 
    bool incrementFileName(void);

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Used to ask user confirmation if auto generated file

			




	
	
	
		
 
     * name exists.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * If user confirms overwrite, `selectedFile` is set to

			




	
	
	
		
 
     * `fileName`. User is also given option to select file and is

			




	
	
	
		
 
     * shown a file select dialog in this case.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param fileName auto generated file name.

			




	
	
	
		
 
     * @return false if user cancels

			




	
	
	
		
 
     */

			




	
	
	
		
 
    bool confirmOverwrite(QString fileName);

			




	
	
	
		
 

			




	
	
	
		
 
    void startRecording(void);

			




	
	
	
		
 
    void stopRecording(void);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Returns separator text from ui. "\t" is converted to TAB

			




	
	
	
		
 
    /// character.

			




	
	
	
		
 
    QString getSeparator() const;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @brief Opens up the file select dialog

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * If you cancel the selection operation, currently selected file is not

			




	
	
	
		
 
     * changed.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @return true if file selected, false if user cancels

			




	
	
	
		
 
     */

			




	
	
	
		
 
    bool selectFile();

			




	
	
	
		
 

			




	
	
	
		
 
    void onRecord(bool start);

			




	
	
	
		
 

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // RECORDPANEL_H

			




        

    


    
    

    

        

                

                    src/recordpanel.ui
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
<?xml version="1.0" encoding="UTF-8"?>

			




	
	
	
		
 
<ui version="4.0">

			




	
	
	
		
 
 <class>RecordPanel</class>

			




	
	
	
		
 
 <widget class="QWidget" name="RecordPanel">

			




	
	
	
		
 
  <property name="geometry">

			




	
	
	
		
 
   <rect>

			




	
	
	
		
 
    <x>0</x>

			




	
	
	
		
 
    <y>0</y>

			




	
	
	
		
 
    <width>532</width>

			




	
	
	
		
 
    <height>261</height>

			




	
	
	
		
 
   </rect>

			




	
	
	
		
 
  </property>

			




	
	
	
		
 
  <property name="windowTitle">

			




	
	
	
		
 
   <string>Form</string>

			




	
	
	
		
 
  </property>

			




	
	
	
		
 
  <layout class="QHBoxLayout" name="horizontalLayout_2">

			




	
	
	
		
 
   <item>

			




	
	
	
		
 
    <layout class="QVBoxLayout" name="verticalLayout">

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <layout class="QHBoxLayout" name="horizontalLayout">

			




	
	
	
		
 
       <item>

			




	
	
	
		
 
        <widget class="QPushButton" name="pbBrowse">

			




	
	
	
		
 
         <property name="toolTip">

			




	
	
	
		
 
          <string>Select record file</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
         <property name="text">

			




	
	
	
		
 
          <string>Browse</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
        </widget>

			




	
	
	
		
 
       </item>

			




	
	
	
		
 
       <item>

			




	
	
	
		
 
        <widget class="QLabel" name="lbFileName">

			




	
	
	
		
 
         <property name="sizePolicy">

			




	
	
	
		
 
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">

			




	
	
	
		
 
           <horstretch>0</horstretch>

			




	
	
	
		
 
           <verstretch>0</verstretch>

			




	
	
	
		
 
          </sizepolicy>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
         <property name="text">

			




	
	
	
		
 
          <string>Select file...</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
        </widget>

			




	
	
	
		
 
       </item>

			




	
	
	
		
 
      </layout>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QCheckBox" name="cbAutoIncrement">

			




	
	
	
		
 
       <property name="toolTip">

			




	
	
	
		
 
        <string>Increments file name automatically everytime a new recording starts</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Auto increment file name</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="checked">

			




	
	
	
		
 
        <bool>true</bool>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QCheckBox" name="cbRecordPaused">

			




	
	
	
		
 
       <property name="toolTip">

			




	
	
	
		
 
        <string>Continue recording to file even when plotting is paused</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Record while paused</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="checked">

			




	
	
	
		
 
        <bool>true</bool>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QCheckBox" name="cbStopOnClose">

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Stop recording when port closed</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="checked">

			




	
	
	
		
 
        <bool>true</bool>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QCheckBox" name="cbHeader">

			




	
	
	
		
 
       <property name="toolTip">

			




	
	
	
		
 
        <string>Channel names are written to the first line of record file</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Write header line</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="checked">

			




	
	
	
		
 
        <bool>true</bool>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <layout class="QHBoxLayout" name="horizontalLayout_3">

			




	
	
	
		
 
       <item>

			




	
	
	
		
 
        <widget class="QLabel" name="label">

			




	
	
	
		
 
         <property name="text">

			




	
	
	
		
 
          <string>Column Separator:</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
        </widget>

			




	
	
	
		
 
       </item>

			




	
	
	
		
 
       <item>

			




	
	
	
		
 
        <widget class="QLineEdit" name="leSeparator">

			




	
	
	
		
 
         <property name="maximumSize">

			




	
	
	
		
 
          <size>

			




	
	
	
		
 
           <width>30</width>

			




	
	
	
		
 
           <height>16777215</height>

			




	
	
	
		
 
          </size>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
         <property name="toolTip">

			




	
	
	
		
 
          <string>For TAB character enter \t</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
         <property name="text">

			




	
	
	
		
 
          <string>,</string>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
        </widget>

			




	
	
	
		
 
       </item>

			




	
	
	
		
 
       <item>

			




	
	
	
		
 
        <spacer name="horizontalSpacer">

			




	
	
	
		
 
         <property name="orientation">

			




	
	
	
		
 
          <enum>Qt::Horizontal</enum>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
         <property name="sizeHint" stdset="0">

			




	
	
	
		
 
          <size>

			




	
	
	
		
 
           <width>40</width>

			




	
	
	
		
 
           <height>20</height>

			




	
	
	
		
 
          </size>

			




	
	
	
		
 
         </property>

			




	
	
	
		
 
        </spacer>

			




	
	
	
		
 
       </item>

			




	
	
	
		
 
      </layout>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QCheckBox" name="cbDisableBuffering">

			




	
	
	
		
 
       <property name="toolTip">

			




	
	
	
		
 
        <string>Do not buffer when writing to file. Check this if you are using other software to open the file during recording.</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Disable buffering</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <spacer name="verticalSpacer">

			




	
	
	
		
 
       <property name="orientation">

			




	
	
	
		
 
        <enum>Qt::Vertical</enum>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="sizeHint" stdset="0">

			




	
	
	
		
 
        <size>

			




	
	
	
		
 
         <width>20</width>

			




	
	
	
		
 
         <height>1</height>

			




	
	
	
		
 
        </size>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </spacer>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
    </layout>

			




	
	
	
		
 
   </item>

			




	
	
	
		
 
   <item>

			




	
	
	
		
 
    <layout class="QVBoxLayout" name="verticalLayout_2">

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <widget class="QToolButton" name="pbRecord">

			




	
	
	
		
 
       <property name="minimumSize">

			




	
	
	
		
 
        <size>

			




	
	
	
		
 
         <width>85</width>

			




	
	
	
		
 
         <height>50</height>

			




	
	
	
		
 
        </size>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="toolTip">

			




	
	
	
		
 
        <string>Start/Stop Recording</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="text">

			




	
	
	
		
 
        <string>Record</string>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </widget>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
     <item>

			




	
	
	
		
 
      <spacer name="verticalSpacer_2">

			




	
	
	
		
 
       <property name="orientation">

			




	
	
	
		
 
        <enum>Qt::Vertical</enum>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
       <property name="sizeHint" stdset="0">

			




	
	
	
		
 
        <size>

			




	
	
	
		
 
         <width>20</width>

			




	
	
	
		
 
         <height>1</height>

			




	
	
	
		
 
        </size>

			




	
	
	
		
 
       </property>

			




	
	
	
		
 
      </spacer>

			




	
	
	
		
 
     </item>

			




	
	
	
		
 
    </layout>

			




	
	
	
		
 
   </item>

			




	
	
	
		
 
  </layout>

			




	
	
	
		
 
 </widget>

			




	
	
	
		
 
 <resources/>

			




	
	
	
		
 
 <connections/>

			




	
	
	
		
 
</ui>

			




        

    


    
    

    

        

                

                    src/setting_defines.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2016 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2017 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_ASCII[] = "DataFormat_ASCII";

			




	
	
	
		
 
const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";

			




	
	
	
		
 
const char SettingGroup_Channels[] = "Channels";

			




	
	
	
		
 
const char SettingGroup_Plot[] = "Plot";

			




	
	
	
		
 
const char SettingGroup_Commands[] = "Commands";

			




	
	
	
		
 
const char SettingGroup_Record[] = "Record";

			




	
	
	
		
 

			




	
	
	
		
 
// 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";

			




	
	
	
		
 
const char SG_MainWindow_Maximized[] = "maximized";

			




	
	
	
		
 
const char SG_MainWindow_State[] = "state";

			




	
	
	
		
 

			




	
	
	
		
 
// 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";

			




	
	
	
		
 

			




	
	
	
		
 
// ascii reader keys

			




	
	
	
		
 
const char SG_ASCII_NumOfChannels[] = "numOfChannels";

			




	
	
	
		
 

			




	
	
	
		
 
// framed reader keys

			




	
	
	
		
 
const char SG_CustomFrame_NumOfChannels[] = "numOfChannels";

			




	
	
	
		
 
const char SG_CustomFrame_FrameStart[] = "frameStart";

			




	
	
	
		
 
const char SG_CustomFrame_FixedSize[] = "fixedSize";

			




	
	
	
		
 
const char SG_CustomFrame_FrameSize[] = "frameSize";

			




	
	
	
		
 
const char SG_CustomFrame_NumberFormat[] = "numberFormat";

			




	
	
	
		
 
const char SG_CustomFrame_Endianness[] = "endianness";

			




	
	
	
		
 
const char SG_CustomFrame_Checksum[] = "checksum";

			




	
	
	
		
 
const char SG_CustomFrame_DebugMode[] = "debugMode";

			




	
	
	
		
 

			




	
	
	
		
 
// channel manager keys

			




	
	
	
		
 
const char SG_Channels_Channel[] = "channel";

			




	
	
	
		
 
const char SG_Channels_Name[] = "name";

			




	
	
	
		
 
const char SG_Channels_Color[] = "color";

			




	
	
	
		
 
const char SG_Channels_Visible[] = "visible";

			




	
	
	
		
 

			




	
	
	
		
 
// plot settings keys

			




	
	
	
		
 
const char SG_Plot_NumOfSamples[] = "numOfSamples";

			




	
	
	
		
 
const char SG_Plot_AutoScale[] = "autoScale";

			




	
	
	
		
 
const char SG_Plot_YMax[] = "yMax";

			




	
	
	
		
 
const char SG_Plot_YMin[] = "yMin";

			




	
	
	
		
 
const char SG_Plot_DarkBackground[] = "darkBackground";

			




	
	
	
		
 
const char SG_Plot_Grid[] = "grid";

			




	
	
	
		
 
const char SG_Plot_MinorGrid[] = "minorGrid";

			




	
	
	
		
 
const char SG_Plot_Legend[] = "legend";

			




	
	
	
		
 
const char SG_Plot_MultiPlot[] = "multiPlot";

			




	
	
	
		
 

			




	
	
	
		
 
// command setting keys

			




	
	
	
		
 
const char SG_Commands_Command[] = "command";

			




	
	
	
		
 
const char SG_Commands_Name[] = "name";

			




	
	
	
		
 
const char SG_Commands_Type[] = "type";

			




	
	
	
		
 
const char SG_Commands_Data[] = "data";

			




	
	
	
		
 

			




	
	
	
		
 
// record panel settings keys

			




	
	
	
		
 
const char SG_Record_AutoIncrement[]    = "autoIncrement";

			




	
	
	
		
 
const char SG_Record_RecordPaused[]     = "recordPaused";

			




	
	
	
		
 
const char SG_Record_StopOnClose[]      = "stopOnClose";

			




	
	
	
		
 
const char SG_Record_Header[]           = "header";

			




	
	
	
		
 
const char SG_Record_Separator[]        = "separator";

			




	
	
	
		
 
const char SG_Record_DisableBuffering[] = "disableBuffering";

			




	
	
	
		
 

			




	
	
	
		
 
#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