plugin: Add ADMT Plugin for ADMT4000

CMakeLists.txt

@@ -302,4 +302,4 @@ set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
 set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
 set(CPACK_SET_DESTDIR ON)
 set(CPACK_COMPONENTS_ALL ${SCOPY_PDK})
-include(CPack)
+include(CPack)

plugins/CMakeLists.txt

@@ -33,6 +33,7 @@ option(ENABLE_PLUGIN_SWIOT "Enable SWIOT plugin" ON)
 option(ENABLE_PLUGIN_PQM "Enable PQM plugin" ON)
 option(ENABLE_PLUGIN_DATALOGGER "Enable DATALOGGER plugin" ON)
 option(ENABLE_PLUGIN_DAC "Enable DAC plugin" ON)
+option(ENABLE_PLUGIN_ADMT "Enable ADMT plugin" ON)
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${SCOPY_PLUGIN_BUILD_PATH})
@@ -125,6 +126,11 @@ if(ENABLE_PLUGIN_M2K)
 	endif()
 endif()
 
+if(ENABLE_PLUGIN_ADMT)
+	add_subdirectory(admt)
+	list(APPEND PLUGINS ${ADMT_TARGET_NAME})
+endif()
+
 install(TARGETS ${PLUGINS} LIBRARY DESTINATION ${SCOPY_PLUGIN_INSTALL_PATH})
 
 set(PLUGINS ${PLUGINS} PARENT_SCOPE)

plugins/admt/.gitignore

@@ -0,0 +1,2 @@
+include/admt/scopy-admt_export.h
+include/admt/scopy-admt_config.h

plugins/admt/CMakeLists.txt

