dev(UML-981): Реализован функционал минимального набора колбэков

src/profinet/profinet.cpp

@@ -20,7 +20,9 @@
 #include <cstring>
 
 #include <cstdio>
- #include <iostream>
+#include <cstring>
+#include <iostream>
+
 
 using namespace std;
 
@@ -258,15 +260,14 @@ bool Profinet::addSlotAndPlugModule(std::shared_ptr<ProfinetSlot>& slot_ptr)
     return true;
 }
 
-ProfinetSlot * Profinet::getSlotPtr(uint16_t slot_nbr, uint32_t module_id)
+ProfinetSlot * Profinet::getSlotPtrAndCheckModule(uint16_t slot_nbr, uint32_t module_id)
 {
-    /// 1. Проверить, что слот slot добавлен в конфигурацию
+    ProfinetSlot * const slot_ptr = getSlotPtr(slot_nbr);
-    if (!m_slots.count(slot_nbr))
-    {
-       return nullptr;
-    }
 
-    ProfinetSlot * const slot_ptr = m_slots[slot_nbr].get();
+    if (slot_ptr == nullptr)
+    {
+        return nullptr;
+    }
 
     /// 2. Проверить, что в слоте slot идентификатор модуля m_module_id совпадает с module_ident
     if (slot_ptr->m_module_id != module_id)
@@ -277,6 +278,28 @@ ProfinetSlot * Profinet::getSlotPtr(uint16_t slot_nbr, uint32_t module_id)
     return slot_ptr;
 }
 
+ProfinetSlot * Profinet::getSlotPtr(uint16_t slot_nbr)
+{
+    /// 1. Проверить, что слот slot добавлен в конфигурацию
+    if (!m_slots.count(slot_nbr))
+    {
+       return nullptr;
+    }
+
+    return m_slots[slot_nbr].get();
+}
+
+ProfinetSubslot * Profinet::getSubslotPtr(uint16_t slot_nbr, uint16_t subslot_nbr)
+{
+    ProfinetSlot * const slot_ptr = getSlotPtr(slot_nbr);
+
+    if (slot_ptr == nullptr)
+    {
+        return nullptr;
+    }
+
+    return slot_ptr->getSubslotPtr(subslot_nbr);
+}
 
 /**\
  * =========================================================================================
@@ -292,15 +315,25 @@ int Profinet::callbackStateInd ( uint32_t arep, pnet_event_values_t event)
 int Profinet::callbackConnectInd ( uint32_t arep, pnet_result_t * p_result)
 {
     /**
-     * @brief По идее здесь ничего не нужно делать
+     * @brief 
      * Если будет возвращено 0, то соединение будет установлено. 
      * Если будет возвращено значение отличное от 0, то не будет, в этом случае нужно указать p_result.
      */
+
+    /// Сообщить приложению об установлении связи с контроллером.
+
     return 0;
 }
 
 int Profinet::callbackReleaseInd ( uint32_t arep, pnet_result_t * p_result)
 {
+    /**
+     * @brief 
+     * Cоединение будет разорвано при любом возвращаемом значении
+     */
+
+    /// Сообщить приложению об разрыве связи с контроллером.
+
     return 0;
 }
 
@@ -308,11 +341,19 @@ int Profinet::callbackDcontrolInd ( uint32_t arep,
                                     pnet_control_command_t control_command,
                                     pnet_result_t * p_result)
 {
+    /**
+     * @brief 
+     * Можно оставить пустым
+     */
     return 0;
 }
 
 int Profinet::callbackCcontrolInd ( uint32_t arep, pnet_result_t * p_result)
 {
+    /**
+     * @brief 
+     * Можно оставить пустым
+     */
     return 0;
 }
 
@@ -325,6 +366,40 @@ int Profinet::callbackReadInd ( uint32_t arep,
                                 uint16_t * p_read_length,
                                 pnet_result_t * p_result)
 {   
+    ProfinetSubslot * const subslot_ptr = getSubslotPtr(slot_nbr, subslot_nbr);
+
+    if (subslot_ptr == nullptr)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_READ;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_READ_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    ProfinetParameter * param_ptr = subslot_ptr->getParameterPtr(idx);
+
+    if (param_ptr == nullptr)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_READ;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_READ_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    if (*p_read_length < param_ptr->length)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_READ;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_READ_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    *pp_read_data = param_ptr->data_ptr;
+    *p_read_length = param_ptr->length;
+
     return 0;
 }
 
