plugins: Added register map API

Signed-off-by: Alexandru Lie <[email protected]>

plugins/regmap/include/regmap/regmapplugin.h

@@ -24,9 +24,11 @@ namespace regmap {
 
 class RegisterMapTool;
 class JsonFormatedElement;
+class RegMap_API;
 
 class SCOPY_REGMAP_EXPORT RegmapPlugin : public QObject, public PluginBase
 {
+	friend class RegMap_API;
 	Q_OBJECT
 	SCOPY_PLUGIN;
 
@@ -59,6 +61,8 @@ public Q_SLOTS:
 	struct iio_device *getIioDevice(iio_context *ctx, const char *dev_name);
 	bool isBufferCapable(iio_device *dev);
 	RegisterMapTool *registerMapTool;
+	void InitApi();
+	RegMap_API *api;
 };
 } // namespace regmap
 } // namespace scopy

plugins/regmap/src/deviceregistermap.cpp

@@ -220,6 +220,8 @@ bool DeviceRegisterMap::hasTemplate()
 	return false;
 }
 
+bool DeviceRegisterMap::getAutoread() { return autoread; }
+
 void DeviceRegisterMap::initSettings()
 {
 	QObject::connect(this, &DeviceRegisterMap::requestRead, registerMapValues, &RegisterMapValues::requestRead);

plugins/regmap/src/deviceregistermap.hpp

@@ -24,6 +24,7 @@ class RegisterMapTable;
 
 class SCOPY_REGMAP_EXPORT DeviceRegisterMap : public QWidget
 {
+	friend class RegMap_API;
 	Q_OBJECT
 public:
 	explicit DeviceRegisterMap(RegisterMapTemplate *registerMapTemplate = nullptr,
@@ -34,6 +35,7 @@ class SCOPY_REGMAP_EXPORT DeviceRegisterMap : public QWidget
 	void toggleAutoread(bool toggled);
 	void applyFilters(QString filter);
 	bool hasTemplate();
+	bool getAutoread();
 
 private:
 	ToolTemplate *tool;

plugins/regmap/src/recyclerview/registermaptable.hpp

@@ -13,6 +13,7 @@ class RecyclerView;
 
 class RegisterMapTable : public IRecyclerViewAdapter
 {
+	friend class RegMap_API;
 	Q_OBJECT
 public:
 	RegisterMapTable(QMap<uint32_t, RegisterModel *> *registerModels, QWidget *parent);

plugins/regmap/src/registermapsettingsmenu.hpp

@@ -15,7 +15,7 @@ namespace regmap {
 class RegisterMapSettingsMenu : public QWidget
 {
 	friend class RegmapStyleHelper;
-
+	friend class RegMap_API;
 	Q_OBJECT
 
 public:

plugins/regmap/src/registermaptool.hpp

@@ -23,6 +23,7 @@ class SearchBarWidget;
 
 class SCOPY_REGMAP_EXPORT RegisterMapTool : public QWidget
 {
+	friend class RegMap_API;
 	Q_OBJECT
 public:
 	explicit RegisterMapTool(QWidget *parent = nullptr);

plugins/regmap/src/regmap_api.cpp

@@ -0,0 +1,161 @@
+#include "regmap_api.h"
+
+using namespace scopy::regmap;
+
+Q_LOGGING_CATEGORY(CAT_REGMAP_API, "RegMap_API")
+
+RegMap_API::RegMap_API(RegmapPlugin *regMapPlugin)
+	: ApiObject()
+	, m_regMapPlugin(regMapPlugin)
+{}
+
+RegMap_API::~RegMap_API() {}
+
+void RegMap_API::write(QString addr, QString val)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	Q_EMIT devRegMap->registerMapValues->requestWrite(addr.toUInt(nullptr, 16), val.toUInt(nullptr, 16));
+}
+
+QStringList RegMap_API::getAvailableDevicesName()
+{
+	QStringList devicesName;
+	auto devices = m_regMapPlugin->registerMapTool->deviceList;
+	return devices->keys();
+}
+
+bool RegMap_API::setDevice(QString device)
+{
+	m_regMapPlugin->registerMapTool->updateActiveRegisterMap(device);
+	QString currentRegMap = m_regMapPlugin->registerMapTool->activeRegisterMap;
+	if(currentRegMap == device) {
+		return true;
+	}
+	qWarning(CAT_REGMAP_API) << "Device " << device << " was not set";
+	return false;
+}
+
+QList<uint32_t> RegMap_API::search(QString searchParam)
+{
+	QList<uint32_t> resultIndexes;
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	resultIndexes = Search::searchForRegisters(devRegMap->registerMapTemplate->getRegisterList(), searchParam);
+	return resultIndexes;
+}
+
+void RegMap_API::readInterval(QString startAddr, QString stopAddr)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	uint32_t start = Utils::convertQStringToUint32(startAddr);
+	uint32_t stop = Utils::convertQStringToUint32(stopAddr);
+	for(int i = start; i <= stop; i++) {
+		Q_EMIT devRegMap->requestRead(i);
+	}
+}
+
+bool RegMap_API::enableAutoread(bool enable)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	devRegMap->toggleAutoread(enable);
+	if(devRegMap->getAutoread() == enable) {
+		return true;
+	}
+	qWarning(CAT_REGMAP_API) << "Autoread was not changed to " << enable;
+	return false;
+}
+
+bool RegMap_API::isAutoreadEnabled()
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	return devRegMap->getAutoread();
+}
+
+void RegMap_API::registerDump(QString filePath)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	Q_EMIT devRegMap->registerMapValues->registerDump(filePath);
+}
+
+void RegMap_API::setPath(QString filePath) { m_regMapPlugin->registerMapTool->settings->filePath->setText(filePath); }
+
+void RegMap_API::writeFromFile(QString filePath)
+{
+	setPath(filePath);
+	Q_EMIT m_regMapPlugin->registerMapTool->settings->writeListOfValuesButton->clicked();
+}
+
+void RegMap_API::readRegister(QString addr)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	Q_EMIT devRegMap->requestRead(Utils::convertQStringToUint32(addr));
+}
+
+QString RegMap_API::getValueOfRegister(QString addr)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	uint32_t address = Utils::convertQStringToUint32(addr);
+	QMap<uint32_t, uint32_t> *values = devRegMap->registerMapValues->getRegisterReadValues();
+	if(values->keys().contains(address)) {
+		return Utils::convertToHexa(values->value(address), 16);
+	}
+	qWarning(CAT_REGMAP_API) << "Value not read";
+	return "";
+}
+
+DeviceRegisterMap *RegMap_API::getActiveDevRegMap()
+{
+	return m_regMapPlugin->registerMapTool->deviceList->value(m_regMapPlugin->registerMapTool->activeRegisterMap);
+}
+
+QStringList RegMap_API::getRegisterInfo(QString addr)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	QStringList regInfo;
+	RegisterModel *regModel =
+		devRegMap->registerMapTableWidget->registerModels->value(Utils::convertQStringToUint32(addr));
+	if(regModel != nullptr) {
+		regInfo.append("Name:" + regModel->getName());
+		regInfo.append("Address:" + Utils::convertToHexa(regModel->getAddress(), 16));
+		regInfo.append("Description:" + regModel->getDescription());
+		regInfo.append("Notes:" + regModel->getNotes());
+	}
+	return regInfo;
+}
+
+QStringList RegMap_API::getRegisterBitFieldsInfo(QString addr)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	QStringList bitFieldsDetails;
+	RegisterModel *regModel =
+		devRegMap->registerMapTableWidget->registerModels->value(Utils::convertQStringToUint32(addr));
+	QVector<BitFieldModel *> *bitField = regModel->getBitFields();
+
+	for(BitFieldModel *bf : *bitField) {
+		bitFieldsDetails.append("Name:" + bf->getName());
+		bitFieldsDetails.append("Description:" + bf->getDescription());
+		bitFieldsDetails.append("Notes:" + bf->getNotes());
+		bitFieldsDetails.append("Default value:" + Utils::convertToHexa(bf->getDefaultValue(), 16));
+		bitFieldsDetails.append(";");
+	}
+	return bitFieldsDetails;
+}
+
+QStringList RegMap_API::getBitFieldInfo(QString addr, QString bitName)
+{
+	DeviceRegisterMap *devRegMap = getActiveDevRegMap();
+	QStringList bitDetails;
+	RegisterModel *regModel =
+		devRegMap->registerMapTableWidget->registerModels->value(Utils::convertQStringToUint32(addr));
+	QVector<BitFieldModel *> *bitField = regModel->getBitFields();
+
+	for(BitFieldModel *bf : *bitField) {
+		if(bf->getName() == bitName) {
+			bitDetails.append("Name:" + bf->getName());
+			bitDetails.append("Description:" + bf->getDescription());
+			bitDetails.append("Notes:" + bf->getNotes());
+			bitDetails.append("Default value:" + Utils::convertToHexa(bf->getDefaultValue(), 16));
+			break;
+		}
+	}
+	return bitDetails;
+}

