diff --git a/livemap.pro b/livemap.pro
index adafd8b..b769c80 100644
--- a/livemap.pro
+++ b/livemap.pro
@@ -67,7 +67,7 @@ SOURCES += src/main.cpp\
     src/DMA-proto/jcsbanksDMA.cpp \
     src/DMA-proto/stockDMA.cpp \
     src/comm-device-interface/op20.cpp \
-    src/ecuManager.cpp \
+    src/widgets/ecuManager.cpp \
     src/wideband/op20wb.cpp \
     src/DMA-proto/pollhelper.cpp \
     src/deviceNativeFilter.cpp \
@@ -104,7 +104,7 @@ HEADERS  += src/mainwindow.h \
     src/DMA-proto/proto-manager.h \
     src/abstract-memory.h \
     src/comm-device-interface/devicemanager.h \
-    src/ecuManager.h \
+    src/widgets/ecuManager.h \
     src/wideband/op20wb.h \
     src/DMA-proto/pollhelper.h \
     src/DMA-proto/evoX-DMA.h \
diff --git a/src/DMA-proto/DMA-proto.cpp b/src/DMA-proto/DMA-proto.cpp
index d5fc29b..fb1acbe 100644
--- a/src/DMA-proto/DMA-proto.cpp
+++ b/src/DMA-proto/DMA-proto.cpp
@@ -10,17 +10,6 @@ DMA_proto::~DMA_proto()
 //    qDebug() << "~ECU_interface";
 }
 
-bool DMA_proto::getECU(QString romID)
-{
-    if (!_ecu_definition.fromFile(_ecu_definition.SearchFiles(QApplication::applicationDirPath() + "/xml/", romID)))
-    {
-        //delete _ecu_definition;
-        qDebug() << "XML NOT FOUND!!!!!!!!!!!!!!!!!!!!!!!!!";
-        return false;
-    }
-    return true;
-}
-
 void DMA_proto::directDMAwrite(abstractMemoryScaled memory)
 {
     qDebug()<< "DMA_proto::directDMAwrite" << memory.toHex(':');
diff --git a/src/DMA-proto/DMA-proto.h b/src/DMA-proto/DMA-proto.h
index 4820f99..e291bf6 100644
--- a/src/DMA-proto/DMA-proto.h
+++ b/src/DMA-proto/DMA-proto.h
@@ -1,5 +1,5 @@
-#ifndef ECU_INTERFACE_H
-#define ECU_INTERFACE_H
+#ifndef DMAPROTO_H
+#define DMAPROTO_H
 
 #include <QApplication>
 #include <QObject>
@@ -9,7 +9,7 @@
 #include <QtEndian>
 #include <QElapsedTimer>
 
-#include <src/ecu/ecu-definition.h>
+#include "../abstract-memory.h"
 
 #include "../comm-device-interface/comm-device-interface.h"
 
@@ -29,14 +29,14 @@ class DMA_proto : public pollHelper
     Q_OBJECT
 public:
     comm_device_interface **devComm = nullptr;
-    ecu_definition _ecu_definition;
+    QVector<mutParam> RAM_MUT;
+    quint32 RAM_MUT_addr;
 
     DMA_proto();
     //explicit DMA_proto(comm_device_interface **devComm = nullptr);
     virtual ~DMA_proto();
 
     void setCommDev(comm_device_interface **devComm = nullptr);
-    bool getECU(QString romID);
 
     virtual bool connect() = 0;
 
@@ -50,9 +50,10 @@ public slots:
     virtual void startLog() = 0;
     virtual void stopLog() = 0;
 
-private slots:
     virtual void poll() = 0;
 
+private slots:
+
 private:
 
     //Protocol protocol;
@@ -64,4 +65,4 @@ private slots:
 
 };
 