@@ -337,14 +412,46 @@ int Profinet::callbackWriteInd ( uint32_t arep,
         const uint8_t * p_write_data,
         pnet_result_t * p_result)
 {   
+    ProfinetSubslot * const subslot_ptr = getSubslotPtr(slot_nbr, subslot_nbr);
+
+    if (subslot_ptr == nullptr)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_WRITE;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_WRITE_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    ProfinetParameter * param_ptr = subslot_ptr->getParameterPtr(idx);
+
+    if (param_ptr == nullptr)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_WRITE;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_WRITE_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    if (write_length != param_ptr->length)
+    {
+        p_result->pnio_status.error_code = PNET_ERROR_CODE_WRITE;
+        p_result->pnio_status.error_decode = PNET_ERROR_DECODE_PNIORW;
+        p_result->pnio_status.error_code_1 = PNET_ERROR_CODE_1_APP_WRITE_ERROR;
+        p_result->pnio_status.error_code_2 = 0; /* User specific */
+        return -1;
+    }
+
+    /// 
+    std::memcpy(param_ptr->data_ptr, p_write_data, param_ptr->length);
+
     return 0;
 }
 
-
-
 int Profinet::callbackExpModuleInd ( uint16_t slot, uint32_t module_ident)
 {
-    ProfinetSlot * const slot_ptr =  getSlotPtr(slot, module_ident);
+    ProfinetSlot * const slot_ptr =  getSlotPtrAndCheckModule(slot, module_ident);
     /**
      * @brief Проверка, что слот slot добавлен в конфигурацию и что 
      * идентификатор модуля m_module_id совпадает с module_ident
@@ -370,7 +477,7 @@ int Profinet::callbackExpSubmoduleInd ( uint16_t slot,
                               uint32_t submodule_id,
                               const pnet_data_cfg_t * p_exp_data)
 {
-    ProfinetSlot * const slot_ptr =  getSlotPtr(slot, module_id);
+    ProfinetSlot * const slot_ptr =  getSlotPtrAndCheckModule(slot, module_id);
     /**
      * @brief Проверка, что слот slot добавлен в конфигурацию и что 
      * идентификатор модуля m_module_id совпадает с module_ident
@@ -387,7 +494,7 @@ int Profinet::callbackExpSubmoduleInd ( uint16_t slot,
         return -1;
     }
 
-    ProfinetSubslot * const subslot_ptr = slot_ptr->getSubslotPtr(subslot, submodule_id, p_exp_data);
+    ProfinetSubslot * const subslot_ptr = slot_ptr->getSubslotPtrAndCheckSubmodule(subslot, submodule_id, p_exp_data);
     
     /**
      *  Проверка того, что:
@@ -414,6 +521,7 @@ int Profinet::callbackNewDataStatusInd ( uint32_t arep,
                                uint8_t changes,
                                uint8_t data_status)
 {
+    /// Пока ничего не делаем
     return 0;
 }
 
@@ -423,25 +531,38 @@ int Profinet::callbackAlarmInd ( uint32_t arep,
                        uint16_t data_usi,
                        const uint8_t * p_data)
 {
+   /**
+    * @brief Должен быть ответ pnet_alarm_send_ack
+    * Пока заглушка
+    * 
+    */
+    pnet_pnio_status_t pnio_status = {0, 0, 0, 0};
+
+    pnet_alarm_send_ack (m_pnet_data.pnet_ptr, arep, p_alarm_arg, &pnio_status);
+
     return 0;
 }
 
 int Profinet::callbackAlarmCnf ( uint32_t arep, const pnet_pnio_status_t * p_pnio_status)
 {
+    /// Пока ничего не делаем
     return 0;
 }
 
 int Profinet::callbackAlarmAckCnf ( uint32_t arep, int res)
 {
+    /// Пока ничего не делаем
     return 0;
 }
 
 int Profinet::callbackResetInd ( bool should_reset_application, uint16_t reset_mode)
 {
+    /// Пока ничего не делаем
     return 0;
 }
 
 int Profinet::callbackSignalLedInd (bool led_state)
 {
+    /// Пока ничего не делаем
     return 0;
 }

src/profinet/profinet.hpp

@@ -33,9 +33,19 @@ private:
      * 
      * @param slot_nbr номер слота
      * @param module_id идентификатор модуля
-     * @return ProfinetSlot* указатель на слот
+     * @return ProfinetSlot* указатель на слот если слот сномером slot_nbr и идентификатором модуля module_id существует в конфигурации
      */