plugins/regmap/src/regmap_api.h

@@ -0,0 +1,51 @@
+#ifndef REGMAP_API_H
+#define REGMAP_API_H
+
+#include "scopy-regmap_export.h"
+
+#include <regmapplugin.h>
+#include <deviceregistermap.hpp>
+#include <registermaptool.hpp>
+#include <register/registermodel.hpp>
+#include <registermapvalues.hpp>
+#include <recyclerview/registermaptable.hpp>
+#include <utils.hpp>
+#include <register/bitfield/bitfieldmodel.hpp>
+#include <readwrite/fileregisterreadstrategy.hpp>
+#include <registermapsettingsmenu.hpp>
+#include <qlineedit.h>
+#include "search.hpp"
+
+namespace scopy::regmap {
+
+class SCOPY_REGMAP_EXPORT RegMap_API : public ApiObject
+{
+
+	Q_OBJECT
+
+public:
+	explicit RegMap_API(RegmapPlugin *regMapPlugin);
+	~RegMap_API();
+
+	Q_INVOKABLE void write(QString addr, QString val);
+	Q_INVOKABLE QStringList getAvailableDevicesName();
+	Q_INVOKABLE bool setDevice(QString device);
+	Q_INVOKABLE QList<uint32_t> search(QString searchParam);
+	Q_INVOKABLE void readInterval(QString startAddr, QString stopAddr);
+	Q_INVOKABLE bool enableAutoread(bool enable);
+	Q_INVOKABLE bool isAutoreadEnabled();
+	Q_INVOKABLE void registerDump(QString filePath);
+	Q_INVOKABLE void setPath(QString filePath);
+	Q_INVOKABLE void writeFromFile(QString filePath);
+	Q_INVOKABLE void readRegister(QString addr);
+	Q_INVOKABLE QString getValueOfRegister(QString addr);
+	Q_INVOKABLE QStringList getRegisterInfo(QString addr);
+	Q_INVOKABLE QStringList getRegisterBitFieldsInfo(QString addr);
+	Q_INVOKABLE QStringList getBitFieldInfo(QString addr, QString bitName);
+
+private:
+	RegmapPlugin *m_regMapPlugin;
+	DeviceRegisterMap *getActiveDevRegMap();
+};
+} // namespace scopy::regmap
+#endif // REGMAP_API_H

