dev(UML-1462): Доработал передачу датаграмм в одном фрейме и мелкие исправления

components/free_rtos/ethernet_industry/CoE/eth_ecat_pdo_fmmu.hpp

@@ -19,28 +19,20 @@ public:
     EcatPdoFMMUSlave(ecat_buffer::EcatBufferSlave& buffer_slave)
     : buffer_slave_(buffer_slave) { }
 
-    template<typename... DataTypes>
+    template<typename DataType>
-    void write(datagram::EcatTelegram& telegram, DataTypes&... data) {
+    datagram::EcatDatagram<command::LWR, DataType> make_datagram_write(DataType& data) {
         ecat_buffer::FMMUProperties& fmmu_properties = buffer_slave_.get_fmmu_properties_write();
         address::Logical logical = fmmu_properties.address;
 
-        datagram::EcatDatagram<command::LWR, DataTypes...> datagram{ {{logical}}, data... };
+        return datagram::EcatDatagram<command::LWR, DataType>{ {{logical}}, data };
-
-        do {
-            telegram.transfer(datagram);
-        } while(datagram.get_wkc() < 0x0001);
     }
 
-    template<typename... DataTypes>
+    template<typename DataType>
-    void read(datagram::EcatTelegram& telegram, DataTypes&... data) {
+    datagram::EcatDatagram<command::LRD, DataType> make_datagram_read(DataType& data) {
         ecat_buffer::FMMUProperties& fmmu_properties = buffer_slave_.get_fmmu_properties_read();
         address::Logical logical = fmmu_properties.address;
 
-        datagram::EcatDatagram<command::LRD, DataTypes...> datagram{ {{logical}}, data... };
+        return datagram::EcatDatagram<command::LRD, DataType>{ {{logical}}, data };
-
-        do {
-            telegram.transfer(datagram);
-        } while(datagram.get_wkc() < 0x0001);
     }
 
 private:
@@ -48,63 +40,34 @@ private:
 };
 
 class EthEcatPdoFMMU {
-private:
-    template<typename... DataTypes>
-    void write_recursion(datagram::EcatTelegram& telegram, size_t slave_index, DataTypes&... data);
-
-    template<typename DataType, typename... DataTypes>
-    void write_recursion(datagram::EcatTelegram& telegram, size_t slave_index, DataType& head, DataTypes&... tail) {
-        pdo_fmmu_slaves_[slave_index].write(telegram, head);
-
-        slave_index++;
-
-        write_recursion(telegram, slave_index, tail...);
-    }
-
-    template<>
-    void write_recursion(datagram::EcatTelegram& telegram, size_t slave_index) { }
-
-    template<typename... DataTypes>
-    void read_recursion(datagram::EcatTelegram& telegram, size_t slave_index, DataTypes&... data);
-
-    template<typename DataType, typename... DataTypes>
-    void read_recursion(datagram::EcatTelegram& telegram, size_t slave_index, DataType& head, DataTypes&... tail) {
-        pdo_fmmu_slaves_[slave_index].read(telegram, head);
-
-        slave_index++;
-
-        read_recursion(telegram, slave_index, tail...);
-    }
-
-    template<>
-    void read_recursion(datagram::EcatTelegram& telegram, size_t slave_index) { }
-
 public:
     EthEcatPdoFMMU(ecat_buffer::EthEcatBuffer& ecat_mailbox): ecat_buffer_{ecat_mailbox} { }
 
     void init();
     void process();
 
-    template<typename... DataTypes>
+    template<typename DataType, typename... DataTypes>
-    void write(DataTypes&... data) {
+    void write(DataType& head, DataTypes&... tail) {
-        datagram::EcatTelegram& telegram = ecat_buffer_.get_ecat().get_telegram();
+        if(sizeof...(tail) + 1 > pdo_fmmu_slaves_.size()) {
-
-        if(sizeof...(data) > pdo_fmmu_slaves_.size()) {
             return;
         }
 
-        write_recursion(telegram, 0, data...);
+        size_t slave_index = 0;
+        auto datagram = pdo_fmmu_slaves_[slave_index].make_datagram_write(head);
+        // Сборка и отправка телеграммы с "головы"
+        write_recursion(slave_index + 1, datagram, datagram, tail...);
     }
 
-    template<typename... DataTypes>
+    template<typename DataType, typename... DataTypes>
-    void read(DataTypes&... data) {
+    void read(DataType& head, DataTypes&... tail) {
-        datagram::EcatTelegram& telegram = ecat_buffer_.get_ecat().get_telegram();
+        if(sizeof...(tail) + 1 > pdo_fmmu_slaves_.size()) {
-
-        if(sizeof...(data) > pdo_fmmu_slaves_.size()) {
             return;
         }
 
-        read_recursion(telegram, 0, data...);
+        size_t slave_index = 0;
+        auto datagram = pdo_fmmu_slaves_[slave_index].make_datagram_read(head);
+        // Сборка и отправка телеграммы с "головы"
+        read_recursion(slave_index + 1, datagram, datagram, tail...);
     }
 
 private:
@@ -112,6 +75,45 @@ private:
 
     std::vector<EcatPdoFMMUSlave> pdo_fmmu_slaves_;
 
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious, typename... DataTypes>
+    void write_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous, DataTypes&... data);
+
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious, typename DataType, typename... DataTypes>
+    void write_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous, DataType& head, DataTypes&... tail) {
+        auto datagram = pdo_fmmu_slaves_[slave_index].make_datagram_write(head);
+
+        write_recursion(slave_index + 1, first, previous + datagram, tail...);
+    }
+
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious>
+    void write_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous) {
+        datagram::EcatTelegram& telegram = ecat_buffer_.get_ecat().get_telegram();
+
+        do {
+            telegram.transfer(first);
+        } while(first.get_wkc() < 0x0001);
+    }
+
+
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious, typename... DataTypes>
+    void read_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous, DataTypes&... data);
+
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious, typename DataType, typename... DataTypes>
+    void read_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous, DataType& head, DataTypes&... tail) {
+        auto datagram = pdo_fmmu_slaves_[slave_index].make_datagram_read(head);
+
+        read_recursion(slave_index + 1, first, previous + datagram, tail...);
+    }
+
+    template<typename DatagramTypeFirst, typename DatagramTypePrevious>
+    void read_recursion(size_t slave_index, DatagramTypeFirst& first, DatagramTypePrevious& previous) {
+        datagram::EcatTelegram& telegram = ecat_buffer_.get_ecat().get_telegram();
+
+        do {
+            telegram.transfer(first);
+        } while(first.get_wkc() < 0x0001);
+    }
+
     void wait_op();
 };
 