-    ProfinetSlot * getSlotPtr(uint16_t slot_nbr, uint32_t module_id);
+    ProfinetSlot * getSlotPtrAndCheckModule(uint16_t slot_nbr, uint32_t module_id);
+
+    /**
+     * @brief Проверяет наличие слота slot_nbr в конфигурации
+     * 
+     * @param slot_nbr  номер слота
+     * @return ProfinetSlot* - указатель на слот, при успехе или nullptr есои слот в конфигурации отсутсвует
+     */
+    ProfinetSlot * getSlotPtr(uint16_t slot_nbr);
+
+    ProfinetSubslot * getSubslotPtr(uint16_t slot_nbr, uint16_t subslot_nbr);
 
 public:
     /**

src/profinet/profinet_slot.cpp

@@ -57,15 +57,16 @@ bool ProfinetSlot::addSubslotAndPlugSubmodule(ProfinetServiceData& pnet_data, st
     return true;
 }
 
-ProfinetSubslot * ProfinetSlot::getSubslotPtr(uint16_t subslot_nbr, uint32_t submodule_id, const pnet_data_cfg_t * const p_data_cfg)
+ProfinetSubslot * ProfinetSlot::getSubslotPtrAndCheckSubmodule(uint16_t subslot_nbr, uint32_t submodule_id, const pnet_data_cfg_t * const p_data_cfg)
 {
     /// Проверка наличия подслота в конфигурации
-    if (!m_subslots.count(subslot_nbr))
+    ProfinetSubslot * const subslot_ptr = getSubslotPtr(subslot_nbr);
+
+    if (subslot_ptr == nullptr)
     {
         return nullptr;
     }
 
-    ProfinetSubslot * const subslot_ptr = m_subslots[subslot_nbr].get();
     /// Проверка совпадения идентификатора подмодуля
     if (subslot_ptr->m_submodule_id != submodule_id)
     {
@@ -82,3 +83,14 @@ ProfinetSubslot * ProfinetSlot::getSubslotPtr(uint16_t subslot_nbr, uint32_t sub
 
     return subslot_ptr;
 }
+
+ProfinetSubslot * ProfinetSlot::getSubslotPtr(uint16_t subslot_nbr)
+{
+    /// Проверка наличия подслота в конфигурации
+    if (!m_subslots.count(subslot_nbr))
+    {
+        return nullptr;
+    }
+
+    return m_subslots[subslot_nbr].get();
+}

src/profinet/profinet_slot.hpp

@@ -46,7 +46,9 @@ public:
 
    bool isModulePlugged() { return m_module_plugged; }
 
-   ProfinetSubslot * getSubslotPtr(uint16_t subslot_nbr, uint32_t submodule_id, const pnet_data_cfg_t * const p_data_cfg);
+   ProfinetSubslot * getSubslotPtrAndCheckSubmodule(uint16_t subslot_nbr, uint32_t submodule_id, const pnet_data_cfg_t * const p_data_cfg);
+
+   ProfinetSubslot * getSubslotPtr(uint16_t subslot_nbr);
 
 public:   
    /// Номер слота

src/profinet/profinet_subslot.cpp

@@ -42,3 +42,20 @@ bool ProfinetSubslot::plugSubmodule(ProfinetServiceData& pnet_data)
 
     return m_submodule_plugged;
 }
+
+bool ProfinetSubslot::addParameter(std::shared_ptr<ProfinetParameter>& param)
+{
+   auto ret = m_params.emplace(param->index, param);
+
+   return ret.second;
+}
+
+ProfinetParameter * ProfinetSubslot::getParameterPtr(uint32_t Index)
+{
+    if (!m_params.count(Index))
+    {
+        return nullptr;
+    }
+
+    return m_params[Index].get();
+}

src/profinet/profinet_subslot.hpp

@@ -4,7 +4,10 @@
 #include <string>
 
 #include "profinet_serv_data.hpp"
+#include "profinet_parameter.hpp"
 #include "../../libs/include/pnet_api.h"
+#include <map>
+#include <memory>
 
 /**
  * Callback for updated cyclic data
@@ -26,6 +29,10 @@ public:
 
    bool pullSubmodule(ProfinetServiceData& pnet_data);
 
+   bool addParameter(std::shared_ptr<ProfinetParameter>& param);
+
+   ProfinetParameter * getParameterPtr(uint32_t Index);
+   
    void setSlotNumber(uint16_t slot_nbr) { m_slot_nbr = slot_nbr; };
    
    void setModuleId(uint16_t module_id) { m_module_id = module_id; };
@@ -60,6 +67,8 @@ private:
    /// iops = I/O provider status data (формат данных из pnet_ioxs_values_t)
    uint8_t m_outdata_iops;
 
+   std::map<uint32_t, std::shared_ptr<ProfinetParameter>> m_params;
+
    /** Callback for cyclic input- or output data, or NULL if not implemented */
    ProfinetSubslotCallback m_cyclic_callback;