plugins/regmap/src/regmapplugin.cpp

@@ -27,12 +27,14 @@
 #include <readwrite/fileregisterreadstrategy.hpp>
 #include <readwrite/fileregisterwritestrategy.hpp>
 #include "logging_categories.h"
+#include <regmap_api.h>
 
 #include "iioutil/connectionprovider.h"
 #include "jsonformatedelement.hpp"
 #include "scopy-regmap_config.h"
 #include "utils.hpp"
 #include "utils.hpp"
+#include <pluginbase/scopyjs.h>
 #if defined __APPLE__
 #include <QApplication>
 #endif
@@ -185,6 +187,7 @@ bool RegmapPlugin::onConnect()
 
 		m_toolList[0]->setEnabled(true);
 		m_toolList[0]->setTool(m_registerMapWidget);
+		InitApi();
 
 		return true;
 	}
@@ -275,4 +278,11 @@ bool RegmapPlugin::isBufferCapable(iio_device *dev)
 	return false;
 }
 
+void RegmapPlugin::InitApi()
+{
+	api = new RegMap_API(this);
+	ScopyJS *js = ScopyJS::GetInstance();
+	api->setObjectName("regmap");
+	js->registerApi(api);
+}
 #include "moc_regmapplugin.cpp"

tests/CMakeLists.txt

@@ -23,4 +23,12 @@ if(ENABLE_AUTOMATED_TESTS)
 		)
 	endif()
 
+	# REGMAP
+	if(ENABLE_PLUGIN_REGMAP)
+		add_test(NAME "RegMapJSTests"
+			 COMMAND bash ${CMAKE_SOURCE_DIR}/js/test.sh "${CMAKE_SOURCE_DIR}/resources/emuXml/"
+				 "${CMAKE_SOURCE_DIR}/plugins/regmap/js/regMapFunctions.js"
+		)
+	endif()
+
 endif()