-#endif // ECU_INTERFACE_H
+#endif // DMAPROTO_H
diff --git a/src/DMA-proto/jcsbanksDMA.cpp b/src/DMA-proto/jcsbanksDMA.cpp
index 91d7a8d..ce99117 100644
--- a/src/DMA-proto/jcsbanksDMA.cpp
+++ b/src/DMA-proto/jcsbanksDMA.cpp
@@ -66,13 +66,13 @@ void jcsbanksDMA::startLog()
 {
     qDebug()<<"=========== jcsbanksDMA::startLog ================";
 
-    for( int i = 0; i < _ecu_definition.RAM_MUT.size() ; ++i  )
+    for( int i = 0; i < RAM_MUT.size() ; ++i  )
     {
-        _ecu_definition.RAM_MUT[i].offset = readSize;
-        readSize += _ecu_definition.RAM_MUT[i].scaling.getElementSize();
+        RAM_MUT[i].offset = readSize;
+        readSize += RAM_MUT[i].scaling.getElementSize();
         //qDebug() << "dataLogger::start" << (*_ecu_definition)->RAM_MUT[i].scaling.name << (*_ecu_definition)->RAM_MUT[i].scaling.getElementSize();
     }
-    scaledRAM_MUTvalue.resize(_ecu_definition.RAM_MUT.size());
+    scaledRAM_MUTvalue.resize(RAM_MUT.size());
 
     pollTimer->start();
 
@@ -88,12 +88,12 @@ void jcsbanksDMA::stopLog()
 void jcsbanksDMA::poll()
 {
     //qDebug() << "jcsbanksDMA::poll" ;
-    abstractMemoryScaled a = indirectDMAread(_ecu_definition.RAM_MUT_addr, readSize);
+    abstractMemoryScaled a = indirectDMAread(RAM_MUT_addr, readSize);
     //a[0] = abs(QCursor::pos().x())/10;
     //a[1] = abs(QCursor::pos().y())/6;
-    for( int i = 0; i < _ecu_definition.RAM_MUT.size() ; i++  )
+    for( int i = 0; i < RAM_MUT.size() ; i++  )
     {
-        scaledRAM_MUTvalue[i] = a.toFloatOffset( &_ecu_definition.RAM_MUT[i].scaling, _ecu_definition.RAM_MUT[i].offset );
+        scaledRAM_MUTvalue[i] = a.toFloatOffset( &RAM_MUT[i].scaling, RAM_MUT[i].offset );
     }
     emit logReady(scaledRAM_MUTvalue);
 }
diff --git a/src/DMA-proto/pollhelper.cpp b/src/DMA-proto/pollhelper.cpp
index 1d689a1..11a8c97 100644
--- a/src/DMA-proto/pollhelper.cpp
+++ b/src/DMA-proto/pollhelper.cpp
@@ -2,18 +2,18 @@
 
 pollHelper::pollHelper() //: QObject(parent)
 {
-    QThread *this_thread = new QThread();
-    QObject::connect(this_thread, &QThread::started, this, [this](){
-        pollTimer = new QTimer(this);
-        pollTimer->setInterval(50);
-        QObject::connect(pollTimer, &QTimer::timeout, this, &pollHelper::poll);
-    }
-    );
-    //    //connect(this_thread, &QThread::started, this, &controller::loop, Qt::QueuedConnection);
-    QObject::connect(this, &QObject::destroyed, this_thread, &QThread::quit);            // Когда удалим объект остановим поток
-    QObject::connect(this_thread, &QThread::finished, this_thread, &QThread::deleteLater);  // Когда остановим поток удалим его
-    moveToThread(this_thread);
-    this_thread->start();
+//    QThread *this_thread = new QThread();
+//    QObject::connect(this_thread, &QThread::started, this, [this](){
+//        pollTimer = new QTimer(this);
+//        pollTimer->setInterval(50);
+//        QObject::connect(pollTimer, &QTimer::timeout, this, &pollHelper::poll);
+//    }
+//    );
+//    //    //connect(this_thread, &QThread::started, this, &controller::loop, Qt::QueuedConnection);
+//    QObject::connect(this, &QObject::destroyed, this_thread, &QThread::quit);            // Когда удалим объект остановим поток
+//    QObject::connect(this_thread, &QThread::finished, this_thread, &QThread::deleteLater);  // Когда остановим поток удалим его
+//    moveToThread(this_thread);
+//    this_thread->start();
 }
 
 //void pollHelper::startLog()
diff --git a/src/DMA-proto/pollhelper.h b/src/DMA-proto/pollhelper.h
index dde4fa7..ebf9b99 100644
--- a/src/DMA-proto/pollhelper.h
+++ b/src/DMA-proto/pollhelper.h
@@ -23,10 +23,11 @@ public slots:
     virtual void startLog() = 0;
     virtual void stopLog() = 0;
 
+    virtual void poll() = 0;
+
 private:
 
 private slots:
-    virtual void poll() = 0;
 
 signals:
     void logReady(QVector<float>);
diff --git a/src/ecu/ecu-definition.cpp b/src/ecu/ecu-definition.cpp
index b4c6352..e964b22 100644
--- a/src/ecu/ecu-definition.cpp
+++ b/src/ecu/ecu-definition.cpp
@@ -1,15 +1,28 @@
 #include "ecu-definition.h"
 
-ecu_definition::ecu_definition(){}
+ecuDefinition::ecuDefinition()
+{
+    QThread *this_thread = new QThread();
+    QObject::connect(this_thread, &QThread::started, this, [this](){
+        pollTimer = new QTimer(this);
+        pollTimer->setInterval(50);
+    }
+    );
+    //    //connect(this_thread, &QThread::started, this, &controller::loop, Qt::QueuedConnection);
+    QObject::connect(this, &QObject::destroyed, this_thread, &QThread::quit);            // Когда удалим объект остановим поток
+    QObject::connect(this_thread, &QThread::finished, this_thread, &QThread::deleteLater);  // Когда остановим поток удалим его
+    moveToThread(this_thread);
+    this_thread->start();
+}
 
-ecu_definition::~ecu_definition(){
+ecuDefinition::~ecuDefinition(){
     for(auto c : qAsConst(RAMtables))
     {
         delete c;
     }
 }
 
-bool ecu_definition::fromFile(QString filename)
+bool ecuDefinition::fromFile(QString filename)
 {
     // Открываем конфиг:
     QFile* file = new QFile(filename);
@@ -20,7 +33,12 @@ bool ecu_definition::fromFile(QString filename)
     return true;
 }
 
-QString ecu_definition::SearchFiles(QString path, QString CalID)       // Для поиска файлов в каталоге
+bool ecuDefinition::fromROMID(QString ROMID)
+{
+    return fromFile(getFile(QApplication::applicationDirPath() + "/xml/", ROMID));
+}
+
+QString ecuDefinition::getFile(QString path, QString CalID)       // Для поиска файлов в каталоге
 {
     // Пытаемся найти правильные файлы, в текущем каталоге
     QStringList listFiles = QDir(path).entryList((CalID + "*.xml ").split(" "), QDir::Files);  //выборка файлов по маскам
@@ -31,7 +49,134 @@ QString ecu_definition::SearchFiles(QString path, QString CalID)       // Для
         return path + listFiles.at(0);
 }
 
-void ecu_definition::_parser(QIODevice *device)
+void ecuDefinition::setComDev(comm_device_interface *_devComm)
+{
+    devComm = _devComm;
+
+    if (devComm == nullptr  )
+    {
+        // все интерфесы отключены, сделай что нибудь!!!!
+        pollTimer->stop();
+    }
+    else
+        ECUproto->setCommDev(&devComm);
+}
+
+void ecuDefinition::setDMAproto(DMA_proto *_ECUproto)
+{
+    ECUproto = _ECUproto;
+    _ECUproto->setCommDev(&devComm);
+    connect(pollTimer, &QTimer::timeout, this, &ecuDefinition::poll);
+}
+
+bool ecuDefinition::connectECU()
+{
+    qDebug() << "=========== ecuDefinition::connectECU ================" << devComm;
+    if (!ECUproto->connect())
+    {
+        emit Log("failure get ECU connect " + QString::number( devComm->getBaudRate()));
+        return false;
+    }
+    QByteArray a = ECUproto->directDMAread( 0xF52, 4);                        //читаем номер калибровки
+    if ( a.isEmpty() )
+    {
+        emit Log("failure get ECU rom id");
+        return false;
+    }
+    QString romID = QString::number( qFromBigEndian<quint32>(a.data()), 16 );
+    emit Log("romID: " + romID);
+    //emit Log("CurrDir: " + QApplication::applicationDirPath());
+    //===================================================================================================
+    if (!fromROMID(romID))
+    {
+        (*ECUproto->devComm)->close();
+        qDebug() << "XML NOT FOUND!!!!!!!!!!!!!!!!!!!!!!!!!";
+        emit Log("xml not found");
+        return false;
+    }
+    ECUproto->RAM_MUT = RAM_MUT;
+    ECUproto->RAM_MUT_addr = RAM_MUT_addr;
+    //==================================================================================================
+    emit ecu_connected();
+    // переберем все описания таблиц
+    for ( Map *tab : qAsConst(RAMtables) )
+    {
+        emit create_table( getMap(tab) );
+    }
+    startLog();
+    return true;
+}
+
+void ecuDefinition::disConnectECU()
+{
+    qDebug() << "=========== ecuDefinition::disConnectECU ================";
+    pollTimer->stop();
+    QThread::msleep(1000);               // костыль
+    devComm->close();
+}
+
+void ecuDefinition::RAMreset()
+{
+    qDebug() << "ecuManager::RAMreset(addr::" << DEAD_var << ");";
+    quint16 r = 0x0000;
+    abstractMemoryScaled a = abstractMemoryScaled(QByteArray((char*)&r, 2));
+    a.addr = DEAD_var;
+    QMetaObject::invokeMethod(ECUproto, "directDMAwrite", Qt::QueuedConnection,
+                              Q_ARG(abstractMemoryScaled, a));
+    //ECUproto->directDMAwrite(_ecu_definition->DEAD_var, (char*)&r, 2);
+}
+
+void ecuDefinition::updateRAM(abstractMemoryScaled memory)
+{
+    qDebug()<< "ecuManager::updateRAM" << memory.toHex(':');
+    QMetaObject::invokeMethod(ECUproto, "directDMAwrite", Qt::QueuedConnection,
+                              Q_ARG(abstractMemoryScaled, memory));
+    //    ECUproto->directDMAwrite(memory);
+}
+
+mapDefinition *ecuDefinition::getMap(Map *declMap)
+{
+    //qDebug()<<"ECU_interface::getMap"<<declMap->Name;
+    //if(declMap->rom_scaling._storagetype == Storagetype::undef || declMap->rom_scaling._storagetype == Storagetype::bloblist)
+    //    return &mapDefinition();
+    mapDefinition *defMap = new mapDefinition;
+    defMap->declMap = declMap;
+    if(declMap->X_axis.addr != 0)
+        defMap->X_axis = ECUproto->directDMAread(declMap->X_axis.addr, declMap->X_axis.byteSize());   // читаем оси
+    if(declMap->Y_axis.addr != 0)
+        defMap->Y_axis = ECUproto->directDMAread(declMap->Y_axis.addr, declMap->Y_axis.byteSize());
+    defMap->Map = ECUproto->directDMAread(declMap->addr, declMap->byteSize());
+    //emit gettedMap(defMap);
+    return defMap;
+}
+
+void ecuDefinition::startLog()
+{
+    qDebug()<<"=========== ecuDefinition::startLog ================";
+    for( int i = 0; i < RAM_MUT.size() ; ++i  )
+    {
+        RAM_MUT[i].offset = readSize;
+        readSize += RAM_MUT[i].scaling.getElementSize();
+        //qDebug() << "dataLogger::start" << (*_ecu_definition)->RAM_MUT[i].scaling.name << (*_ecu_definition)->RAM_MUT[i].scaling.getElementSize();
+    }
+    scaledRAM_MUTvalue.resize(RAM_MUT.size());
+    pollTimer->start();
+}
+
+void ecuDefinition::poll()
+{
+    //qDebug() << "jcsbanksDMA::poll" ;
+    abstractMemoryScaled a = ECUproto->indirectDMAread(RAM_MUT_addr, readSize);
+    //a[0] = abs(QCursor::pos().x())/10;
+    //a[1] = abs(QCursor::pos().y())/6;
+    for( int i = 0; i < RAM_MUT.size() ; i++  )
+    {
+        scaledRAM_MUTvalue[i] = a.toFloatOffset( &RAM_MUT[i].scaling, RAM_MUT[i].offset );
+    }
+    emit logReady(scaledRAM_MUTvalue);
+}
+
+void ecuDefinition::_parser(QIODevice *device)
 {
     QString errorStr;
     int errorLine;
@@ -78,7 +223,7 @@ void ecu_definition::_parser(QIODevice *device)
 
 }
 
-void ecu_definition::getMUTparam(const QDomElement &element)
+void ecuDefinition::getMUTparam(const QDomElement &element)
 {
     QDomNode node = element.firstChild();
     while (!node.isNull())
@@ -90,22 +235,21 @@ void ecu_definition::getMUTparam(const QDomElement &element)
             _mut_param.scaling = scaling_qmap.value(el.attribute("scaling"));
 
             _mut_param.number = el.attribute("number").toInt(nullptr, 16);
-            ++RAM_MUT_count;
+            //++RAM_MUT_count;
             RAM_MUT.insert(_mut_param.number, _mut_param );
         }
         node = node.nextSibling();
     }
 }
 