@@ -0,0 +1,109 @@
+#
+# Copyright (c) 2024 Analog Devices Inc.
+#
+# This file is part of Scopy
+# (see https://www.github.com/analogdevicesinc/scopy).
+#
+# This program 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+
+cmake_minimum_required(VERSION 3.9)
+
+set(SCOPY_MODULE admt)
+
+message(STATUS "building plugin: " ${SCOPY_MODULE})
+
+project(scopy-${SCOPY_MODULE} VERSION 0.1 LANGUAGES CXX) 
+
+set(PLUGIN_DISPLAY_NAME "ADMT")
+set(PLUGIN_DESCRIPTION "Plugin for ADMT Harmonic Calibration")
+
+include(GenerateExportHeader) 
+
+# TODO: split stylesheet/resources and add here TODO: export header files correctly
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON) 
+
+set(CMAKE_AUTOUIC_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/ui) 
+set(CMAKE_AUTOUIC ON) 
+set(CMAKE_AUTOMOC ON) 
+set(CMAKE_AUTORCC ON) 
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON) 
+
+set(CMAKE_CXX_VISIBILITY_PRESET hidden) 
+set(CMAKE_VISIBILITY_INLINES_HIDDEN TRUE) 
+
+file(
+    GLOB 
+    SRC_LIST 
+    src/*.cpp 
+    src/*.cc
+    src/widgets/*.cpp
+) 
+file(
+    GLOB 
+    HEADER_LIST 
+    include/${SCOPY_MODULE}/*.h 
+    include/${SCOPY_MODULE}/*.hpp
+    include/${SCOPY_MODULE}/widgets/*.h
+) 
+file(GLOB UI_LIST ui/*.ui) 
+
+set(ENABLE_TESTING ON)
+if(ENABLE_TESTING) 
+    add_subdirectory(test) 
+endif() 
+
+set(PROJECT_SOURCES ${SRC_LIST} ${HEADER_LIST} ${UI_LIST}) 
+find_package(Qt${QT_VERSION_MAJOR} COMPONENTS REQUIRED Widgets Core) 
+
+qt_add_resources(PROJECT_RESOURCES res/resources.qrc) 
+add_library(${PROJECT_NAME} SHARED ${PROJECT_SOURCES} ${PROJECT_RESOURCES}) 
+
+generate_export_header( 
+    ${PROJECT_NAME} EXPORT_FILE_NAME ${CMAKE_CURRENT_SOURCE_DIR}/include/${SCOPY_MODULE}/${PROJECT_NAME}_export.h 
+)
+
+include(ScopyStyle)
+generate_style("--plugin" ${CMAKE_CURRENT_SOURCE_DIR}/style ${CMAKE_CURRENT_SOURCE_DIR}/include/admt)
+
+configure_file(
+	include/${SCOPY_MODULE}/scopy-${SCOPY_MODULE}_config.h.cmakein
+	${CMAKE_CURRENT_SOURCE_DIR}/include/${SCOPY_MODULE}/scopy-${SCOPY_MODULE}_config.h @ONLY
+)
+
+target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include) 
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include/${SCOPY_MODULE}) 
+
+target_include_directories(${PROJECT_NAME} PUBLIC scopy-pluginbase scopy-gui) 
+
+target_link_libraries( 
+    ${PROJECT_NAME} 
+    PUBLIC Qt::Widgets 
+        Qt::Core 
+        scopy-pluginbase 
+        scopy-gui 
+        scopy-iioutil 
+        scopy-gr-util
+        scopy-iio-widgets
+)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+	set(INSTALLER_DESCRIPTION "${PLUGIN_DISPLAY_NAME} ${PLUGIN_DESCRIPTION}")
+	configureinstallersettings(${SCOPY_MODULE} ${INSTALLER_DESCRIPTION} TRUE)
+endif()
+
+set(ADMT_TARGET_NAME ${PROJECT_NAME} PARENT_SCOPE)

plugins/admt/include/admt/admtcontroller.h

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2025 Analog Devices Inc.
+ *
+ * This file is part of Scopy
+ * (see https://www.github.com/analogdevicesinc/scopy).
+ *
+ * This program 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ADMTCONTROLLER_H
+#define ADMTCONTROLLER_H
+
+#include "scopy-admt_export.h"
+
+#include <iio.h>
+#include <bitset>
+
+#include <QObject>
+#include <QString>
+
+#include <iioutil/connectionprovider.h>
+#include <pluginbase/statusbarmanager.h>
+
+#include <vector>
+#include <algorithm>
+#include <cstdlib>
+#include <cmath>
+#include <math.h>
+#include <numeric>
+#include <complex>
+#include <iterator>
+#include <cstdint>
+
+using namespace std;
+
+namespace scopy::admt {    
+class SCOPY_ADMT_EXPORT ADMTController : public QObject
+{
+    Q_OBJECT
+public:
+    ADMTController(QString uri, QObject *parent = nullptr);
+    ~ADMTController();
+
+    int HAR_MAG_1, HAR_MAG_2, HAR_MAG_3, HAR_MAG_8 ,HAR_PHASE_1 ,HAR_PHASE_2 ,HAR_PHASE_3 ,HAR_PHASE_8;
+
+    vector<double> angle_errors_fft_pre, 
+                   angle_errors_fft_phase_pre,
+                   angle_errors_fft_post,
+                   angle_errors_fft_phase_post,
+                   calibration_samples_sine, 
+                   calibration_samples_cosine, 
+                   calibration_samples_sine_scaled, 
+                   calibration_samples_cosine_scaled,
+                   angleError,
+                   FFTAngleErrorMagnitude,
+                   FFTAngleErrorPhase,
+                   correctedError,
+                   FFTCorrectedErrorMagnitude,
+                   FFTCorrectedErrorPhase;
+
+    enum Channel
+    {
+        ROTATION,
+        ANGLE,
+        COUNT,
+        TEMPERATURE,
+        CHANNEL_COUNT
+    };
+
+    enum Device
+    {
+        ADMT4000,
+        TMC5240,
+        DEVICE_COUNT
+    };
+
+    enum DeviceAttribute
+    {
+        PAGE,
+        SEQUENCER_MODE,
+        ANGLE_FILT,
+        CONVERSION_MODE,
+        H8_CTRL,
+        SDP_GPIO_CTRL,
+        SDP_GPIO0_BUSY,
+        SDP_COIL_RS,
+        REGMAP_DUMP,
+        DEVICE_ATTR_COUNT
+    };
+
+    enum MotorAttribute
+    {
+        AMAX,
+        ROTATE_VMAX,
+        DMAX,
+        DISABLE,
+        TARGET_POS,
+        CURRENT_POS,
+        RAMP_MODE,
+        MOTOR_ATTR_COUNT
+    };
+
+    enum MotorRampMode
+    {
+        POSITION,
+        RAMP_MODE_1
+    };
+
+    enum HarmonicRegister
+    {
+        H1MAG,
+        H1PH,
+        H2MAG,
+        H2PH,
+        H3MAG,
+        H3PH,
+        H8MAG,
+        H8PH,
+        HARMONIC_REGISTER_COUNT
+    };
+
+    enum ConfigurationRegister
+    {
+        CNVPAGE,
+        DIGIO,
+        FAULT,
+        GENERAL,
+        DIGIOEN,
+        ANGLECK,
+        ECCDCDE,
+        ECCDIS,
+        CONFIGURATION_REGISTER_COUNT
+    };
+
+    enum SensorRegister
+    {
+        ABSANGLE,
+        ANGLEREG,
+        ANGLESEC,
+        SINE,
+        COSINE,
+        SECANGLI,
+        SECANGLQ,
+        RADIUS,
+        DIAG1,
+        DIAG2,
+        TMP0,
+        TMP1,
+        CNVCNT,
+        SENSOR_REGISTER_COUNT
+    };
+
+    enum UniqueIDRegister
+    {
+        UNIQID0,
+        UNIQID1,
+        UNIQID2,
+        UNIQID3,
+        UNIQID_REGISTER_COUNT
+    };
+
+    const char* ChannelIds[CHANNEL_COUNT] = { "rot", "angl", "count", "temp" };
+    const char* DeviceIds[DEVICE_COUNT] = { "admt4000", "tmc5240" };
+    const char* DeviceAttributes[DEVICE_ATTR_COUNT] = { "page", "sequencer_mode", "angle_filt", "conversion_mode", "h8_ctrl", "sdp_gpio_ctrl", "sdp_gpio0_busy", "sdp_coil_rs", "regmap_dump" };
+    const char* MotorAttributes[MOTOR_ATTR_COUNT] = { "amax", "rotate_vmax", "dmax",
+                                                     "disable", "target_pos", "current_pos",
+                                                     "ramp_mode" };
+    const uint32_t ConfigurationRegisters[CONFIGURATION_REGISTER_COUNT] = { 0x01, 0x04, 0x06, 0x10, 0x12, 0x13, 0x1D, 0x23 };
+    const uint32_t ConfigurationPages[CONFIGURATION_REGISTER_COUNT] = { UINT32_MAX, UINT32_MAX, UINT32_MAX, 0x02, 0x02, 0x02, 0x02, 0x02 };
+    const uint32_t UniqueIdRegisters[UNIQID_REGISTER_COUNT] = { 0x1E, 0x1F, 0x20, 0x21 };
+    const uint32_t UniqueIdPages[UNIQID_REGISTER_COUNT] = { 0x02, 0x02, 0x02, 0x02 };
+    const uint32_t HarmonicRegisters[HARMONIC_REGISTER_COUNT] = { 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C };
+    const uint32_t HarmonicPages[HARMONIC_REGISTER_COUNT] = { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 };
+    const uint32_t SensorRegisters[SENSOR_REGISTER_COUNT] = { 0x03, 0x05, 0x08, 0x10, 0x11, 0x12, 0x13, 0x18, 0x1D, 0x1E, 0x20, 0x23, 0x14 };
+    const uint32_t SensorPages[SENSOR_REGISTER_COUNT] = { UINT32_MAX, UINT32_MAX, UINT32_MAX, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 };
+
+    const char* getChannelId(Channel channel);
+    const char* getDeviceId(Device device);
+    const char* getDeviceAttribute(DeviceAttribute attribute);
+    const char* getMotorAttribute(MotorAttribute attribute);
+    const uint32_t getConfigurationRegister(ConfigurationRegister registerID);
+    const uint32_t getConfigurationPage(ConfigurationRegister registerID);
+    const uint32_t getUniqueIdRegister(UniqueIDRegister registerID);
+    const uint32_t getHarmonicRegister(HarmonicRegister registerID);
+    const uint32_t getHarmonicPage(HarmonicRegister registerID);
+    const uint32_t getUniqueIdPage(UniqueIDRegister registerID);
+    const uint32_t getSensorRegister(SensorRegister registerID);
+    const uint32_t getSensorPage(SensorRegister registerID);
+
+    void connectADMT();
+    void disconnectADMT();
+    int getChannelIndex(const char *deviceName, const char *channelName);
+    double getChannelValue(const char *deviceName, const char *channelName, int bufferSize = 1);
+    int getDeviceAttributeValue(const char *deviceName, const char *attributeName, double *returnValue);
+    int getDeviceAttributeValueString(const char *deviceName, const char *attributeName, char *returnValue, size_t byteLength = 512);
+    int setDeviceAttributeValue(const char *deviceName, const char *attributeName, double writeValue);
+    QString calibrate(vector<double> PANG, int cycles = 11, int samplesPerCycle = 256);
+    int writeDeviceRegistry(const char *deviceName, uint32_t address, uint32_t value);
+    int readDeviceRegistry(const char *deviceName, uint32_t address, uint32_t *returnValue);
+    void computeSineCosineOfAngles(const vector<double>& angles);
+    uint16_t calculateHarmonicCoefficientMagnitude(uint16_t harmonicCoefficient, uint16_t originalValue, const string& key);
+    uint16_t calculateHarmonicCoefficientPhase(uint16_t harmonicPhase, uint16_t originalValue);
+    double getActualHarmonicRegisterValue(uint16_t registerValue, const string key);
+    map<string, bool> getFaultRegisterBitMapping(uint16_t registerValue);
+    map<string, int> getGeneralRegisterBitMapping(uint16_t registerValue);
+    map<string, bool> getDIGIOENRegisterBitMapping(uint16_t registerValue);
+    map<string, bool> getDIGIORegisterBitMapping(uint16_t registerValue);
+    map<string, bool> getDiag1RegisterBitMapping_Register(uint16_t registerValue);
+    map<string, double> getDiag1RegisterBitMapping_Afe(uint16_t registerValue, bool is5V);
+    map<string, double> getDiag2RegisterBitMapping(uint16_t registerValue);
+    uint16_t setGeneralRegisterBitMapping(uint16_t currentRegisterValue, map<string, int> settings);
+    void postcalibrate(vector<double> PANG, int cycleCount, int samplesPerCycle);
+    int getAbsAngleTurnCount(uint16_t registerValue);
+    uint16_t setDIGIOENRegisterBitMapping(uint16_t currentRegisterValue, map<string, bool> settings);
+    uint16_t setDIGIORegisterBitMapping(uint16_t currentRegisterValue, map<string, bool> settings);
+    void unwrapAngles(vector<double>& angles_rad); 
+    map<string, string> getUNIQID3RegisterMapping(uint16_t registerValue);
+    map<string, double> getSineRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getCosineRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getRadiusRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getAngleSecRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getSecAnglQRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getSecAnglIRegisterBitMapping(uint16_t registerValue);
+    map<string, double> getTmp1RegisterBitMapping(uint16_t registerValue, bool is5V);
+    bool checkRegisterFault(uint16_t registerValue, bool isMode1);
+
+private:
+    iio_context *m_iioCtx;
+    iio_buffer *m_iioBuffer;
+    Connection *m_conn;
+    QString uri;
+
+    unsigned int bitReverse(unsigned int x, int log2n);
+    template <typename Iter_T>
+    void fft(Iter_T a, Iter_T b, int log2n);
+    void performFFT(const vector<double>& angle_errors, vector<double>& angle_errors_fft, vector<double>& angle_errors_fft_phase, int cycleCount);
+    int linear_fit(vector<double> x, vector<double> y, double* slope, double* intercept);
+    int calculate_angle_error(vector<double> angle_meas, vector<double>& angle_error_ret, double* max_angle_err);
+    void getPreCalibrationFFT(const vector<double>& PANG, vector<double>& angle_errors_fft_pre, vector<double>& angle_errors_fft_phase_pre, int cycleCount, int samplesPerCycle);
+    void getPostCalibrationFFT(const vector<double>& updated_PANG, vector<double>& angle_errors_fft_post, vector<double>& angle_errors_fft_phase_post, int cycleCount, int samplesPerCycle);
+};
+} // namespace scopy::admt
+
+#endif // ADMTCONTROLLER_H