components/free_rtos/ethernet_industry/eth_ecat_buffer.hpp

@@ -162,21 +162,13 @@ public:
     }
 
     template<typename TypeT>
-    void init_sync_manager(datagram::EcatTelegram& telegram, sync_manager sm, BufferProperties& buffer, address::Offset& reg) {
+    datagram::EcatDatagram<command::EcatCommand<TypeT, command::WR>, BufferProperties, uint32_t>
-        using TCommand = command::EcatCommand<TypeT, command::WR>;
+    make_sync_manager_datagram(SyncManager& sync_manager, BufferProperties& buffer) {
-
         auto slave_address = slave_.get_slave_address<TypeT>();
 
-        SyncManager sync_manager = sync_managers_[static_cast<size_t>(sm)];
+        return datagram::EcatDatagram<command::EcatCommand<TypeT, command::WR>, BufferProperties, uint32_t>{    {{slave_address, sync_manager.offset}},
-        datagram::EcatDatagram<TCommand, BufferProperties, uint32_t> datagram{    {{slave_address, sync_manager.offset}},
+                                                                                                                buffer,
-                                                                                  buffer,
+                                                                                                                sync_manager.default_setting };
-                                                                                  sync_manager.default_setting };
-
-        telegram.transfer(datagram);
-
-        reg = sync_manager.offset + 0x05;
-
-        DebugP_log("datagram.get_wkc() = %d\r\n", datagram.get_wkc());
     }
 
     template<typename TypeT>
@@ -186,16 +178,10 @@ public:
         auto slave_address = slave_.get_slave_address<TypeT>();
 
         SyncManager sync_manager_write = sync_managers_[static_cast<size_t>(sm_write)];
-        datagram::EcatDatagram<TCommand, BufferProperties, uint32_t> datagram_write{    {{slave_address, sync_manager_write.offset}},
+        auto datagram_write = make_sync_manager_datagram<TypeT>(sync_manager_write, buffer_properties_write_);
-                                                                                        buffer_properties_write_,
-                                                                                        sync_manager_write.default_setting };
-        //register_sync_manager<TypeT>(telegram, sm_write, buffer_properties_write_, buffer_regs_[MailboxesRegs::EMPTY]);
 
         SyncManager sync_manager_read = sync_managers_[static_cast<size_t>(sm_read)];
-        datagram::EcatDatagram<TCommand, BufferProperties, uint32_t> datagram_read{ {{slave_address, sync_manager_read.offset}},
+        auto datagram_read = make_sync_manager_datagram<TypeT>(sync_manager_read, buffer_properties_read_);
-                                                                                    buffer_properties_read_,
-                                                                                    sync_manager_read.default_setting };
-        //register_sync_manager<TypeT>(telegram, sm_read, buffer_properties_read_, buffer_regs_[MailboxesRegs::AVAILABLE]);
 
         datagram_write + datagram_read;
 
@@ -219,23 +205,17 @@ public:
     }
 
     template<typename TypeT>