-
-void ecu_definition::getLivemap(const QDomElement &element)
+void ecuDefinition::getLivemap(const QDomElement &element)
 {
     Map *mainTableDeclaration = new Map;
     mainTableDeclaration->fromXML(element);
     RAMtables.insert(mainTableDeclaration->Name, mainTableDeclaration);
 }
 
-void ecu_definition::getScaling(const QDomElement &el)
+void ecuDefinition::getScaling(const QDomElement &el)
 {
     Scaling sc(el);
     scaling_qmap.insert(sc.name, sc);
diff --git a/src/ecu/ecu-definition.h b/src/ecu/ecu-definition.h
index d5b7e94..a1c2f06 100644
--- a/src/ecu/ecu-definition.h
+++ b/src/ecu/ecu-definition.h
@@ -1,25 +1,21 @@
 #ifndef ECU_DEFINITION_H
 #define ECU_DEFINITION_H
 
+#include <QDebug>
+#include <QApplication>
 #include <QFile>
 #include <QFileDialog>
-
-#include <QtXml/QDomDocument>
-#include <src/abstract-memory.h>
-
 #include <QtEndian>
 #include <QList>
 #include <QStack>
 #include <QChar>
 #include <QMap>
-#include <QDebug>
-
-
+#include <QtXml/QDomDocument>
 
-#include <math.h>
 #include "../types.h"
 #include "../map-decl/map.h"
-
+#include "../abstract-memory.h"
+#include "../DMA-proto/DMA-proto.h"
 
 typedef struct                                       // Содержимое таблицы
 {
@@ -29,24 +25,51 @@ typedef struct                                       // Содержимое т
     abstractMemoryScaled Y_axis;
 } mapDefinition;
 
-class ecu_definition
+class ecuDefinition : public QObject
 {
+    Q_OBJECT
 public:
+    comm_device_interface *devComm = nullptr;
+    DMA_proto *ECUproto = nullptr;
+
     quint32 DEAD_var;
     quint32 RAM_MUT_addr;
     QVector<mutParam> RAM_MUT;
-    quint32 RAM_MUT_count = 0;
 
     QHash<QString, Map*> RAMtables;
 
-    ecu_definition();
-    ~ecu_definition();
-public:
+    ecuDefinition();
+    ~ecuDefinition();
+
     bool fromFile(QString filename);
-    //bool fromROMID(QString ROMID);
-    QString SearchFiles(QString path, QString CalID);
+    bool fromROMID(QString ROMID);
+    QString getFile(QString path, QString CalID);
+
+public slots:
+    void setComDev(comm_device_interface *_devComm);
+    void setDMAproto(DMA_proto *_ECUproto);
+
+    bool connectECU();
+
+    void disConnectECU();
+
+    void RAMreset();
+
+    void updateRAM(abstractMemoryScaled memory);
+
+    mapDefinition *getMap(Map *declMap);
+
+    virtual void startLog();
+    //virtual void stopLog();
+
+private slots:
+    void poll();
 
 private:
+    QVector<float> scaledRAM_MUTvalue;
+    int readSize = 0;
+    QTimer *pollTimer;
+
     QHash<QString, Scaling> scaling_qmap;                     //контейнер скалингов
 
     void _parser(QIODevice *device);
@@ -54,6 +77,16 @@ class ecu_definition
 
     void getLivemap(const QDomElement &element);
     void getScaling(const QDomElement &el);
+
+signals:
+    void ecu_connected();
+    void disConnectECUaction();
+    void create_table(mapDefinition*);
+
+    void Log(QString);
+
+    void logReady(QVector<float>);
+
 };
 
 #endif // ECU_DEFINITION_H
diff --git a/src/logger.cpp b/src/logger.cpp
index 5a4aae6..0e0f035 100644
--- a/src/logger.cpp
+++ b/src/logger.cpp
@@ -1,7 +1,7 @@
 #include "logger.h"
 #include <QCursor>
 
-dataLogger::dataLogger(ecu_definition **_ecu, comm_device_interface **devComm, DMA_proto **ECUproto):_ecu_definition(_ecu), ECUproto(ECUproto), devComm(devComm)
+dataLogger::dataLogger(ecuDefinition **_ecu, comm_device_interface **devComm, DMA_proto **ECUproto):_ecu_definition(_ecu), ECUproto(ECUproto), devComm(devComm)
 {
     //QString filename = startDate.toString("'log_'dd_MM_yyyy'.txt'");
 
@@ -20,7 +20,7 @@ dataLogger::~dataLogger()
     log_file.close();
 }
 
-void dataLogger::setECU(ecu_definition **_ecu)
+void dataLogger::setECU(ecuDefinition **_ecu)
 {
     this->_ecu_definition = _ecu;
     scaledRAM_MUTvalue.fill(0, (*_ecu_definition)->RAM_MUT.size());
diff --git a/src/logger.h b/src/logger.h
index 67db052..beda2b3 100644
--- a/src/logger.h
+++ b/src/logger.h
@@ -18,15 +18,15 @@ class dataLogger:public QObject
 {
     Q_OBJECT
 public:
-    ecu_definition **_ecu_definition;
+    ecuDefinition **_ecu_definition;
     QMap<int, float> log_param;
     QVector<float> scaledRAM_MUTvalue;
     DMA_proto **ECUproto;
 
-    dataLogger(ecu_definition **_ecu = nullptr, comm_device_interface **devComm = nullptr, DMA_proto **ECUproto = nullptr);
+    dataLogger(ecuDefinition **_ecu = nullptr, comm_device_interface **devComm = nullptr, DMA_proto **ECUproto = nullptr);
     ~dataLogger();
 
-    void setECU(ecu_definition **_ecu);
+    void setECU(ecuDefinition **_ecu);
 
 private:
     comm_device_interface **devComm = nullptr;
diff --git a/src/main.cpp b/src/main.cpp
index a4fdeef..d6dd246 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,23 +1,21 @@
 #include <QApplication>
 #include <QObject>
-//#include <QStatusBar>
+#include <QElapsedTimer>
 
 #include "deviceNativeFilter.h"
 #include "comm-device-interface/devicemanager.h"
-#include "DMA-proto/proto-manager.h"
 #include "mainwindow.h"
-#include "ecuManager.h"
-//#include "wblogger.h"
+
 #include "widgets/commParamWidget.h"
+#include "DMA-proto/proto-manager.h"
 
-#include <QElapsedTimer>
 
 QElapsedTimer t;
 
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
-
+QThread::currentThread()->setPriority(QThread::TimeCriticalPriority);
     app.setApplicationDisplayName(QString("livemap by eulle@ya.ru ver %1").arg(GIT_VERSION));
     qDebug() << QString("Version: %1").arg(GIT_VERSION);
     //========================================================================================
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 6f18c03..e3722b2 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -22,15 +22,14 @@
 
 #include "deviceNativeFilter.h"
 
-#include "ecuManager.h"
-//#include "widgets/maintoolbar.h"
-#include "widgets/gauge_widget.h"
 #include "widgets/commParamWidget.h"
 #include "widgets/mapWidget/mapwidget.h"
 #include "widgets/hexEditor/qhexedit/qhexedit.h"
 #include "widgets/hexEditor/hexeditor.h"
+#include "widgets/gauge_widget.h"
 
 
+#include "widgets/ecuManager.h"
 #include "comm-device-interface/devicemanager.h"
 #include "DMA-proto/proto-manager.h"
 #include "wideband/wb-manager.h"
diff --git a/src/ecuManager.cpp b/src/widgets/ecuManager.cpp
similarity index 56%
rename from src/ecuManager.cpp
rename to src/widgets/ecuManager.cpp
index fd9fb51..622d39f 100644
--- a/src/ecuManager.cpp
+++ b/src/widgets/ecuManager.cpp
@@ -7,11 +7,33 @@ ecuManager::ecuManager(QWidget *parent) : QToolBar(parent)
     qRegisterMetaType<abstractMemoryScaled>("abstractMemoryScaled");
     qRegisterMetaType<QVector<float>>("QVector<float>");
 
-    qRegisterMetaType<char *>("char *");
+    //qRegisterMetaType<char *>("char *");
 
-    setProto(0);
+    connect(&ECUdef, &ecuDefinition::ecu_connected, this, &ecuManager::ecu_connected);
+    connect(&ECUdef, &ecuDefinition::ecu_connected, this, &ecuManager::ecuConnected);
+    connect(&ECUdef, &ecuDefinition::create_table, this, &ecuManager::create_table);
 
-    createUI();
+    connect(&ECUdef, &ecuDefinition::logReady, this, &ecuManager::logReady);
+
+    //setProto(0);
+
+    //=============================================================================
+    a_start_action = addAction( QIcon( ":ico/connect.png" ), "Start", this, &ecuManager::startAction);
+    a_start_action->setDisabled(true);
+    addSeparator();
+    a_ramReset = addAction(QIcon( ":ico/Memory-Freer-icon.png" ), "RAM refresh", &ECUdef, &ecuDefinition::RAMreset);
+    a_ramReset->setDisabled(true);
+    //a_logger = addAction( "Start", this, &MainWindow::logger_slot);
+    //a_logger->setDisabled(true);
+
+    addSeparator();
+    //QWidget* empty = new QWidget(this);
+    //empty->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
+    //addWidget(empty);
+    //debug_action = ui->toolBar->addAction(QIcon( ":ico/screwdriver.png" ), "Debug", this, &MainWindow::debugButton_slot);
+
+    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
+    setIconSize(QSize(200, 200));
 }
 
 ecuManager::~ecuManager()
@@ -29,96 +51,49 @@ ecuManager::~ecuManager()
 
 void ecuManager::setCommDevice(comm_device_interface *dev)
 {
-    qDebug() << "=========== ecuManager::setCommDevice ================" << dev << this->ECUproto;
+    qDebug() << "=========== ecuManager::setCommDevice ================" << dev << ECUproto;
     devComm = dev;
-    //connect((pollHelper*)devComm, &pollHelper::readyRead, this, &ecuManager::poll);
-    this->ECUproto->setCommDev(&devComm);
-    if (devComm != nullptr  )
-    {
-        p_in_buff = devComm->p_in_buff;
-    }
-    else
-    {
-        // все интерфесы отключены, сделай что нибудь!!!!
-
-        //_dataLogger->stop();
-    }
+    ECUproto->setCommDev(&dev);
+    ECUdef.setComDev(dev);
 }
 
 void ecuManager::setProto(DMA_proto *ECUproto)
 {
-    qDebug() << "=========== ecuManager::setProto ================"// << ECUproto
-                ;
+    qDebug() << "=========== ecuManager::setProto ================";
     this->ECUproto = ECUproto;
+    ECUdef.setDMAproto(ECUproto);
     connect(ECUproto, &DMA_proto::logReady, this, &ecuManager::logReady);
-    //this->ECUproto->setCommDev(&devComm);
 }
 
 void ecuManager::setLogRate(uint logRate)
 {
-    _dataLogger->setLogRate(logRate);
+    //_dataLogger->setLogRate(logRate);
 }
 
-void ecuManager::connectECU()
+void ecuManager::ecuConnected()
 {
-    qDebug() << "=========== ecuManager::getECUconnect ================" << devComm;
-    if (!ECUproto->connect())
-    {
-        emit Log("failure get ECU connect " + QString::number( devComm->getBaudRate()));
-        return ;
-    }
-
-    QByteArray a = ECUproto->directDMAread( 0xF52, 4);                        //читаем номер калибровки
-
-    if ( a.isEmpty() )
-    {
-        emit Log("failure get ECU rom id");
-        return;
-    }
-    QString romID = QString::number( qFromBigEndian<quint32>(a.data()), 16 );
-    emit Log("romID: " + romID);
-
-    //emit Log("CurrDir: " + QApplication::applicationDirPath());
-
-    _ecu_definition = new ecu_definition;
-    if (!ECUproto->getECU(romID))
-    {
-        (*ECUproto->devComm)->close();
-        emit Log("xml not found");
-        return;
-    }
-
+    qDebug() << "=========== ecuManager::connectECU ================" << devComm;
     lockReset( false);
-
     a_start_action->setText("Stop");
-
     emit ecu_connected();
-    // переберем все описания таблиц
-    for ( Map *tab : qAsConst(ECUproto->_ecu_definition.RAMtables) )
-    {
-        emit create_table( getMap(tab) );
-    }
-
-    QMetaObject::invokeMethod(ECUproto, "startLog");
 }
 
-void ecuManager::disConnectECU()
-{
-    qDebug() << "=========== ecuManager::disConnectECU ================";
-    QMetaObject::invokeMethod(ECUproto, "stopLog");
-    QThread::msleep(1000);
-    devComm->close();
-}
-
-void ecuManager::RAMreset()
+void ecuManager::startAction()
 {
-    qDebug() << "ecuManager::RAMreset(addr::" << ECUproto->_ecu_definition.DEAD_var << ");";
-    quint16 r = 0x0000;
-    abstractMemoryScaled a = abstractMemoryScaled(QByteArray((char*)&r, 2));
-    a.addr = ECUproto->_ecu_definition.DEAD_var;
-    QMetaObject::invokeMethod(ECUproto, "directDMAwrite", Qt::QueuedConnection,
-                              Q_ARG(abstractMemoryScaled, a));
-    //ECUproto->directDMAwrite(_ecu_definition->DEAD_var, (char*)&r, 2);
+    if (a_start_action->text() == "Start")
+    {
+        qDebug() << "=========== ecuManager::startAction Start";
+        QMetaObject::invokeMethod(&ECUdef, "connectECU");
+        qDebug() << "=========== ecuManager::startAction2 Start";
+    }
+    else
+    {
+        qDebug() << "=========== ecuManager::startAction Stop ================";
+        QMetaObject::invokeMethod(&ECUdef, "disConnectECU");
+        a_start_action->setText("Start");
+        lockReset( true);
+        emit disConnectECUaction();
+    }
 }
 
 mapDefinition *ecuManager::getMap(Map *declMap)
@@ -137,29 +112,12 @@ mapDefinition *ecuManager::getMap(Map *declMap)
     return defMap;
 }
 
-void ecuManager::startAction()
-{
-    if (a_start_action->text() == "Start")
-    {
-        qDebug() << "ecuManager::startButton_slot Start";
-        connectECU();
-    }
-    else
-    {
-        disConnectECU();
-        a_start_action->setText("Start");
-        lockReset( true);
-
-        emit disConnectECUaction();
-    }
-}
-
 void ecuManager::updateRAM(abstractMemoryScaled memory)
 {
     qDebug()<< "ecuManager::updateRAM" << memory.toHex(':');
     QMetaObject::invokeMethod(ECUproto, "directDMAwrite", Qt::QueuedConnection,
                               Q_ARG(abstractMemoryScaled, memory));
-//    ECUproto->directDMAwrite(memory);
+    //    ECUproto->directDMAwrite(memory);
 }
 
 void ecuManager::lockConnect(bool lockFlag)
@@ -175,24 +133,3 @@ void ecuManager::lockReset(bool lockFlag)
 {
     a_ramReset->setDisabled(lockFlag);
 }
-
-void ecuManager::createUI()
-{
-    //=============================================================================
-    a_start_action = addAction( QIcon( ":ico/connect.png" ), "Start", this, &ecuManager::startAction);
-    a_start_action->setDisabled(true);
-    addSeparator();
-    a_ramReset = addAction(QIcon( ":ico/Memory-Freer-icon.png" ), "RAM refresh", this, &ecuManager::RAMreset);
-    a_ramReset->setDisabled(true);
-    //a_logger = addAction( "Start", this, &MainWindow::logger_slot);
-    //a_logger->setDisabled(true);
-
-    addSeparator();
-    //QWidget* empty = new QWidget(this);
-    //empty->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
-    //addWidget(empty);
-    //debug_action = ui->toolBar->addAction(QIcon( ":ico/screwdriver.png" ), "Debug", this, &MainWindow::debugButton_slot);
-
-    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
-    setIconSize(QSize(200, 200));
-}
diff --git a/src/ecuManager.h b/src/widgets/ecuManager.h
similarity index 68%
rename from src/ecuManager.h
rename to src/widgets/ecuManager.h
index 3678453..0c1a8c0 100644
--- a/src/ecuManager.h
+++ b/src/widgets/ecuManager.h
@@ -10,15 +10,15 @@
 //#include "comm-device-interface/op13.h"
 //#include "comm-device-interface/op20.h"
 
-#include "DMA-proto/jcsbanksDMA.h"
-#include "DMA-proto/stockDMA.h"
-#include "DMA-proto/evoX-DMA.h"
+#include "../DMA-proto/jcsbanksDMA.h"
+#include "../DMA-proto/stockDMA.h"
+#include "../DMA-proto/evoX-DMA.h"
 
-#include "ecu/ecu-definition.h"
-#include "logger.h"
-#include <src/abstract-memory.h>
+#include "../ecu/ecu-definition.h"
+
+#include "src/abstract-memory.h"
 //#include "read-request.h"
-#include "deviceNativeFilter.h"
+#include "../deviceNativeFilter.h"
 
 class ecuManager : public QToolBar
 {
@@ -32,32 +32,22 @@ public slots:
     void setProto(DMA_proto *ECUproto);
     void setLogRate(uint logRate);
 
-    void connectECU();
-    void disConnectECU();
-
-//    void startLogger();
-//    void stopLogger();
+    void ecuConnected();
 
     void updateRAM(abstractMemoryScaled memory);
-    void RAMreset();
 
     void lockConnect(bool lockFlag);
     void lockReset(bool lockFlag);
 
 private:
-    void createUI();
+    ecuDefinition ECUdef;
+
     QAction *a_start_action;
     QAction *a_ramReset;
 
-    //QVector<float> scaledRAM_MUTvalue;
-    //int readSize = 0;
-
-    ecu_definition *_ecu_definition = nullptr;
     comm_device_interface *devComm = nullptr;
     DMA_proto *ECUproto = nullptr;
 
-    dataLogger *_dataLogger;
-
     char* p_in_buff;
     char* p_out_buff;