-    void init_fmmu( datagram::EcatTelegram& telegram, fmmu fmmu_x, FMMUSettings& settings) {
+    datagram::EcatDatagram<command::EcatCommand<TypeT, command::WR>, FMMUSettings>
-        using TCommand = command::EcatCommand<TypeT, command::WR>;
+    make_fmmu_datagram(fmmu fmmu_x, FMMUSettings& settings) {
-
         auto slave_address = slave_.get_slave_address<TypeT>();
-        datagram::EcatDatagram<TCommand, FMMUSettings> datagram{ {{slave_address, fmmu_regs_[static_cast<size_t>(fmmu_x)]}}, settings};
 
-        telegram.transfer(datagram);
+        return datagram::EcatDatagram<command::EcatCommand<TypeT, command::WR>, FMMUSettings>{ {{slave_address, fmmu_regs_[static_cast<size_t>(fmmu_x)]}}, settings};
     }
 
     template<typename TypeT>
     void init_fmmu(datagram::EcatTelegram& telegram, fmmu fmmu_write, fmmu fmmu_read) {
-        using TCommand = command::EcatCommand<TypeT, command::WR>;
-
         static address::Logical logical_end_address{logical_start_address_};
 
-        auto slave_address = slave_.get_slave_address<TypeT>();
-
         fmmu_write_ = fmmu_write;
         fmmu_read_ = fmmu_read;
 
@@ -250,8 +230,7 @@ public:
             .activate = 0x01
         };
 
-        datagram::EcatDatagram<TCommand, FMMUSettings> datagram_write{ {{slave_address, fmmu_regs_[static_cast<size_t>(fmmu_write)]}}, settings_write};
+        auto datagram_write = make_fmmu_datagram<TypeT>(fmmu_write, settings_write);
-        //init_fmmu<TypeT>(telegram, fmmu_write, settings_write);
 
         fmmu_properties_write_.address = logical_end_address;
         fmmu_properties_write_.length = buffer_properties_write_.length;
@@ -269,8 +248,7 @@ public:
             .activate = 0x01
         };
 
-        datagram::EcatDatagram<TCommand, FMMUSettings> datagram_read{ {{slave_address, fmmu_regs_[static_cast<size_t>(fmmu_read)]}}, settings_read};
+        auto datagram_read = make_fmmu_datagram<TypeT>(fmmu_read, settings_read);
-        //init_fmmu<TypeT>(telegram, fmmu_read, settings_read);
 
         fmmu_properties_read_.address = logical_end_address;
         fmmu_properties_read_.length = buffer_properties_read_.length;

components/free_rtos/ethernet_industry/eth_ecat_command.hpp

@@ -138,7 +138,6 @@ public:
     }
 
 private:
-
     typename TypeT::TAddress address_;
 };
 

components/free_rtos/ethernet_industry/eth_ecat_datagram.hpp

@@ -31,6 +31,8 @@ public:
 
     IEcatDatagram() { }
 
+    virtual ~IEcatDatagram() { };
+
     IEcatDatagram& operator+(IEcatDatagram &next) {
         more_ = ec_moredatagrams::EC_MOREDATAGRAMS_MORE;
         next_ = &next;
@@ -85,6 +87,8 @@ public:
 
     EcatDatagram() { }
 
+    ~EcatDatagram() { }
+
     virtual uint8_t* pack(uint8_t *raw) override {
         return pack_header(raw);
     }