From 7546fa1865cdfc566ef48d18ec3e0760890749af Mon Sep 17 00:00:00 2001
From: aschwinn <al.schwinn@gsi.de>
Date: Tue, 16 May 2017 11:42:59 +0200
Subject: [PATCH] Bug 1155 - Allow to give alias-names for
 fesaProperties/Value-Items/Fields

---
 .../src/xml/fesa/fesa_3_0_0/fesaGeneral.py    |  27 ++
 .../src/xml/fesa/fesa_3_0_0/fesaTemplates.py  | 247 +++++++++--------
 .../xml/fesa/fesa_3_0_0/generateFesaDesign.py |  50 ++--
 .../xml/fesa/fesa_3_0_0/generateSourceCode.py |  66 ++---
 .../src/xml/test/AllTypes.silecsdesign        | 124 ++++-----
 .../src/xml/test/AllTypesFESA.silecsdesign    | 124 ++++-----
 .../xml/test/generated_correct/AllTypes.cpp   | 254 +++++++++---------
 .../src/xml/test/generated_correct/AllTypes.h |  53 ++--
 .../generated_correct/AllTypesFESA.design     |  12 +-
 silecs-model/src/xml/DesignSchema.xsd         |  10 +
 10 files changed, 503 insertions(+), 464 deletions(-)
 create mode 100644 silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaGeneral.py

diff --git a/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaGeneral.py b/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaGeneral.py
new file mode 100644
index 0000000..91cb2a2
--- /dev/null
+++ b/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaGeneral.py
@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# Copyright 2016 CERN and GSI
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+import libxml2
+import iecommon
+
+def getFesaName(node):
+    if(node.hasProp('fesaPropertyName')):
+        return node.prop('fesaPropertyName')
+    if(node.hasProp('fesaFieldName')):
+        return node.prop('fesaFieldName')
+    if(node.hasProp('name')):
+        return node.prop('name')
+    iecommon.logError('ERROR: Passed node has no name attribute', True, {'errorlog': True})    
diff --git a/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaTemplates.py b/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaTemplates.py
index bd60e31..ed8adab 100644
--- a/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaTemplates.py
+++ b/silecs-codegen/src/xml/fesa/fesa_3_0_0/fesaTemplates.py
@@ -192,40 +192,40 @@ namespace ${className}
     };
 
     // -------------------------------------------------------------------------------------------------
-    #define BLOCK_RO( name )\t\\
-    class name##_Type : public Abstract${className}\t\\
+    #define BLOCK_RO( blockName, propName )\t\\
+    class blockName##_Type : public Abstract${className}\t\\
     {\t\\
         public:\t\\
-            name##_Type(std::string name);\t\\
-            ~name##_Type();\t\\
+            blockName##_Type(std::string name);\t\\
+            ~blockName##_Type();\t\\
             void getOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);\t\\
     }
 
 
-    #define BLOCK_WO( name )\t\\
-    class name##_Type : public Abstract${className}\t\\
+    #define BLOCK_WO( blockName, propName )\t\\
+    class blockName##_Type : public Abstract${className}\t\\
     {\t\\
         public:\t\\
-            name##_Type(std::string name);\t\\
-            ~name##_Type();\t\\
+            blockName##_Type(std::string name);\t\\
+            ~blockName##_Type();\t\\
         void setOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);\t\\
-        void setOneDevice(Device* pDevice, name##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);\t\\
+        void setOneDevice(Device* pDevice, propName##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);\t\\
     }
 
-    #define BLOCK_RW( name )\t\\
-    class name##_Type : public Abstract${className}\t\\
+    #define BLOCK_RW( blockName, propName )\t\\
+    class blockName##_Type : public Abstract${className}\t\\
     {\t\\
         public:\t\\
-            name##_Type(std::string name);\t\\
-            ~name##_Type();\t\\
+            blockName##_Type(std::string name);\t\\
+            ~blockName##_Type();\t\\
             void getOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);\t\\
             void setOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);\t\\
-            void setOneDevice(Device* pDevice, name##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);\t\\
+            void setOneDevice(Device* pDevice, propName##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);\t\\
     }
     
     """
 
-hBlock = """BLOCK_${mode}( ${blockName} );
+hBlock = """BLOCK_${mode}( ${blockName}, ${propName} );
     """
 
 hBottom = """
@@ -243,14 +243,13 @@ hBottom = """
             static void cleanup() { Abstract${className}::cleanup(); }
             static bool isInitialized(){ return Abstract${className}::isInitialized(); }
             static Silecs::PLC* getPLC(Device* pDevice)
-			{
-				return Abstract${className}::theCluster()->getPLC(pDevice->plcHostName.get(),pDevice->parameterFile.get());
-			}
-
+            {
+                return Abstract${className}::theCluster()->getPLC(pDevice->plcHostName.get(),pDevice->parameterFile.get());
+            }
     """
 
-hDeclBlocks = """            static ${className}_Type ${className};
-    """
+hDeclBlocks = """
+			static ${className}_Type ${className};"""
 
 hClosing = """           
         };
@@ -483,53 +482,53 @@ cRecv = """        if (recvNow) pPLCDevice -> recv(blockName_);
     """
 
 cGetStringReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
-        pDevice->${registerName}.set(pRegister->getValString().c_str(), pContext);
+        pRegister = pPLCDevice->getRegister("${regName}");
+        pDevice->${fieldName}.set(pRegister->getValString().c_str(), pContext);
 """
 
 cGetStringArrayReg = """
         {
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         const std::string** stdStringArray = pRegister->getRefStringArray(dim1);
         for (unsigned int i=0; i<dim1; i++)
-        {   pDevice->${registerName}.setString(stdStringArray[i]->c_str(), i, pContext);
+        {   pDevice->${fieldName}.setString(stdStringArray[i]->c_str(), i, pContext);
         }
         }
 """
 
 cGetScalarReg = """
-        pDevice->${registerName}.set( pPLCDevice->getRegister("${registerName}")->getVal${registerType}(), pContext);"""
+        pDevice->${fieldName}.set( pPLCDevice->getRegister("${regName}")->getVal${regType}(), pContext);"""
 
 cGetArrayReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
             dim1 = pRegister->getDimension1();
-            pDevice->${registerName}.set(pRegister->getRef${registerType}Array(dim1), dim1, pContext);
+            pDevice->${fieldName}.set(pRegister->getRef${regType}Array(dim1), dim1, pContext);
         """
 cGetArray2DReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->${registerName}.set(pRegister->getRef${registerType}Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->${fieldName}.set(pRegister->getRef${regType}Array2D(dim1, dim2), dim1, dim2, pContext);
 """
 
 cGetUnsignedArrayReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
             dim1 = pRegister->getDimension1();
-            ${registerType}* ${registerName} = (${registerType}*)calloc(dim1, sizeof(${registerType}));
-            pRegister->getVal${registerType}Array(${registerName}, dim1);\t//use automatic conversion for JAVA non-supported type
-            pDevice->${registerName}.set(${registerName}, dim1, pContext);
-            free(${registerName});
+            ${regType}* ${regName} = (${regType}*)calloc(dim1, sizeof(${regType}));
+            pRegister->getVal${regType}Array(${regName}, dim1);\t//use automatic conversion for JAVA non-supported type
+            pDevice->${fieldName}.set(${regName}, dim1, pContext);
+            free(${regName});
     """
 
 cGetUnsignedArray2DReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        ${fesaType]* ${registerName} = (${fesaType]*)calloc(dim1*dim2, sizeof(${fesaType]));
-        pRegister->getVal${registerType}Array2D(${registerName}, dim1, dim2);\t//use automatic conversion for JAVA non-supported type
-        pDevice->${registerName}.set(${registerName}, dim1, dim2, pContext);
-    free(${registerName});
+        ${fesaType]* ${regName} = (${fesaType]*)calloc(dim1*dim2, sizeof(${fesaType]));
+        pRegister->getVal${regType}Array2D(${regName}, dim1, dim2);\t//use automatic conversion for JAVA non-supported type
+        pDevice->${fieldName}.set(${regName}, dim1, dim2, pContext);
+    free(${regName});
 """
 
 cCommonSet = """    
@@ -548,7 +547,7 @@ cSend = """
 """
 
 cDatatypeSet = """
-    void ${blockName}_Type::setOneDevice(Device* pDevice, ${blockName}PropertyData& data, bool sendNow, MultiplexingContext* pContext)
+    void ${blockName}_Type::setOneDevice(Device* pDevice, ${propName}PropertyData& data, bool sendNow, MultiplexingContext* pContext)
     {
     	if( !isInitialized_ )
     	{
@@ -559,103 +558,103 @@ cDatatypeSet = """
 """
 
 cSetStringReg = """
-        pPLCDevice->getRegister("${registerName}")->setValString(pDevice->${registerName}.get(pContext));
+        pPLCDevice->getRegister("${regName}")->setValString(pDevice->${fieldName}.get(pContext));
 """
 
 cSetStringArrayReg = """
         {
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         std::string stdStringArray[dim1];
-        const char** cStringArray = pDevice->${registerName}.get(fesaDim1, pContext);
+        const char** cStringArray = pDevice->${fieldName}.get(fesaDim1, pContext);
         for (unsigned int i=0; i<dim1; i++) stdStringArray[i] = (const char*)cStringArray[i];
         pRegister->setValStringArray(stdStringArray, dim1);
         }
 """
 
 cSetScalarReg = """
-        pPLCDevice->getRegister("${registerName}")->setVal${registerType}( pDevice->${registerName}.get(pContext));"""
+        pPLCDevice->getRegister("${regName}")->setVal${regType}( pDevice->${fieldName}.get(pContext));"""
             
 cSetScalarUReg = """
-        pPLCDevice->getRegister("${registerName}")->setVal${registerType}( (${lowerType})pDevice->${registerName}.get(pContext));"""
+        pPLCDevice->getRegister("${regName}")->setVal${regType}( (${lowerType})pDevice->${fieldName}.get(pContext));"""
 
 cSetArrayReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
             dim1 = pRegister->getDimension1();
-            pRegister->setVal${registerType}Array(pDevice->${registerName}.get(fesaDim1, pContext), dim1);
+            pRegister->setVal${regType}Array(pDevice->${fieldName}.get(fesaDim1, pContext), dim1);
     """
 
 cSetArray2DReg = """
-    pRegister = pPLCDevice->getRegister("${registerName}");
+    pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setVal${registerType}Array2D(pDevice->${registerName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setVal${regType}Array2D(pDevice->${fieldName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 """
 
 cSetUnsignedArrayReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
-        pRegister->setVal${registerType}Array(pDevice->${registerName}.get(fesaDim1, pContext), dim1);\t//use automatic conversion for JAVA non-supported type
+        pRegister->setVal${regType}Array(pDevice->${fieldName}.get(fesaDim1, pContext), dim1);\t//use automatic conversion for JAVA non-supported type
 """
 
 cSetUnsignedArray2DReg = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setVal${registerType}Array2D( pDevice->${registerName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);\t//use automatic conversion for JAVA non-supported type
+        pRegister->setVal${regType}Array2D( pDevice->${fieldName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);\t//use automatic conversion for JAVA non-supported type
 """
 
 cSetStringRegData = """
-        (data.is${registerName_upper}Available()) ? pPLCDevice->getRegister("${registerName}")->setValString(data.${registerName}.get()) :
-                                     pPLCDevice->getRegister("${registerName}")->setValString(pDevice->${registerName}.get(pContext));"""
+        (data.is${fieldName_upper}Available()) ? pPLCDevice->getRegister("${regName}")->setValString(data.${fieldName}.get()) :
+                                     pPLCDevice->getRegister("${regName}")->setValString(pDevice->${fieldName}.get(pContext));"""
                                     
 cSetStringArrayRegData = """
         {
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         std::string stdStringArray[dim1];
-        const char** cStringArray = (data.is${registerName_upper}Available() ? data.${registerName}.get(fesaDim1) : pDevice->${registerName}.get(fesaDim1, pContext));
+        const char** cStringArray = (data.is${fieldName_upper}Available() ? data.${fieldName}.get(fesaDim1) : pDevice->${fieldName}.get(fesaDim1, pContext));
         for (unsigned int i=0; i<dim1; i++) stdStringArray[i] = (const char*)cStringArray[i];
         pRegister->setValStringArray(stdStringArray, dim1);
         }
 """
 
 cSetScalarRegData = """
-        (data.is${registerName_upper}Available()) ? pPLCDevice->getRegister("${registerName}")->setVal${registerType}( data.${registerName}.get()) :
-                                          pPLCDevice->getRegister("${registerName}")->setVal${registerType}( pDevice->${registerName}.get(pContext));"""
+        (data.is${fieldName_upper}Available()) ? pPLCDevice->getRegister("${regName}")->setVal${regType}( data.${fieldName}.get()) :
+                                          pPLCDevice->getRegister("${regName}")->setVal${regType}( pDevice->${fieldName}.get(pContext));"""
 
 cSetScalarURegData = """
-        (data.is${registerName_upper}Available()) ? pPLCDevice->getRegister("${registerName}")->setVal${registerType}( (${lowerType})data.${registerName}.get()) :
-                                          pPLCDevice->getRegister("${registerName}")->setVal${registerType}( (${lowerType})pDevice->${registerName}.get(pContext));"""
+        (data.is${fieldName_upper}Available()) ? pPLCDevice->getRegister("${regName}")->setVal${regType}( (${lowerType})data.${fieldName}.get()) :
+                                          pPLCDevice->getRegister("${regName}")->setVal${regType}( (${lowerType})pDevice->${fieldName}.get(pContext));"""
 
 cSetArrayRegData = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
             dim1 = pRegister->getDimension1();
-            (data.is${registerName_upper}Available()) ? pRegister->setVal${registerType}Array( data.${registerName}.get(fesaDim1), dim1) :
-                                         pRegister->setVal${registerType}Array( pDevice->${registerName}.get(fesaDim1, pContext), dim1);
+            (data.is${fieldName_upper}Available()) ? pRegister->setVal${regType}Array( data.${fieldName}.get(fesaDim1), dim1) :
+                                         pRegister->setVal${regType}Array( pDevice->${fieldName}.get(fesaDim1, pContext), dim1);
     """
 
 cSetUnsignedArrayRegData = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
             dim1 = pRegister->getDimension1();
-            (data.is${registerName_upper}Available()) ? pRegister->setVal${registerType}Array( data.${registerName}.get(fesaDim1), dim1) :
-                                         pRegister->setVal${registerType}Array( pDevice->${registerName}.get(fesaDim1, pContext), dim1);
+            (data.is${fieldName_upper}Available()) ? pRegister->setVal${regType}Array( data.${fieldName}.get(fesaDim1), dim1) :
+                                         pRegister->setVal${regType}Array( pDevice->${fieldName}.get(fesaDim1, pContext), dim1);
     """
 
 cSetArray2DRegData = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.is${registerName_upper}Available()) ? pRegister->setVal${registerType}Array2D(data.${registerName}.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setVal${registerType}Array2D(pDevice->${registerName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setVal${regType}Array2D(data.${fieldName}.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setVal${regType}Array2D(pDevice->${fieldName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 """
 
 cSetUnsignedArray2DRegData = """
-        pRegister = pPLCDevice->getRegister("${registerName}");
+        pRegister = pPLCDevice->getRegister("${regName}");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.is${registerName_upper}Available()) ? pRegister->setVal${registerType}Array2D(data.${registerName}.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setVal${registerType}Array2D(pDevice->${registerName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.is${fieldName_upper}Available()) ? pRegister->setVal${regType}Array2D(data.${fieldName}.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setVal${regType}Array2D(pDevice->${fieldName}.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 """
 
 makeDesign = """# Include SILECS library path
@@ -720,8 +719,8 @@ def genHTopBlock(className, blockName):
 def genHTop2(className):
     return hTop2.replace('${className}', className)
    
-def genHBlock(mode, blockName):
-    return hBlock.replace('${mode}', mode).replace('${blockName}', blockName)
+def genHBlock(mode, blockName, propName):
+    return hBlock.replace('${mode}', mode).replace('${blockName}', blockName).replace('${propName}', propName)
 
 def genHBottom(className):
 	return hBottom.replace('${className}', className)
@@ -765,80 +764,80 @@ def genCGetPLC(className, blockName):
 def genCPart4(className):
     return cPart4.replace('${className}', className)
 
-def genCGetStringReg(registerName):
-    return cGetStringReg.replace('${registerName}', registerName)
+def genCGetStringReg(regName, fieldName):
+    return cGetStringReg.replace('${regName}', regName).replace('${fieldName}', fieldName)
 
-def genCGetStringArrayReg(registerName):
-    return cGetStringArrayReg.replace('${registerName}', registerName)
+def genCGetStringArrayReg(regName, fieldName):
+    return cGetStringArrayReg.replace('${regName}', regName).replace('${fieldName}', fieldName)
 
-def genCGetScalarReg(registerName, registerType):
-    return cGetScalarReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCGetScalarReg(regName, fieldName, regType):
+    return cGetScalarReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCGetArrayReg(registerName, registerType):    
-    return cGetArrayReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCGetArrayReg(regName, fieldName, regType):    
+    return cGetArrayReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCGetArray2DReg(registerName, registerType):
-    return cGetArray2DReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCGetArray2DReg(regName, fieldName, regType):
+    return cGetArray2DReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCGetUnsignedArrayReg(registerName, fesaType, registerType):
-    return cGetUnsignedArrayReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCGetUnsignedArrayReg(regName, fieldName, fesaType, regType):
+    return cGetUnsignedArrayReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
    
-def genCGetUnsignedArray2DReg(registerName, fesaType, registerType):
-    return cGetUnsignedArray2DReg.replace('${registerName}', registerName).replace('${registerType}', registerType).replace('${fesaType]', fesaType)
+def genCGetUnsignedArray2DReg(regName, fieldName, fesaType, regType):
+    return cGetUnsignedArray2DReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fesaType]', fesaType).replace('${fieldName}', fieldName)
 
 def genCCommonSet(blockName,className):
     return cCommonSet.replace('${className}', className).replace('${blockName}', blockName)
 
-def genCDatatypeSet(blockName,className):
-    return cDatatypeSet.replace('${className}', className).replace('${blockName}', blockName)
+def genCDatatypeSet(blockName,propName,className):
+    return cDatatypeSet.replace('${className}', className).replace('${blockName}', blockName).replace('${propName}', propName)
 
-def genCSetStringReg(registerName):
-    return cSetStringReg.replace('${registerName}', registerName)
+def genCSetStringReg(regName, fieldName):
+    return cSetStringReg.replace('${regName}', regName).replace('${fieldName}', fieldName)
 
-def genCSetStringArrayReg(registerName):
-    return cSetStringArrayReg.replace('${registerName}', registerName)
+def genCSetStringArrayReg(regName, fieldName):
+    return cSetStringArrayReg.replace('${regName}', regName).replace('${fieldName}', fieldName)
 
-def genCSetScalarReg(registerName, registerType):
-    return cSetScalarReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCSetScalarReg(regName, fieldName, regType):
+    return cSetScalarReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetScalarUReg(registerName, registerType, lowerType):
-    return cSetScalarUReg.replace('${registerName}', registerName).replace('${registerType}', registerType).replace('${lowerType}', lowerType)
+def genCSetScalarUReg(regName, fieldName, regType, lowerType):
+    return cSetScalarUReg.replace('${regName}', regName).replace('${regType}', regType).replace('${lowerType}', lowerType).replace('${fieldName}', fieldName)
 
-def genCSetArrayReg(registerName, registerType):
-    return cSetArrayReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCSetArrayReg(regName, fieldName, regType):
+    return cSetArrayReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetUnsignedArrayReg(registerName, registerType):    
-    return cSetUnsignedArrayReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCSetUnsignedArrayReg(regName, fieldName, regType):    
+    return cSetUnsignedArrayReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetArray2DReg(registerName, registerType):
-    return cSetArray2DReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCSetArray2DReg(regName, fieldName, regType):
+    return cSetArray2DReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetUnsignedArray2DReg(registerName, registerType):
-    return cSetUnsignedArray2DReg.replace('${registerName}', registerName).replace('${registerType}', registerType)
+def genCSetUnsignedArray2DReg(regName, fieldName, regType):
+    return cSetUnsignedArray2DReg.replace('${regName}', regName).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetStringRegData(registerName):
-	return cSetStringRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName))
+def genCSetStringRegData(regName, fieldName):
+	return cSetStringRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${fieldName}', fieldName)
 
-def genCSetStringArrayRegData(registerName):
-    return cSetStringArrayRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName))
+def genCSetStringArrayRegData(regName, fieldName):
+    return cSetStringArrayRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${fieldName}', fieldName)
 
-def genCSetScalarRegData(registerName, registerType):
-	return cSetScalarRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType)
+def genCSetScalarRegData(regName, fieldName, regType):
+	return cSetScalarRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetScalarURegData(registerName, registerType, lowerType):
-	return cSetScalarURegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType).replace('${lowerType}', lowerType)
+def genCSetScalarURegData(regName, fieldName, regType, lowerType):
+	return cSetScalarURegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${lowerType}', lowerType).replace('${fieldName}', fieldName)
 
-def genCSetUnsignedArrayRegData(registerName, registerType):
-	return cSetUnsignedArrayRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType)
+def genCSetUnsignedArrayRegData(regName, fieldName, regType):
+	return cSetUnsignedArrayRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetUnsignedArray2DRegData(registerName, fesaType, registerType):
-	return cSetUnsignedArray2DRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType)
+def genCSetUnsignedArray2DRegData(regName, fieldName, fesaType, regType):
+	return cSetUnsignedArray2DRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetArrayRegData(registerName, registerType):
-    return cSetArrayRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType)
+def genCSetArrayRegData(regName, fieldName, regType):
+    return cSetArrayRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
-def genCSetArray2DRegData(registerName, fesaType, registerType):
-	return cSetArray2DRegData.replace('${registerName}', registerName).replace('${registerName_upper}', iecommon.capitalizeString(registerName)).replace('${registerType}', registerType)
+def genCSetArray2DRegData(regName, fieldName, fesaType, regType):
+	return cSetArray2DRegData.replace('${regName}', regName).replace('${fieldName_upper}', iecommon.capitalizeString(fieldName)).replace('${regType}', regType).replace('${fieldName}', fieldName)
 
 def genMakeDesign(centralMakefilePath):
     return makeDesign.replace('${centralMakefilePath}', centralMakefilePath)
diff --git a/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateFesaDesign.py b/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateFesaDesign.py
index 9aa76a3..83af3b7 100644
--- a/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateFesaDesign.py
+++ b/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateFesaDesign.py
@@ -26,10 +26,12 @@ import datetime
 import socket
 
 import iecommon
+import fesaGeneral
 import fesaTemplates
 import iefiles
 
 from iecommon import *
+from fesaGeneral import *
 
 import libxml2
 
@@ -39,7 +41,7 @@ class FESADesignGenerator3_0_0(object):
     #=========================================================================
     # Sub-functions
     #=========================================================================
-
+        
     def isGSITemplate(self,parent):
         if isChildElement(parent,"GSI-Status-Property"):
             return True
@@ -203,9 +205,9 @@ class FESADesignGenerator3_0_0(object):
     def getOrCreateFieldNode(self,parent,register): #in order to place them before any GSI-specifc fields (order matters!)
         iecommon.logDebug('Generating Data-Field for register: ' + register.prop('name'), {'debuglog': True})
         if( hasChildren(parent) ):
-            return getOrCreateNamedPreviousSiblingElement(parent,getFirstChild(parent),'field',register.prop('name'))
+            return getOrCreateNamedPreviousSiblingElement(parent,getFirstChild(parent),'field',getFesaName(register))
         else:
-            return getOrCreateNamedChildElement(parent,'field',register.prop('name'))
+            return getOrCreateNamedChildElement(parent,'field',getFesaName(register))
 
     def getOrCreatePLCHostNameField(self,configurationNode):
         fieldNode = getOrCreateNamedFirstChild(configurationNode,'field','plcHostName')
@@ -260,9 +262,9 @@ class FESADesignGenerator3_0_0(object):
         iecommon.logDebug('Generating SettingProperty for Block: ' + block.prop('name'), {'debuglog': True})
         if( hasChildren(parent)):
             propsAfterCommand = parent.xpathEval("*[not(name()='command-property')]")
-            prop = getOrCreateNamedPreviousSiblingElement(parent,propsAfterCommand[0], 'setting-property',block.prop('name'))
+            prop = getOrCreateNamedPreviousSiblingElement(parent,propsAfterCommand[0], 'setting-property',getFesaName(block))
         else:
-            prop = getOrCreateNamedChildElement(parent,'setting-property',block.prop('name'))
+            prop = getOrCreateNamedChildElement(parent,'setting-property',getFesaName(block))
         self.getOrCreateRegisterValueItems(prop,block,True)
         self.getOrCreateUpdateFlagItem(prop)
         self.getOrCreateCyleNameItem(prop)
@@ -272,23 +274,23 @@ class FESADesignGenerator3_0_0(object):
         iecommon.logDebug('Generating AcquisitionProperty for Block: ' + block.prop('name'), {'debuglog': True})
         prop = ""
         if( hasChildren(parent)):
-            prop = getOrCreateNamedPreviousSiblingElement(parent,getFirstChild(parent), 'acquisition-property',block.prop('name'))
+            prop = getOrCreateNamedPreviousSiblingElement(parent,getFirstChild(parent), 'acquisition-property',getFesaName(block))
         else:
-            prop = getOrCreateNamedChildElement(parent,'acquisition-property',block.prop('name'))
+            prop = getOrCreateNamedChildElement(parent,'acquisition-property',getFesaName(block))
         fillAttributes(prop, {'visibility': 'development', 'subscribable': 'true', 'multiplexed': 'false', 'on-change': 'true'})
         self.getOrCreateRegisterValueItems(prop,block,False)
         self.getOrCreateAcqStampItem(prop)
         self.getOrCreateUpdateFlagItem(prop)
         self.getOrCreateCyleNameItem(prop)
         self.getOrCreateCyleStampItem(prop)
-        self.getOrCreateAction(prop,'Get'+block.prop('name'),'get',actionsNode,'default')
+        self.getOrCreateAction(prop,'Get'+getFesaName(block),'get',actionsNode,'default')
         return prop
                 
             
     def getOrCreateGSISettingProperty(self,parent,block):
         iecommon.logDebug('Generating GSISettingProperty for Block: ' + block.prop('name'), {'debuglog': True})
         powerProp = parent.xpathEval('GSI-Power-Property')[0] # template is used --> there has to be a power prop
-        prop =  getOrCreateNamedPreviousSiblingElement(parent,powerProp, 'GSI-Setting-Property',block.prop('name'))
+        prop =  getOrCreateNamedPreviousSiblingElement(parent,powerProp, 'GSI-Setting-Property',getFesaName(block))
         self.getOrCreateRegisterValueItems(prop,block,True)
         self.getOrCreateUpdateFlagItem(prop)
         self.getOrCreateCyleNameItem(prop)
@@ -297,14 +299,14 @@ class FESADesignGenerator3_0_0(object):
     def getOrCreateGSIAcquisitionProperty(self,parent,actionsNode,block):
         iecommon.logDebug('Generating GSIAcquisitionProperty for Block: ' + block.prop('name'), {'debuglog': True})
         versionProp = parent.xpathEval('GSI-Version-Property')[0] # template is used --> there has to be a version prop
-        prop =  getOrCreateNamedPreviousSiblingElement(parent,versionProp, 'GSI-Acquisition-Property',block.prop('name'))
+        prop =  getOrCreateNamedPreviousSiblingElement(parent,versionProp, 'GSI-Acquisition-Property',getFesaName(block))
         fillAttributes(prop, {'visibility': 'development', 'subscribable': 'true', 'multiplexed': 'false', 'on-change': 'true'})
         self.getOrCreateRegisterValueItems(prop,block,False)
         self.getOrCreateAcqStampItem(prop)
         self.getOrCreateUpdateFlagItem(prop)
         self.getOrCreateCyleNameItem(prop)
         self.getOrCreateCyleStampItem(prop)
-        self.getOrCreateAction(prop,'Get'+block.prop('name'),'get',actionsNode,'default')
+        self.getOrCreateAction(prop,'Get'+getFesaName(block),'get',actionsNode,'default')
         self.getOrCreateAcquisitionContextItem(prop)
         return prop
 
@@ -324,20 +326,20 @@ class FESADesignGenerator3_0_0(object):
 
     def getOrCreateValueItem(self,propertyNode,register,isSetting):
         iecommon.logDebug('Generating ValueItem for Register: ' + register.prop('name'), {'debuglog': True})
-        result = propertyNode.xpathEval("value-item[@name='" + register.prop('name') + "']")
+        result = propertyNode.xpathEval("value-item[@name='" + getFesaName(register) + "']")
         if len(result):
             return result[0]
         if( hasChildren(propertyNode)):
             result = propertyNode.xpathEval("*[not(name()='description') and not(name()='export') and not(name()='filter-item')]") # skip possible first elements to get right position
-            valueItemNode =  getOrCreateNamedPreviousSiblingElement(propertyNode,result[0],'value-item',register.prop('name'))
+            valueItemNode =  getOrCreateNamedPreviousSiblingElement(propertyNode,result[0],'value-item',getFesaName(register))
         else:
-            valueItemNode = getOrCreateNamedChildElement(propertyNode,'value-item',register.prop('name'))
+            valueItemNode = getOrCreateNamedChildElement(propertyNode,'value-item',getFesaName(register))
         if isSetting:
             fillAttributes(valueItemNode, {'direction': 'INOUT'})
         else:
             fillAttributes(valueItemNode, {'direction': 'OUT'})
         self.getOrCreateType(valueItemNode,register)
-        self.getOrCreateFieldRef(valueItemNode,register.prop('name'))
+        self.getOrCreateFieldRef(valueItemNode,getFesaName(register))
 
     #-------------------------------------------------------------------------
     # Generates the data node of the FESA design document
@@ -423,19 +425,19 @@ class FESADesignGenerator3_0_0(object):
 
             if block.prop('mode') in ('READ-ONLY'):
                 self.getOrCreateFESAProperty(acquisitionNode,actionsNode,block)
-                rtAction = getOrCreateNamedChildElement(actionsNode,'rt-action','Recv'+block.prop('name'))
-                notifiedProperty = getOrCreateNamedChildElement(rtAction,'notified-property',block.prop('name'),'property-name-ref')
+                rtAction = getOrCreateNamedChildElement(actionsNode,'rt-action','Recv'+getFesaName(block))
+                notifiedProperty = getOrCreateNamedChildElement(rtAction,'notified-property',getFesaName(block),'property-name-ref')
                 fillAttributes(notifiedProperty, {'automatic': 'true'})
                 self.genEvent(block,doc,logTopics)
                 self.genSchedulingUnit(block,doc,logTopics)
             else:   # setting property for both WO and RW blocks, w/get+set server action
                 settingPropertyNode = self.getOrCreateFESAProperty(settingNode, actionsNode, block)
                 fillAttributes(settingPropertyNode, {'visibility': 'development', 'multiplexed': 'false'})
-                self.getOrCreateAction(settingPropertyNode,'Send'+block.prop('name'),'set',actionsNode,'custom')
+                self.getOrCreateAction(settingPropertyNode,'Send'+getFesaName(block),'set',actionsNode,'custom')
                 if block.prop('mode') == 'READ-WRITE':
-                    self.getOrCreateAction(settingPropertyNode,'Recv'+block.prop('name'),'get',actionsNode,'custom')
+                    self.getOrCreateAction(settingPropertyNode,'Recv'+getFesaName(block),'get',actionsNode,'custom')
                 else:   # WRITE-ONLY
-                    self.getOrCreateAction(settingPropertyNode,'Get'+block.prop('name'),'get',actionsNode,'default')
+                    self.getOrCreateAction(settingPropertyNode,'Get'+getFesaName(block),'get',actionsNode,'default')
 
     #-------------------------------------------------------------------------
     # Generates the logical-events node of the FESA design
@@ -449,7 +451,7 @@ class FESADesignGenerator3_0_0(object):
         timingSourceNode = getOrCreateNamedChildElement(sourcesNode,'timing-event-source','Timing')
         timerSourceNode = getOrCreateNamedChildElement(sourcesNode,'timer-event-source','Timer')
         logicalEventsNode = getOrCreateChildElement(eventsNode,'logical-events')
-        logicalEventNode = getOrCreateNamedChildElement(logicalEventsNode,'logical-event','Recv'+block.prop('name')+'Event')
+        logicalEventNode = getOrCreateNamedChildElement(logicalEventsNode,'logical-event','Recv'+getFesaName(block)+'Event')
         fillAttributes(logicalEventNode, {'type': 'timer', 'use': 'required'})
             
     #-------------------------------------------------------------------------
@@ -460,11 +462,11 @@ class FESADesignGenerator3_0_0(object):
         iecommon.logDebug('Generating scheduling unit', logTopics)
         eqpModelNode = fesaRoot.xpathEval("/equipment-model")[0]
         schedulingUnitsNode = getOrCreateChildElement(eqpModelNode,'scheduling-units')
-        schedulingUnitNode = getOrCreateNamedChildElement(schedulingUnitsNode,'scheduling-unit','Recv'+block.prop('name')+'Unit')
+        schedulingUnitNode = getOrCreateNamedChildElement(schedulingUnitsNode,'scheduling-unit','Recv'+getFesaName(block)+'Unit')
         rtActionRefNode = getOrCreateChildElement(schedulingUnitNode,'rt-action-ref')
-        fillAttributes(rtActionRefNode, {'rt-action-name-ref': 'Recv'+block.prop('name')})
+        fillAttributes(rtActionRefNode, {'rt-action-name-ref': 'Recv'+getFesaName(block)})
         logicalEventRefNode = getOrCreateChildElement(schedulingUnitNode,'logical-event-ref')
-        fillAttributes(logicalEventRefNode, {'logical-event-name-ref': 'Recv'+block.prop('name')+'Event'})
+        fillAttributes(logicalEventRefNode, {'logical-event-name-ref': 'Recv'+getFesaName(block)+'Event'})
 
     #-------------------------------------------------------------------------
     # Generates the scheduling-units node of the FESA design
diff --git a/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateSourceCode.py b/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateSourceCode.py
index 2b520a9..e01ebcd 100644
--- a/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateSourceCode.py
+++ b/silecs-codegen/src/xml/fesa/fesa_3_0_0/generateSourceCode.py
@@ -25,9 +25,11 @@ import socket
 
 import iecommon
 import fesaTemplates
+import fesaGeneral
 import iefiles
 
 from iecommon import *
+from fesaGeneral import *
 import libxml2
 
 def findBlockServerSetActionName(fesaRoot, blockName):
@@ -46,18 +48,18 @@ def genHSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
     
     for block in silecsRoot.xpathEval('//Block'):
         if block.prop('mode') == 'WRITE-ONLY' or block.prop('mode') == 'READ-WRITE':
-            serverActionName = findBlockServerSetActionName(fesaRoot,block.prop('name'))
+            serverActionName = findBlockServerSetActionName(fesaRoot,getFesaName(block))
             source += fesaTemplates.genHTopBlock(className, serverActionName)
         
     source += fesaTemplates.genHTop2(className)
         
     for block in silecsRoot.xpathEval('//Block'):
         if block.prop('mode') == 'READ-ONLY':
-            source += fesaTemplates.genHBlock('RO', block.prop('name'))
+            source += fesaTemplates.genHBlock('RO', block.prop('name'),getFesaName(block) )
         elif block.prop('mode') == 'WRITE-ONLY':
-            source += fesaTemplates.genHBlock('WO', block.prop('name'))
+            source += fesaTemplates.genHBlock('WO', block.prop('name'),getFesaName(block))
         else:   # READ-WRITE
-            source += fesaTemplates.genHBlock('RW', block.prop('name'))
+            source += fesaTemplates.genHBlock('RW', block.prop('name'),getFesaName(block))
     
     source += fesaTemplates.genHBottom(className)
 
@@ -135,9 +137,9 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                     flagReg = True                    
                     if (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # string array
                         flagDim1 = True                    
-                        source += fesaTemplates.genCGetStringArrayReg(reg.prop('name'))
+                        source += fesaTemplates.genCGetStringArrayReg(reg.prop('name'), getFesaName(reg))
                     else:   # simple string
-                        source += fesaTemplates.genCGetStringReg(reg.prop('name'))
+                        source += fesaTemplates.genCGetStringReg(reg.prop('name'), getFesaName(reg))
 
                 else:   # not string register
                     # uppercasing of type
@@ -150,26 +152,26 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetUnsignedArray2DReg(reg.prop('name'), fesaType, type)
+                            source += fesaTemplates.genCGetUnsignedArray2DReg(reg.prop('name'), getFesaName(reg), fesaType, type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetUnsignedArrayReg(reg.prop('name'), fesaType, type)
+                            source += fesaTemplates.genCGetUnsignedArrayReg(reg.prop('name'), getFesaName(reg), fesaType, type)
                         else:    # scalar
-                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), type) 
+                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), getFesaName(reg), type) 
                             
                     elif type[0] == 'd':    # date type
                         if reg.prop('array-dim2') and int(reg.prop('array-dim2')) > 1:
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetArray2DReg(reg.prop('name'), 'Date')
+                            source += fesaTemplates.genCGetArray2DReg(reg.prop('name'), getFesaName(reg), 'Date')
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetArrayReg(reg.prop('name'), 'Date')
+                            source += fesaTemplates.genCGetArrayReg(reg.prop('name'), getFesaName(reg), 'Date')
                         else:    # scalar
-                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), 'Date')
+                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), getFesaName(reg), 'Date')
                         
                     else:
                         type = type[:1].upper() + type[1:]  # only first character if not unsigned
@@ -177,13 +179,13 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetArray2DReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCGetArray2DReg(reg.prop('name'), getFesaName(reg), type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCGetArrayReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCGetArrayReg(reg.prop('name'), getFesaName(reg), type)
                         else:    # scalar
-                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCGetScalarReg(reg.prop('name'), getFesaName(reg), type)
             
             source += '\n\t}'   # closing bracket for block
 
@@ -213,9 +215,9 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                     flagReg = True                    
                     if (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # string array
                         flagDim1 = True                    
-                        source += fesaTemplates.genCSetStringArrayReg(reg.prop('name'))
+                        source += fesaTemplates.genCSetStringArrayReg(reg.prop('name'), getFesaName(reg))
                     else:   # simple string
-                        source += fesaTemplates.genCSetStringReg(reg.prop('name'))
+                        source += fesaTemplates.genCSetStringReg(reg.prop('name'), getFesaName(reg))
                 
                 else:   # not string register              
                     # uppercasing of type
@@ -228,13 +230,13 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetUnsignedArray2DReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetUnsignedArray2DReg(reg.prop('name'), getFesaName(reg), type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetUnsignedArrayReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetUnsignedArrayReg(reg.prop('name'), getFesaName(reg), type)
                         else:    # scalar
-                            source += fesaTemplates.genCSetScalarUReg(reg.prop('name'), type, lowerType)
+                            source += fesaTemplates.genCSetScalarUReg(reg.prop('name'), getFesaName(reg), type, lowerType)
     
                     else:   # signed type
                         type = type[:1].upper() + type[1:]  # only first character if not unsigned
@@ -242,13 +244,13 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetArray2DReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetArray2DReg(reg.prop('name'), getFesaName(reg), type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetArrayReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetArrayReg(reg.prop('name'), getFesaName(reg), type)
                         else:    # scalar
-                            source += fesaTemplates.genCSetScalarReg(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetScalarReg(reg.prop('name'), getFesaName(reg), type)
 
             source += fesaTemplates.cSend
             source += '\n\t}'   # closing bracket for block
@@ -268,7 +270,7 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
             flagDim1 = False
             flagDim2 = False
     
-            finalSource += fesaTemplates.genCDatatypeSet(block.prop('name'),className)
+            finalSource += fesaTemplates.genCDatatypeSet(block.prop('name'),getFesaName(block), className)
             
             regList = block.xpathEval('Register')
             
@@ -278,9 +280,9 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                     flagReg = True                    
                     if (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # string array
                         flagDim1 = True                    
-                        source += fesaTemplates.genCSetStringArrayRegData(reg.prop('name'))
+                        source += fesaTemplates.genCSetStringArrayRegData(reg.prop('name'), getFesaName(reg))
                     else:   # simple string
-                        source += fesaTemplates.genCSetStringRegData(reg.prop('name'))
+                        source += fesaTemplates.genCSetStringRegData(reg.prop('name'), getFesaName(reg))
                 
                 else:   # not string register
                     # uppercasing of type
@@ -293,13 +295,13 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetUnsignedArray2DRegData(reg.prop('name'), fesaType, type)
+                            source += fesaTemplates.genCSetUnsignedArray2DRegData(reg.prop('name'), getFesaName(reg), fesaType, type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetUnsignedArrayRegData(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetUnsignedArrayRegData(reg.prop('name'), getFesaName(reg), type)
                         else:    # scalar
-                            source += fesaTemplates.genCSetScalarURegData(reg.prop('name'), type, lowerType)
+                            source += fesaTemplates.genCSetScalarURegData(reg.prop('name'), getFesaName(reg), type, lowerType)
                             
                     else:   # signed type
                         type = type[:1].upper() + type[1:]  # only first character if not unsigned
@@ -307,13 +309,13 @@ def genCppSource(className, silecsRoot, fesaRoot, sourcePath,logTopics):
                             flagReg = True                    
                             flagDim2 = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetArray2DRegData(reg.prop('name'), fesaType, type)
+                            source += fesaTemplates.genCSetArray2DRegData(reg.prop('name'), getFesaName(reg), fesaType, type)
                         elif (reg.prop('array-dim1')) and int(reg.prop('array-dim1')) > 1:   # array
                             flagReg = True                    
                             flagDim1 = True                    
-                            source += fesaTemplates.genCSetArrayRegData(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetArrayRegData(reg.prop('name'), getFesaName(reg), type)
                         else:    # scalar
-                            source += fesaTemplates.genCSetScalarRegData(reg.prop('name'), type)
+                            source += fesaTemplates.genCSetScalarRegData(reg.prop('name'), getFesaName(reg), type)
              
             source += fesaTemplates.cSend
             source += '\n\t}'   # closing bracket for block
diff --git a/silecs-codegen/src/xml/test/AllTypes.silecsdesign b/silecs-codegen/src/xml/test/AllTypes.silecsdesign
index a92fd2e..c9e16e9 100644
--- a/silecs-codegen/src/xml/test/AllTypes.silecsdesign
+++ b/silecs-codegen/src/xml/test/AllTypes.silecsdesign
@@ -1,77 +1,77 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <SILECS-Design silecs-version="0.10.0" created="06/27/16" updated="06/27/16" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:noNamespaceSchemaLocation="/common/home/bel/schwinn/lnx/workspace-silecs-mars/silecs-model/src/xml/DesignSchema.xsd">
+    xsi:noNamespaceSchemaLocation="/common/home/bel/schwinn/lnx/git/silecs-model/src/xml/DesignSchema.xsd">
     <Information>
         <Owner user-login="schwinn"/>
         <Editor user-login="schwinn"/>
     </Information>
     <SILECS-Class name="AllTypes" version="0.1.0" domain="OPERATIONAL" >
-        <Block name="MyROBlock" mode="READ-ONLY" generateFesaProperty="true">
-            <Register name="RO_int8" format="int8" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" />
-            <!--<Register name="RO_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="RO_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="RO_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" />
-            <!--<Register name="RO_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <Register name="RO_string" format="string" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_date" format="date" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_char" format="char" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_word" format="word" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int" format="int" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_real" format="real" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" />
+        <Block name="MyROBlock" mode="READ-ONLY" generateFesaProperty="true" fesaPropertyName="MyROBlockProp">
+            <Register name="RO_int8" format="int8" synchro="MASTER" generateFesaValueItem="true"/>
+            <Register name="RO_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint8_fesa"/>
+            <Register name="RO_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int16_fesa"/>
+            <Register name="RO_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint16_fesa"/>
+            <Register name="RO_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int32_fesa"/>
+            <Register name="RO_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint32_fesa"/>
+            <!--<Register name="RO_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int64_fesa"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <!--<Register name="RO_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint64_fesa"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="RO_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_float32_fesa"/>
+            <!--<Register name="RO_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" esaFieldName="RO_float64_fesa"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="RO_string" format="string" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_string_fesa"/>
+            <Register name="RO_date" format="date" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_date_fesa"/>
+            <Register name="RO_char" format="char" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_char_fesa"/>
+            <Register name="RO_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_byte_fesa"/>
+            <Register name="RO_word" format="word" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_word_fesa"/>
+            <Register name="RO_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dword_fesa"/>
+            <Register name="RO_int" format="int" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int_fesa"/>
+            <Register name="RO_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dint_fesa"/>
+            <Register name="RO_real" format="real" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_real_fesa"/>
+            <Register name="RO_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dt_fesa"/>
         </Block>
-        <Block name="MyRWBlock" generateFesaProperty="true" mode="READ-WRITE">
+        <Block name="MyRWBlock" generateFesaProperty="true" fesaPropertyName="MyRWBlockProp" mode="READ-WRITE">
             <Register name="RW_int8" format="int8" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2" />
-            <Register name="RW_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <!--  <Register name="RW_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="RW_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="RW_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <!--<Register name="RW_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <Register name="RW_string" format="string" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_date" format="date" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_char" format="char" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_word" format="word" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int" format="int" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_real" format="real" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint8_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int16_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint16_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int32_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint32_fesa" array-dim1="2" array-dim2="2"/>
+            <!--<Register name="RW_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <!--<Register name="RW_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="RW_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_float32_fesa" array-dim1="2" array-dim2="2"/>
+            <!--<Register name="RW_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_float64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="RW_string" format="string" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_string_fesa" array-dim1="2" array-dim2="2"/> 
+            <Register name="RW_date" format="date" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_date_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_char" format="char" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_char_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_byte_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_word" format="word" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_word_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dword_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int" format="int" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dint_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_real" format="real" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_real_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dt_fesa" array-dim1="2" array-dim2="2"/>
         </Block>
-        <Block name="MyWOBlock" generateFesaProperty="true" mode="WRITE-ONLY">
+        <Block name="MyWOBlock" generateFesaProperty="true" fesaPropertyName="MyWOBlockProp" mode="WRITE-ONLY">
             <Register name="WO_int8" format="int8" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint8" format="uint8" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int16" format="int16" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint16" format="uint16" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int32" format="int32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint32" format="uint32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <!--<Register name="WO_int64" format="int64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="WO_uint64" format="uint64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="WO_float32" format="float32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <!--<Register name="WO_float64" format="float64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <Register name="WO_string" format="string" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_date" format="date" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_char" format="char" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_byte" format="byte" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_word" format="word" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dword" format="dword" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int" format="int" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dint" format="dint" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_real" format="real" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dt" format="dt" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
+            <Register name="WO_uint8" format="uint8" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint8_fesa" array-dim1="10"/>
+            <Register name="WO_int16" format="int16" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int16_fesa" array-dim1="10"/>
+            <Register name="WO_uint16" format="uint16" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint16_fesa" array-dim1="10"/>
+            <Register name="WO_int32" format="int32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int32_fesa" array-dim1="10"/>
+            <Register name="WO_uint32" format="uint32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint32_fesa" array-dim1="10"/>
+            <!--<Register name="WO_int64" format="int64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int64_fesa" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <!--<Register name="WO_uint64" format="uint64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint64_fesa" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="WO_float32" format="float32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_float32_fesa" array-dim1="10"/>
+            <!--<Register name="WO_float64" format="float64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_float64_fesa" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="WO_string" format="string" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_string_fesa" array-dim1="10"/>
+            <Register name="WO_date" format="date" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_date_fesa" array-dim1="10"/>
+            <Register name="WO_char" format="char" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_char_fesa" array-dim1="10"/>
+            <Register name="WO_byte" format="byte" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_byte_fesa" array-dim1="10"/>
+            <Register name="WO_word" format="word" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_word_fesa" array-dim1="10"/>
+            <Register name="WO_dword" format="dword" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dword_fesa" array-dim1="10"/>
+            <Register name="WO_int" format="int" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int_fesa" array-dim1="10"/>
+            <Register name="WO_dint" format="dint" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dint_fesa" array-dim1="10"/>
+            <Register name="WO_real" format="real" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_real_fesa" array-dim1="10"/>
+            <Register name="WO_dt" format="dt" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dt_fesa" array-dim1="10"/>
         </Block>
     </SILECS-Class>
 </SILECS-Design>
diff --git a/silecs-codegen/src/xml/test/AllTypesFESA.silecsdesign b/silecs-codegen/src/xml/test/AllTypesFESA.silecsdesign
index 01c9edf..238d245 100644
--- a/silecs-codegen/src/xml/test/AllTypesFESA.silecsdesign
+++ b/silecs-codegen/src/xml/test/AllTypesFESA.silecsdesign
@@ -1,77 +1,77 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <SILECS-Design silecs-version="0.10.0" created="06/27/16" updated="06/27/16" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:noNamespaceSchemaLocation="/common/home/bel/schwinn/lnx/workspace-silecs-mars/silecs-model/src/xml/DesignSchema.xsd">
+    xsi:noNamespaceSchemaLocation="/common/home/bel/schwinn/lnx/git/silecs-model/src/xml/DesignSchema.xsd">
     <Information>
         <Owner user-login="schwinn"/>
         <Editor user-login="schwinn"/>
     </Information>
     <SILECS-Class name="AllTypesFESA" version="0.1.0" domain="OPERATIONAL" >
-        <Block name="MyROBlock" mode="READ-ONLY" generateFesaProperty="true">
-            <Register name="RO_int8" format="int8" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" />
-            <!--<Register name="RO_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="RO_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="RO_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" />
-            <!--<Register name="RO_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" /> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <Register name="RO_string" format="string" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_date" format="date" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_char" format="char" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_word" format="word" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_int" format="int" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_real" format="real" synchro="MASTER" generateFesaValueItem="true" />
-            <Register name="RO_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" />
+        <Block name="MyROBlock" mode="READ-ONLY" generateFesaProperty="true" fesaPropertyName="MyROBlockProp">
+            <Register name="RO_int8" format="int8" synchro="MASTER" generateFesaValueItem="true"/>
+            <Register name="RO_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint8_fesa"/>
+            <Register name="RO_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int16_fesa"/>
+            <Register name="RO_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint16_fesa"/>
+            <Register name="RO_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int32_fesa"/>
+            <Register name="RO_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint32_fesa"/>
+            <!--<Register name="RO_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int64_fesa"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <!--<Register name="RO_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_uint64_fesa"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <Register name="RO_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_float32_fesa"/>
+            <!--<Register name="RO_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" esaFieldName="RO_float64_fesa"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="RO_string" format="string" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_string_fesa"/>
+            <Register name="RO_date" format="date" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_date_fesa"/>
+            <Register name="RO_char" format="char" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_char_fesa"/>
+            <Register name="RO_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_byte_fesa"/>
+            <Register name="RO_word" format="word" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_word_fesa"/>
+            <Register name="RO_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dword_fesa"/>
+            <Register name="RO_int" format="int" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_int_fesa"/>
+            <Register name="RO_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dint_fesa"/>
+            <Register name="RO_real" format="real" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_real_fesa"/>
+            <Register name="RO_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RO_dt_fesa"/>
         </Block>
-        <Block name="MyRWBlock" generateFesaProperty="true" mode="READ-WRITE">
+        <Block name="MyRWBlock" generateFesaProperty="true" fesaPropertyName="MyRWBlockProp" mode="READ-WRITE">
             <Register name="RW_int8" format="int8" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2" />
-            <Register name="RW_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <!--  <Register name="RW_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="RW_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="RW_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <!--<Register name="RW_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <!--  <Register name="RW_string" format="string" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/> 2d string arrays not supported in FESA --> 
-            <Register name="RW_date" format="date" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_char" format="char" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_word" format="word" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_int" format="int" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_real" format="real" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
-            <Register name="RW_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint8" format="uint8" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint8_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int16" format="int16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int16_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint16" format="uint16" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint16_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int32" format="int32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int32_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_uint32" format="uint32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint32_fesa" array-dim1="2" array-dim2="2"/>
+            <!--  <Register name="RW_int64" format="int64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <!--<Register name="RW_uint64" format="uint64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_uint64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <Register name="RW_float32" format="float32" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_float32_fesa" array-dim1="2" array-dim2="2"/>
+            <!--<Register name="RW_float64" format="float64" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_float64_fesa" array-dim1="2" array-dim2="2"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <!--  <Register name="RW_string" format="string" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_string_fesa" array-dim1="2" array-dim2="2"/> 2d string arrays not supported in FESA --> 
+            <Register name="RW_date" format="date" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_date_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_char" format="char" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_char_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_byte" format="byte" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_byte_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_word" format="word" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_word_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dword" format="dword" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dword_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_int" format="int" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_int_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dint" format="dint" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dint_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_real" format="real" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_real_fesa" array-dim1="2" array-dim2="2"/>
+            <Register name="RW_dt" format="dt" synchro="MASTER" generateFesaValueItem="true" fesaFieldName="RW_dt_fesa" array-dim1="2" array-dim2="2"/>
         </Block>
-        <Block name="MyWOBlock" generateFesaProperty="true" mode="WRITE-ONLY">
+        <Block name="MyWOBlock" generateFesaProperty="true" fesaPropertyName="MyWOBlockProp" mode="WRITE-ONLY">
             <Register name="WO_int8" format="int8" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint8" format="uint8" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int16" format="int16" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint16" format="uint16" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int32" format="int32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_uint32" format="uint32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <!--<Register name="WO_int64" format="int64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <!--<Register name="WO_uint64" format="uint64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
-            <Register name="WO_float32" format="float32" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <!--<Register name="WO_float64" format="float64" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
-            <Register name="WO_string" format="string" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_date" format="date" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_char" format="char" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_byte" format="byte" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_word" format="word" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dword" format="dword" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_int" format="int" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dint" format="dint" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_real" format="real" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
-            <Register name="WO_dt" format="dt" synchro="SLAVE" generateFesaValueItem="true" array-dim1="10"/>
+            <Register name="WO_uint8" format="uint8" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint8_fesa" array-dim1="10"/>
+            <Register name="WO_int16" format="int16" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int16_fesa" array-dim1="10"/>
+            <Register name="WO_uint16" format="uint16" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint16_fesa" array-dim1="10"/>
+            <Register name="WO_int32" format="int32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int32_fesa" array-dim1="10"/>
+            <Register name="WO_uint32" format="uint32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint32_fesa" array-dim1="10"/>
+            <!--<Register name="WO_int64" format="int64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int64_fesa" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <!--<Register name="WO_uint64" format="uint64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_uint64_fesa" array-dim1="10"/> not Supported for Beckhoff, Siemens and Schneider-->
+            <Register name="WO_float32" format="float32" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_float32_fesa" array-dim1="10"/>
+            <!--<Register name="WO_float64" format="float64" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_float64_fesa" array-dim1="10"/> not Supported for Rabbit, Beckhoff, Siemens and Schneider-->
+            <Register name="WO_string" format="string" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_string_fesa" array-dim1="10"/>
+            <Register name="WO_date" format="date" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_date_fesa" array-dim1="10"/>
+            <Register name="WO_char" format="char" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_char_fesa" array-dim1="10"/>
+            <Register name="WO_byte" format="byte" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_byte_fesa" array-dim1="10"/>
+            <Register name="WO_word" format="word" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_word_fesa" array-dim1="10"/>
+            <Register name="WO_dword" format="dword" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dword_fesa" array-dim1="10"/>
+            <Register name="WO_int" format="int" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_int_fesa" array-dim1="10"/>
+            <Register name="WO_dint" format="dint" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dint_fesa" array-dim1="10"/>
+            <Register name="WO_real" format="real" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_real_fesa" array-dim1="10"/>
+            <Register name="WO_dt" format="dt" synchro="SLAVE" generateFesaValueItem="true" fesaFieldName="WO_dt_fesa" array-dim1="10"/>
         </Block>
     </SILECS-Class>
 </SILECS-Design>
diff --git a/silecs-codegen/src/xml/test/generated_correct/AllTypes.cpp b/silecs-codegen/src/xml/test/generated_correct/AllTypes.cpp
index 08c4d7f..ac67399 100644
--- a/silecs-codegen/src/xml/test/generated_correct/AllTypes.cpp
+++ b/silecs-codegen/src/xml/test/generated_correct/AllTypes.cpp
@@ -196,24 +196,24 @@ namespace AllTypes
         if (recvNow) pPLCDevice -> recv(blockName_);        
     
         pDevice->RO_int8.set( pPLCDevice->getRegister("RO_int8")->getValInt8(), pContext);
-        pDevice->RO_uint8.set( pPLCDevice->getRegister("RO_uint8")->getValUInt8(), pContext);
-        pDevice->RO_int16.set( pPLCDevice->getRegister("RO_int16")->getValInt16(), pContext);
-        pDevice->RO_uint16.set( pPLCDevice->getRegister("RO_uint16")->getValUInt16(), pContext);
-        pDevice->RO_int32.set( pPLCDevice->getRegister("RO_int32")->getValInt32(), pContext);
-        pDevice->RO_uint32.set( pPLCDevice->getRegister("RO_uint32")->getValUInt32(), pContext);
-        pDevice->RO_float32.set( pPLCDevice->getRegister("RO_float32")->getValFloat32(), pContext);
+        pDevice->RO_uint8_fesa.set( pPLCDevice->getRegister("RO_uint8")->getValUInt8(), pContext);
+        pDevice->RO_int16_fesa.set( pPLCDevice->getRegister("RO_int16")->getValInt16(), pContext);
+        pDevice->RO_uint16_fesa.set( pPLCDevice->getRegister("RO_uint16")->getValUInt16(), pContext);
+        pDevice->RO_int32_fesa.set( pPLCDevice->getRegister("RO_int32")->getValInt32(), pContext);
+        pDevice->RO_uint32_fesa.set( pPLCDevice->getRegister("RO_uint32")->getValUInt32(), pContext);
+        pDevice->RO_float32_fesa.set( pPLCDevice->getRegister("RO_float32")->getValFloat32(), pContext);
         pRegister = pPLCDevice->getRegister("RO_string");
-        pDevice->RO_string.set(pRegister->getValString().c_str(), pContext);
-
-        pDevice->RO_date.set( pPLCDevice->getRegister("RO_date")->getValDate(), pContext);
-        pDevice->RO_char.set( pPLCDevice->getRegister("RO_char")->getValInt8(), pContext);
-        pDevice->RO_byte.set( pPLCDevice->getRegister("RO_byte")->getValUInt8(), pContext);
-        pDevice->RO_word.set( pPLCDevice->getRegister("RO_word")->getValUInt16(), pContext);
-        pDevice->RO_dword.set( pPLCDevice->getRegister("RO_dword")->getValUInt32(), pContext);
-        pDevice->RO_int.set( pPLCDevice->getRegister("RO_int")->getValInt16(), pContext);
-        pDevice->RO_dint.set( pPLCDevice->getRegister("RO_dint")->getValInt32(), pContext);
-        pDevice->RO_real.set( pPLCDevice->getRegister("RO_real")->getValFloat32(), pContext);
-        pDevice->RO_dt.set( pPLCDevice->getRegister("RO_dt")->getValDate(), pContext);
+        pDevice->RO_string_fesa.set(pRegister->getValString().c_str(), pContext);
+
+        pDevice->RO_date_fesa.set( pPLCDevice->getRegister("RO_date")->getValDate(), pContext);
+        pDevice->RO_char_fesa.set( pPLCDevice->getRegister("RO_char")->getValInt8(), pContext);
+        pDevice->RO_byte_fesa.set( pPLCDevice->getRegister("RO_byte")->getValUInt8(), pContext);
+        pDevice->RO_word_fesa.set( pPLCDevice->getRegister("RO_word")->getValUInt16(), pContext);
+        pDevice->RO_dword_fesa.set( pPLCDevice->getRegister("RO_dword")->getValUInt32(), pContext);
+        pDevice->RO_int_fesa.set( pPLCDevice->getRegister("RO_int")->getValInt16(), pContext);
+        pDevice->RO_dint_fesa.set( pPLCDevice->getRegister("RO_dint")->getValInt32(), pContext);
+        pDevice->RO_real_fesa.set( pPLCDevice->getRegister("RO_real")->getValFloat32(), pContext);
+        pDevice->RO_dt_fesa.set( pPLCDevice->getRegister("RO_dt")->getValDate(), pContext);
 	}
     void MyRWBlock_Type::getOneDevice(Device* pDevice, const bool recvNow, MultiplexingContext* pContext)
     {
@@ -239,56 +239,56 @@ namespace AllTypes
         dim2 = pRegister->getDimension2();
         int16_t* RW_uint8 = (int16_t*)calloc(dim1*dim2, sizeof(int16_t));
         pRegister->getValUInt8Array2D(RW_uint8, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_uint8.set(RW_uint8, dim1, dim2, pContext);
+        pDevice->RW_uint8_fesa.set(RW_uint8, dim1, dim2, pContext);
     free(RW_uint8);
 
         pRegister = pPLCDevice->getRegister("RW_int16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_int16.set(pRegister->getRefInt16Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_int16_fesa.set(pRegister->getRefInt16Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_uint16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
         int32_t* RW_uint16 = (int32_t*)calloc(dim1*dim2, sizeof(int32_t));
         pRegister->getValUInt16Array2D(RW_uint16, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_uint16.set(RW_uint16, dim1, dim2, pContext);
+        pDevice->RW_uint16_fesa.set(RW_uint16, dim1, dim2, pContext);
     free(RW_uint16);
 
         pRegister = pPLCDevice->getRegister("RW_int32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_int32.set(pRegister->getRefInt32Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_int32_fesa.set(pRegister->getRefInt32Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_uint32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
         int64_t* RW_uint32 = (int64_t*)calloc(dim1*dim2, sizeof(int64_t));
         pRegister->getValUInt32Array2D(RW_uint32, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_uint32.set(RW_uint32, dim1, dim2, pContext);
+        pDevice->RW_uint32_fesa.set(RW_uint32, dim1, dim2, pContext);
     free(RW_uint32);
 
         pRegister = pPLCDevice->getRegister("RW_float32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_float32.set(pRegister->getRefFloat32Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_float32_fesa.set(pRegister->getRefFloat32Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_date");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_date.set(pRegister->getRefDateArray2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_date_fesa.set(pRegister->getRefDateArray2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_char");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_char.set(pRegister->getRefInt8Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_char_fesa.set(pRegister->getRefInt8Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_byte");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
         int16_t* RW_byte = (int16_t*)calloc(dim1*dim2, sizeof(int16_t));
         pRegister->getValUInt8Array2D(RW_byte, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_byte.set(RW_byte, dim1, dim2, pContext);
+        pDevice->RW_byte_fesa.set(RW_byte, dim1, dim2, pContext);
     free(RW_byte);
 
         pRegister = pPLCDevice->getRegister("RW_word");
@@ -296,7 +296,7 @@ namespace AllTypes
         dim2 = pRegister->getDimension2();
         int32_t* RW_word = (int32_t*)calloc(dim1*dim2, sizeof(int32_t));
         pRegister->getValUInt16Array2D(RW_word, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_word.set(RW_word, dim1, dim2, pContext);
+        pDevice->RW_word_fesa.set(RW_word, dim1, dim2, pContext);
     free(RW_word);
 
         pRegister = pPLCDevice->getRegister("RW_dword");
@@ -304,28 +304,28 @@ namespace AllTypes
         dim2 = pRegister->getDimension2();
         int64_t* RW_dword = (int64_t*)calloc(dim1*dim2, sizeof(int64_t));
         pRegister->getValUInt32Array2D(RW_dword, dim1, dim2);	//use automatic conversion for JAVA non-supported type
-        pDevice->RW_dword.set(RW_dword, dim1, dim2, pContext);
+        pDevice->RW_dword_fesa.set(RW_dword, dim1, dim2, pContext);
     free(RW_dword);
 
         pRegister = pPLCDevice->getRegister("RW_int");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_int.set(pRegister->getRefInt16Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_int_fesa.set(pRegister->getRefInt16Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_dint");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_dint.set(pRegister->getRefInt32Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_dint_fesa.set(pRegister->getRefInt32Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_real");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_real.set(pRegister->getRefFloat32Array2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_real_fesa.set(pRegister->getRefFloat32Array2D(dim1, dim2), dim1, dim2, pContext);
 
         pRegister = pPLCDevice->getRegister("RW_dt");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pDevice->RW_dt.set(pRegister->getRefDateArray2D(dim1, dim2), dim1, dim2, pContext);
+        pDevice->RW_dt_fesa.set(pRegister->getRefDateArray2D(dim1, dim2), dim1, dim2, pContext);
 
 	}    
     void MyRWBlock_Type::setOneDevice(Device* pDevice, const bool sendNow, MultiplexingContext* pContext)
@@ -351,82 +351,82 @@ namespace AllTypes
         pRegister = pPLCDevice->getRegister("RW_uint8");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt8Array2D( pDevice->RW_uint8.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt8Array2D( pDevice->RW_uint8_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
     pRegister = pPLCDevice->getRegister("RW_int16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValInt16Array2D(pDevice->RW_int16.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValInt16Array2D(pDevice->RW_int16_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_uint16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt16Array2D( pDevice->RW_uint16.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt16Array2D( pDevice->RW_uint16_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
     pRegister = pPLCDevice->getRegister("RW_int32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValInt32Array2D(pDevice->RW_int32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValInt32Array2D(pDevice->RW_int32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_uint32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt32Array2D( pDevice->RW_uint32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt32Array2D( pDevice->RW_uint32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
     pRegister = pPLCDevice->getRegister("RW_float32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValFloat32Array2D(pDevice->RW_float32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValFloat32Array2D(pDevice->RW_float32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
     pRegister = pPLCDevice->getRegister("RW_date");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValDateArray2D(pDevice->RW_date.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValDateArray2D(pDevice->RW_date_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
     pRegister = pPLCDevice->getRegister("RW_char");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValInt8Array2D(pDevice->RW_char.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValInt8Array2D(pDevice->RW_char_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_byte");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt8Array2D( pDevice->RW_byte.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt8Array2D( pDevice->RW_byte_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("RW_word");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt16Array2D( pDevice->RW_word.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt16Array2D( pDevice->RW_word_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("RW_dword");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValUInt32Array2D( pDevice->RW_dword.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt32Array2D( pDevice->RW_dword_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);	//use automatic conversion for JAVA non-supported type
 
     pRegister = pPLCDevice->getRegister("RW_int");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValInt16Array2D(pDevice->RW_int.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValInt16Array2D(pDevice->RW_int_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
     pRegister = pPLCDevice->getRegister("RW_dint");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValInt32Array2D(pDevice->RW_dint.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValInt32Array2D(pDevice->RW_dint_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
     pRegister = pPLCDevice->getRegister("RW_real");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValFloat32Array2D(pDevice->RW_real.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValFloat32Array2D(pDevice->RW_real_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
     pRegister = pPLCDevice->getRegister("RW_dt");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        pRegister->setValDateArray2D(pDevice->RW_dt.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        pRegister->setValDateArray2D(pDevice->RW_dt_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         if (sendNow) pPLCDevice->send(blockName_);
 
 	}
-    void MyRWBlock_Type::setOneDevice(Device* pDevice, MyRWBlockPropertyData& data, bool sendNow, MultiplexingContext* pContext)
+    void MyRWBlock_Type::setOneDevice(Device* pDevice, MyRWBlockPropPropertyData& data, bool sendNow, MultiplexingContext* pContext)
     {
     	if( !isInitialized_ )
     	{
@@ -444,98 +444,98 @@ namespace AllTypes
         pRegister = pPLCDevice->getRegister("RW_int8");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_int8Available()) ? pRegister->setValInt8Array2D(data.RW_int8.get(fesaDim1, fesaDim2), dim1, dim2) :
+        (_upper}Available()) ? pRegister->setValInt8Array2D(data.RW_int8.get(fesaDim1, fesaDim2), dim1, dim2) :
                                      pRegister->setValInt8Array2D(pDevice->RW_int8.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_uint8");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_uint8Available()) ? pRegister->setValUInt8Array2D(data.RW_uint8.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt8Array2D(pDevice->RW_uint8.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_uint8_fesaAvailable()) ? pRegister->setValUInt8Array2D(data.RW_uint8_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt8Array2D(pDevice->RW_uint8_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_int16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_int16Available()) ? pRegister->setValInt16Array2D(data.RW_int16.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValInt16Array2D(pDevice->RW_int16.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValInt16Array2D(data.RW_int16_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValInt16Array2D(pDevice->RW_int16_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_uint16");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_uint16Available()) ? pRegister->setValUInt16Array2D(data.RW_uint16.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt16Array2D(pDevice->RW_uint16.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_uint16_fesaAvailable()) ? pRegister->setValUInt16Array2D(data.RW_uint16_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt16Array2D(pDevice->RW_uint16_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_int32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_int32Available()) ? pRegister->setValInt32Array2D(data.RW_int32.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValInt32Array2D(pDevice->RW_int32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValInt32Array2D(data.RW_int32_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValInt32Array2D(pDevice->RW_int32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_uint32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_uint32Available()) ? pRegister->setValUInt32Array2D(data.RW_uint32.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt32Array2D(pDevice->RW_uint32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_uint32_fesaAvailable()) ? pRegister->setValUInt32Array2D(data.RW_uint32_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt32Array2D(pDevice->RW_uint32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_float32");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_float32Available()) ? pRegister->setValFloat32Array2D(data.RW_float32.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValFloat32Array2D(pDevice->RW_float32.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValFloat32Array2D(data.RW_float32_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValFloat32Array2D(pDevice->RW_float32_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_date");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_dateAvailable()) ? pRegister->setValDateArray2D(data.RW_date.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValDateArray2D(pDevice->RW_date.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValDateArray2D(data.RW_date_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValDateArray2D(pDevice->RW_date_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_char");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_charAvailable()) ? pRegister->setValInt8Array2D(data.RW_char.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValInt8Array2D(pDevice->RW_char.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValInt8Array2D(data.RW_char_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValInt8Array2D(pDevice->RW_char_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_byte");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_byteAvailable()) ? pRegister->setValUInt8Array2D(data.RW_byte.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt8Array2D(pDevice->RW_byte.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_byte_fesaAvailable()) ? pRegister->setValUInt8Array2D(data.RW_byte_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt8Array2D(pDevice->RW_byte_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_word");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_wordAvailable()) ? pRegister->setValUInt16Array2D(data.RW_word.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt16Array2D(pDevice->RW_word.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_word_fesaAvailable()) ? pRegister->setValUInt16Array2D(data.RW_word_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt16Array2D(pDevice->RW_word_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_dword");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_dwordAvailable()) ? pRegister->setValUInt32Array2D(data.RW_dword.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValUInt32Array2D(pDevice->RW_dword.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (data.isRW_dword_fesaAvailable()) ? pRegister->setValUInt32Array2D(data.RW_dword_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValUInt32Array2D(pDevice->RW_dword_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_int");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_intAvailable()) ? pRegister->setValInt16Array2D(data.RW_int.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValInt16Array2D(pDevice->RW_int.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValInt16Array2D(data.RW_int_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValInt16Array2D(pDevice->RW_int_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_dint");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_dintAvailable()) ? pRegister->setValInt32Array2D(data.RW_dint.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValInt32Array2D(pDevice->RW_dint.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValInt32Array2D(data.RW_dint_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValInt32Array2D(pDevice->RW_dint_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_real");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_realAvailable()) ? pRegister->setValFloat32Array2D(data.RW_real.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValFloat32Array2D(pDevice->RW_real.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValFloat32Array2D(data.RW_real_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValFloat32Array2D(pDevice->RW_real_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         pRegister = pPLCDevice->getRegister("RW_dt");
         dim1 = pRegister->getDimension1();
         dim2 = pRegister->getDimension2();
-        (data.isRW_dtAvailable()) ? pRegister->setValDateArray2D(data.RW_dt.get(fesaDim1, fesaDim2), dim1, dim2) :
-                                     pRegister->setValDateArray2D(pDevice->RW_dt.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
+        (_upper}Available()) ? pRegister->setValDateArray2D(data.RW_dt_fesa.get(fesaDim1, fesaDim2), dim1, dim2) :
+                                     pRegister->setValDateArray2D(pDevice->RW_dt_fesa.get(fesaDim1, fesaDim2, pContext), dim1, dim2);
 
         if (sendNow) pPLCDevice->send(blockName_);
 
@@ -560,77 +560,77 @@ namespace AllTypes
     
         pRegister = pPLCDevice->getRegister("WO_uint8");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt8Array(pDevice->WO_uint8.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt8Array(pDevice->WO_uint8_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_int16");
             dim1 = pRegister->getDimension1();
-            pRegister->setValInt16Array(pDevice->WO_int16.get(fesaDim1, pContext), dim1);
+            pRegister->setValInt16Array(pDevice->WO_int16_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_uint16");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt16Array(pDevice->WO_uint16.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt16Array(pDevice->WO_uint16_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_int32");
             dim1 = pRegister->getDimension1();
-            pRegister->setValInt32Array(pDevice->WO_int32.get(fesaDim1, pContext), dim1);
+            pRegister->setValInt32Array(pDevice->WO_int32_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_uint32");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt32Array(pDevice->WO_uint32.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt32Array(pDevice->WO_uint32_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_float32");
             dim1 = pRegister->getDimension1();
-            pRegister->setValFloat32Array(pDevice->WO_float32.get(fesaDim1, pContext), dim1);
+            pRegister->setValFloat32Array(pDevice->WO_float32_fesa.get(fesaDim1, pContext), dim1);
     
         {
         pRegister = pPLCDevice->getRegister("WO_string");
         dim1 = pRegister->getDimension1();
         std::string stdStringArray[dim1];
-        const char** cStringArray = pDevice->WO_string.get(fesaDim1, pContext);
+        const char** cStringArray = pDevice->WO_string_fesa.get(fesaDim1, pContext);
         for (unsigned int i=0; i<dim1; i++) stdStringArray[i] = (const char*)cStringArray[i];
         pRegister->setValStringArray(stdStringArray, dim1);
         }
 
         pRegister = pPLCDevice->getRegister("WO_date");
             dim1 = pRegister->getDimension1();
-            pRegister->setValDateArray(pDevice->WO_date.get(fesaDim1, pContext), dim1);
+            pRegister->setValDateArray(pDevice->WO_date_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_char");
             dim1 = pRegister->getDimension1();
-            pRegister->setValInt8Array(pDevice->WO_char.get(fesaDim1, pContext), dim1);
+            pRegister->setValInt8Array(pDevice->WO_char_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_byte");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt8Array(pDevice->WO_byte.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt8Array(pDevice->WO_byte_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_word");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt16Array(pDevice->WO_word.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt16Array(pDevice->WO_word_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_dword");
         dim1 = pRegister->getDimension1();
-        pRegister->setValUInt32Array(pDevice->WO_dword.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
+        pRegister->setValUInt32Array(pDevice->WO_dword_fesa.get(fesaDim1, pContext), dim1);	//use automatic conversion for JAVA non-supported type
 
         pRegister = pPLCDevice->getRegister("WO_int");
             dim1 = pRegister->getDimension1();
-            pRegister->setValInt16Array(pDevice->WO_int.get(fesaDim1, pContext), dim1);
+            pRegister->setValInt16Array(pDevice->WO_int_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_dint");
             dim1 = pRegister->getDimension1();
-            pRegister->setValInt32Array(pDevice->WO_dint.get(fesaDim1, pContext), dim1);
+            pRegister->setValInt32Array(pDevice->WO_dint_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_real");
             dim1 = pRegister->getDimension1();
-            pRegister->setValFloat32Array(pDevice->WO_real.get(fesaDim1, pContext), dim1);
+            pRegister->setValFloat32Array(pDevice->WO_real_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_dt");
             dim1 = pRegister->getDimension1();
-            pRegister->setValDateArray(pDevice->WO_dt.get(fesaDim1, pContext), dim1);
+            pRegister->setValDateArray(pDevice->WO_dt_fesa.get(fesaDim1, pContext), dim1);
     
         if (sendNow) pPLCDevice->send(blockName_);
 
 	}
-    void MyWOBlock_Type::setOneDevice(Device* pDevice, MyWOBlockPropertyData& data, bool sendNow, MultiplexingContext* pContext)
+    void MyWOBlock_Type::setOneDevice(Device* pDevice, MyWOBlockPropPropertyData& data, bool sendNow, MultiplexingContext* pContext)
     {
     	if( !isInitialized_ )
     	{
@@ -650,87 +650,87 @@ namespace AllTypes
     
         pRegister = pPLCDevice->getRegister("WO_uint8");
             dim1 = pRegister->getDimension1();
-            (data.isWO_uint8Available()) ? pRegister->setValUInt8Array( data.WO_uint8.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt8Array( pDevice->WO_uint8.get(fesaDim1, pContext), dim1);
+            (data.isWO_uint8_fesaAvailable()) ? pRegister->setValUInt8Array( data.WO_uint8_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt8Array( pDevice->WO_uint8_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_int16");
             dim1 = pRegister->getDimension1();
-            (data.isWO_int16Available()) ? pRegister->setValInt16Array( data.WO_int16.get(fesaDim1), dim1) :
-                                         pRegister->setValInt16Array( pDevice->WO_int16.get(fesaDim1, pContext), dim1);
+            (data.isWO_int16_fesaAvailable()) ? pRegister->setValInt16Array( data.WO_int16_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValInt16Array( pDevice->WO_int16_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_uint16");
             dim1 = pRegister->getDimension1();
-            (data.isWO_uint16Available()) ? pRegister->setValUInt16Array( data.WO_uint16.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt16Array( pDevice->WO_uint16.get(fesaDim1, pContext), dim1);
+            (data.isWO_uint16_fesaAvailable()) ? pRegister->setValUInt16Array( data.WO_uint16_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt16Array( pDevice->WO_uint16_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_int32");
             dim1 = pRegister->getDimension1();
-            (data.isWO_int32Available()) ? pRegister->setValInt32Array( data.WO_int32.get(fesaDim1), dim1) :
-                                         pRegister->setValInt32Array( pDevice->WO_int32.get(fesaDim1, pContext), dim1);
+            (data.isWO_int32_fesaAvailable()) ? pRegister->setValInt32Array( data.WO_int32_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValInt32Array( pDevice->WO_int32_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_uint32");
             dim1 = pRegister->getDimension1();
-            (data.isWO_uint32Available()) ? pRegister->setValUInt32Array( data.WO_uint32.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt32Array( pDevice->WO_uint32.get(fesaDim1, pContext), dim1);
+            (data.isWO_uint32_fesaAvailable()) ? pRegister->setValUInt32Array( data.WO_uint32_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt32Array( pDevice->WO_uint32_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_float32");
             dim1 = pRegister->getDimension1();
-            (data.isWO_float32Available()) ? pRegister->setValFloat32Array( data.WO_float32.get(fesaDim1), dim1) :
-                                         pRegister->setValFloat32Array( pDevice->WO_float32.get(fesaDim1, pContext), dim1);
+            (data.isWO_float32_fesaAvailable()) ? pRegister->setValFloat32Array( data.WO_float32_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValFloat32Array( pDevice->WO_float32_fesa.get(fesaDim1, pContext), dim1);
     
         {
         pRegister = pPLCDevice->getRegister("WO_string");
         dim1 = pRegister->getDimension1();
         std::string stdStringArray[dim1];
-        const char** cStringArray = (data.isWO_stringAvailable() ? data.WO_string.get(fesaDim1) : pDevice->WO_string.get(fesaDim1, pContext));
+        const char** cStringArray = (data.isWO_string_fesaAvailable() ? data.WO_string_fesa.get(fesaDim1) : pDevice->WO_string_fesa.get(fesaDim1, pContext));
         for (unsigned int i=0; i<dim1; i++) stdStringArray[i] = (const char*)cStringArray[i];
         pRegister->setValStringArray(stdStringArray, dim1);
         }
 
         pRegister = pPLCDevice->getRegister("WO_date");
             dim1 = pRegister->getDimension1();
-            (data.isWO_dateAvailable()) ? pRegister->setValDateArray( data.WO_date.get(fesaDim1), dim1) :
-                                         pRegister->setValDateArray( pDevice->WO_date.get(fesaDim1, pContext), dim1);
+            (data.isWO_date_fesaAvailable()) ? pRegister->setValDateArray( data.WO_date_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValDateArray( pDevice->WO_date_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_char");
             dim1 = pRegister->getDimension1();
-            (data.isWO_charAvailable()) ? pRegister->setValInt8Array( data.WO_char.get(fesaDim1), dim1) :
-                                         pRegister->setValInt8Array( pDevice->WO_char.get(fesaDim1, pContext), dim1);
+            (data.isWO_char_fesaAvailable()) ? pRegister->setValInt8Array( data.WO_char_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValInt8Array( pDevice->WO_char_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_byte");
             dim1 = pRegister->getDimension1();
-            (data.isWO_byteAvailable()) ? pRegister->setValUInt8Array( data.WO_byte.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt8Array( pDevice->WO_byte.get(fesaDim1, pContext), dim1);
+            (data.isWO_byte_fesaAvailable()) ? pRegister->setValUInt8Array( data.WO_byte_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt8Array( pDevice->WO_byte_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_word");
             dim1 = pRegister->getDimension1();
-            (data.isWO_wordAvailable()) ? pRegister->setValUInt16Array( data.WO_word.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt16Array( pDevice->WO_word.get(fesaDim1, pContext), dim1);
+            (data.isWO_word_fesaAvailable()) ? pRegister->setValUInt16Array( data.WO_word_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt16Array( pDevice->WO_word_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_dword");
             dim1 = pRegister->getDimension1();
-            (data.isWO_dwordAvailable()) ? pRegister->setValUInt32Array( data.WO_dword.get(fesaDim1), dim1) :
-                                         pRegister->setValUInt32Array( pDevice->WO_dword.get(fesaDim1, pContext), dim1);
+            (data.isWO_dword_fesaAvailable()) ? pRegister->setValUInt32Array( data.WO_dword_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValUInt32Array( pDevice->WO_dword_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_int");
             dim1 = pRegister->getDimension1();
-            (data.isWO_intAvailable()) ? pRegister->setValInt16Array( data.WO_int.get(fesaDim1), dim1) :
-                                         pRegister->setValInt16Array( pDevice->WO_int.get(fesaDim1, pContext), dim1);
+            (data.isWO_int_fesaAvailable()) ? pRegister->setValInt16Array( data.WO_int_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValInt16Array( pDevice->WO_int_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_dint");
             dim1 = pRegister->getDimension1();
-            (data.isWO_dintAvailable()) ? pRegister->setValInt32Array( data.WO_dint.get(fesaDim1), dim1) :
-                                         pRegister->setValInt32Array( pDevice->WO_dint.get(fesaDim1, pContext), dim1);
+            (data.isWO_dint_fesaAvailable()) ? pRegister->setValInt32Array( data.WO_dint_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValInt32Array( pDevice->WO_dint_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_real");
             dim1 = pRegister->getDimension1();
-            (data.isWO_realAvailable()) ? pRegister->setValFloat32Array( data.WO_real.get(fesaDim1), dim1) :
-                                         pRegister->setValFloat32Array( pDevice->WO_real.get(fesaDim1, pContext), dim1);
+            (data.isWO_real_fesaAvailable()) ? pRegister->setValFloat32Array( data.WO_real_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValFloat32Array( pDevice->WO_real_fesa.get(fesaDim1, pContext), dim1);
     
         pRegister = pPLCDevice->getRegister("WO_dt");
             dim1 = pRegister->getDimension1();
-            (data.isWO_dtAvailable()) ? pRegister->setValDateArray( data.WO_dt.get(fesaDim1), dim1) :
-                                         pRegister->setValDateArray( pDevice->WO_dt.get(fesaDim1, pContext), dim1);
+            (data.isWO_dt_fesaAvailable()) ? pRegister->setValDateArray( data.WO_dt_fesa.get(fesaDim1), dim1) :
+                                         pRegister->setValDateArray( pDevice->WO_dt_fesa.get(fesaDim1, pContext), dim1);
     
         if (sendNow) pPLCDevice->send(blockName_);
 
diff --git a/silecs-codegen/src/xml/test/generated_correct/AllTypes.h b/silecs-codegen/src/xml/test/generated_correct/AllTypes.h
index ead17ae..544c28a 100644
--- a/silecs-codegen/src/xml/test/generated_correct/AllTypes.h
+++ b/silecs-codegen/src/xml/test/generated_correct/AllTypes.h
@@ -10,8 +10,8 @@
 #include <SilecsService.h>
 #include <fesa-core/Synchronization/MultiplexingContext.h>
 #include <AllTypes/GeneratedCode/ServiceLocator.h>
-#include <AllTypes/Server/SendMyRWBlock.h>
-#include <AllTypes/Server/SendMyWOBlock.h>
+#include <AllTypes/Server/SendMyRWBlockProp.h>
+#include <AllTypes/Server/SendMyWOBlockProp.h>
 
 namespace AllTypes
 {
@@ -88,40 +88,40 @@ namespace AllTypes
     };
 
     // -------------------------------------------------------------------------------------------------
-    #define BLOCK_RO( name )	\
-    class name##_Type : public AbstractAllTypes	\
+    #define BLOCK_RO( blockName, propName )	\
+    class blockName##_Type : public AbstractAllTypes	\
     {	\
         public:	\
-            name##_Type(std::string name);	\
-            ~name##_Type();	\
+            blockName##_Type(std::string name);	\
+            ~blockName##_Type();	\
             void getOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);	\
     }
 
 
-    #define BLOCK_WO( name )	\
-    class name##_Type : public AbstractAllTypes	\
+    #define BLOCK_WO( blockName, propName )	\
+    class blockName##_Type : public AbstractAllTypes	\
     {	\
         public:	\
-            name##_Type(std::string name);	\
-            ~name##_Type();	\
+            blockName##_Type(std::string name);	\
+            ~blockName##_Type();	\
         void setOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);	\
-        void setOneDevice(Device* pDevice, name##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);	\
+        void setOneDevice(Device* pDevice, propName##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);	\
     }
 
-    #define BLOCK_RW( name )	\
-    class name##_Type : public AbstractAllTypes	\
+    #define BLOCK_RW( blockName, propName )	\
+    class blockName##_Type : public AbstractAllTypes	\
     {	\
         public:	\
-            name##_Type(std::string name);	\
-            ~name##_Type();	\
+            blockName##_Type(std::string name);	\
+            ~blockName##_Type();	\
             void getOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);	\
             void setOneDevice(Device* pDevice, const bool transmitNow, MultiplexingContext* pContext);	\
-            void setOneDevice(Device* pDevice, name##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);	\
+            void setOneDevice(Device* pDevice, propName##PropertyData& data, const bool transmitNow, MultiplexingContext* pContext);	\
     }
     
-    BLOCK_RO( MyROBlock );
-    BLOCK_RW( MyRWBlock );
-    BLOCK_WO( MyWOBlock );
+    BLOCK_RO( MyROBlock, MyROBlockProp );
+    BLOCK_RW( MyRWBlock, MyRWBlockProp );
+    BLOCK_WO( MyWOBlock, MyWOBlockProp );
     
     /*---------------------------------------------------------------------------------------------------------
      * INTERFACE
@@ -137,14 +137,13 @@ namespace AllTypes
             static void cleanup() { AbstractAllTypes::cleanup(); }
             static bool isInitialized(){ return AbstractAllTypes::isInitialized(); }
             static Silecs::PLC* getPLC(Device* pDevice)
-			{
-				return AbstractAllTypes::theCluster()->getPLC(pDevice->plcHostName.get(),pDevice->parameterFile.get());
-			}
-
-                static MyROBlock_Type MyROBlock;
-                static MyRWBlock_Type MyRWBlock;
-                static MyWOBlock_Type MyWOBlock;
-               
+            {
+                return AbstractAllTypes::theCluster()->getPLC(pDevice->plcHostName.get(),pDevice->parameterFile.get());
+            }
+    
+			static MyROBlock_Type MyROBlock;
+			static MyRWBlock_Type MyRWBlock;
+			static MyWOBlock_Type MyWOBlock;           
         };
     }
 
diff --git a/silecs-codegen/src/xml/test/generated_correct/AllTypesFESA.design b/silecs-codegen/src/xml/test/generated_correct/AllTypesFESA.design
index 68ba063..54d0465 100644
--- a/silecs-codegen/src/xml/test/generated_correct/AllTypesFESA.design
+++ b/silecs-codegen/src/xml/test/generated_correct/AllTypesFESA.design
@@ -44,7 +44,7 @@
                         <server-action-ref server-action-name-ref="SettingGetAction"/>
                     </get-action>
                 </GSI-Setting-Property>
-                <GSI-Setting-Property name="MyRWBlock" multiplexed="false" visibility="development"><value-item name="RW_dt" direction="INOUT"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dt"/></value-item><value-item name="RW_real" direction="INOUT"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_real"/></value-item><value-item name="RW_dint" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dint"/></value-item><value-item name="RW_int" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int"/></value-item><value-item name="RW_dword" direction="INOUT"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dword"/></value-item><value-item name="RW_word" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_word"/></value-item><value-item name="RW_byte" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_byte"/></value-item><value-item name="RW_char" direction="INOUT"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_char"/></value-item><value-item name="RW_date" direction="INOUT"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_date"/></value-item><value-item name="RW_float32" direction="INOUT"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_float32"/></value-item><value-item name="RW_uint32" direction="INOUT"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint32"/></value-item><value-item name="RW_int32" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int32"/></value-item><value-item name="RW_uint16" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint16"/></value-item><value-item name="RW_int16" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int16"/></value-item><value-item name="RW_uint8" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint8"/></value-item><value-item name="RW_int8" direction="INOUT"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int8"/></value-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><set-action><server-action-ref server-action-name-ref="SendMyRWBlock"/></set-action><get-action><server-action-ref server-action-name-ref="RecvMyRWBlock"/></get-action></GSI-Setting-Property><GSI-Setting-Property name="MyWOBlock" multiplexed="false" visibility="development"><value-item name="WO_dt" direction="INOUT"><array type="double"><dim>10</dim></array><data-field-ref field-name-ref="WO_dt"/></value-item><value-item name="WO_real" direction="INOUT"><array type="float"><dim>10</dim></array><data-field-ref field-name-ref="WO_real"/></value-item><value-item name="WO_dint" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_dint"/></value-item><value-item name="WO_int" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int"/></value-item><value-item name="WO_dword" direction="INOUT"><array type="int64_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_dword"/></value-item><value-item name="WO_word" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_word"/></value-item><value-item name="WO_byte" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_byte"/></value-item><value-item name="WO_char" direction="INOUT"><array type="int8_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_char"/></value-item><value-item name="WO_date" direction="INOUT"><array type="double"><dim>10</dim></array><data-field-ref field-name-ref="WO_date"/></value-item><value-item name="WO_string" direction="INOUT"><array2D type="char"><dim1>10</dim1><dim2>64</dim2></array2D><data-field-ref field-name-ref="WO_string"/></value-item><value-item name="WO_float32" direction="INOUT"><array type="float"><dim>10</dim></array><data-field-ref field-name-ref="WO_float32"/></value-item><value-item name="WO_uint32" direction="INOUT"><array type="int64_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint32"/></value-item><value-item name="WO_int32" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int32"/></value-item><value-item name="WO_uint16" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint16"/></value-item><value-item name="WO_int16" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int16"/></value-item><value-item name="WO_uint8" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint8"/></value-item><value-item name="WO_int8" direction="INOUT"><array type="int8_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int8"/></value-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><set-action><server-action-ref server-action-name-ref="SendMyWOBlock"/></set-action><get-action><server-action-ref server-action-name-ref="GetMyWOBlock"/></get-action></GSI-Setting-Property><GSI-Power-Property multiplexed="false" name="Power" visibility="operational">
+                <GSI-Setting-Property name="MyRWBlockProp" multiplexed="false" visibility="development"><value-item name="RW_dt_fesa" direction="INOUT"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dt_fesa"/></value-item><value-item name="RW_real_fesa" direction="INOUT"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_real_fesa"/></value-item><value-item name="RW_dint_fesa" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dint_fesa"/></value-item><value-item name="RW_int_fesa" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int_fesa"/></value-item><value-item name="RW_dword_fesa" direction="INOUT"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_dword_fesa"/></value-item><value-item name="RW_word_fesa" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_word_fesa"/></value-item><value-item name="RW_byte_fesa" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_byte_fesa"/></value-item><value-item name="RW_char_fesa" direction="INOUT"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_char_fesa"/></value-item><value-item name="RW_date_fesa" direction="INOUT"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_date_fesa"/></value-item><value-item name="RW_float32_fesa" direction="INOUT"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_float32_fesa"/></value-item><value-item name="RW_uint32_fesa" direction="INOUT"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint32_fesa"/></value-item><value-item name="RW_int32_fesa" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int32_fesa"/></value-item><value-item name="RW_uint16_fesa" direction="INOUT"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint16_fesa"/></value-item><value-item name="RW_int16_fesa" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int16_fesa"/></value-item><value-item name="RW_uint8_fesa" direction="INOUT"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_uint8_fesa"/></value-item><value-item name="RW_int8" direction="INOUT"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D><data-field-ref field-name-ref="RW_int8"/></value-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><set-action><server-action-ref server-action-name-ref="SendMyRWBlockProp"/></set-action><get-action><server-action-ref server-action-name-ref="RecvMyRWBlockProp"/></get-action></GSI-Setting-Property><GSI-Setting-Property name="MyWOBlockProp" multiplexed="false" visibility="development"><value-item name="WO_dt_fesa" direction="INOUT"><array type="double"><dim>10</dim></array><data-field-ref field-name-ref="WO_dt_fesa"/></value-item><value-item name="WO_real_fesa" direction="INOUT"><array type="float"><dim>10</dim></array><data-field-ref field-name-ref="WO_real_fesa"/></value-item><value-item name="WO_dint_fesa" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_dint_fesa"/></value-item><value-item name="WO_int_fesa" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int_fesa"/></value-item><value-item name="WO_dword_fesa" direction="INOUT"><array type="int64_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_dword_fesa"/></value-item><value-item name="WO_word_fesa" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_word_fesa"/></value-item><value-item name="WO_byte_fesa" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_byte_fesa"/></value-item><value-item name="WO_char_fesa" direction="INOUT"><array type="int8_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_char_fesa"/></value-item><value-item name="WO_date_fesa" direction="INOUT"><array type="double"><dim>10</dim></array><data-field-ref field-name-ref="WO_date_fesa"/></value-item><value-item name="WO_string_fesa" direction="INOUT"><array2D type="char"><dim1>10</dim1><dim2>64</dim2></array2D><data-field-ref field-name-ref="WO_string_fesa"/></value-item><value-item name="WO_float32_fesa" direction="INOUT"><array type="float"><dim>10</dim></array><data-field-ref field-name-ref="WO_float32_fesa"/></value-item><value-item name="WO_uint32_fesa" direction="INOUT"><array type="int64_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint32_fesa"/></value-item><value-item name="WO_int32_fesa" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int32_fesa"/></value-item><value-item name="WO_uint16_fesa" direction="INOUT"><array type="int32_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint16_fesa"/></value-item><value-item name="WO_int16_fesa" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int16_fesa"/></value-item><value-item name="WO_uint8_fesa" direction="INOUT"><array type="int16_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_uint8_fesa"/></value-item><value-item name="WO_int8" direction="INOUT"><array type="int8_t"><dim>10</dim></array><data-field-ref field-name-ref="WO_int8"/></value-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><set-action><server-action-ref server-action-name-ref="SendMyWOBlockProp"/></set-action><get-action><server-action-ref server-action-name-ref="GetMyWOBlockProp"/></get-action></GSI-Setting-Property><GSI-Power-Property multiplexed="false" name="Power" visibility="operational">
                     <update-flag-item direction="OUT" name="updateFlags" optional="true">
 						<builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/>
                     </update-flag-item>
@@ -232,7 +232,7 @@
                         <acquisition-context-field-ref field-name-ref="acquisitionContext"/>
                     </acquisition-context-item>
                 </GSI-Acquisition-Property>
-                <GSI-Acquisition-Property name="MyROBlock" subscribable="true" multiplexed="false" on-change="true" visibility="development"><value-item name="RO_dt" direction="OUT"><scalar type="double"/><data-field-ref field-name-ref="RO_dt"/></value-item><value-item name="RO_real" direction="OUT"><scalar type="float"/><data-field-ref field-name-ref="RO_real"/></value-item><value-item name="RO_dint" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_dint"/></value-item><value-item name="RO_int" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_int"/></value-item><value-item name="RO_dword" direction="OUT"><scalar type="int64_t"/><data-field-ref field-name-ref="RO_dword"/></value-item><value-item name="RO_word" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_word"/></value-item><value-item name="RO_byte" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_byte"/></value-item><value-item name="RO_char" direction="OUT"><scalar type="int8_t"/><data-field-ref field-name-ref="RO_char"/></value-item><value-item name="RO_date" direction="OUT"><scalar type="double"/><data-field-ref field-name-ref="RO_date"/></value-item><value-item name="RO_string" direction="OUT"><array type="char"><dim>64</dim></array><data-field-ref field-name-ref="RO_string"/></value-item><value-item name="RO_float32" direction="OUT"><scalar type="float"/><data-field-ref field-name-ref="RO_float32"/></value-item><value-item name="RO_uint32" direction="OUT"><scalar type="int64_t"/><data-field-ref field-name-ref="RO_uint32"/></value-item><value-item name="RO_int32" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_int32"/></value-item><value-item name="RO_uint16" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_uint16"/></value-item><value-item name="RO_int16" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_int16"/></value-item><value-item name="RO_uint8" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_uint8"/></value-item><value-item name="RO_int8" direction="OUT"><scalar type="int8_t"/><data-field-ref field-name-ref="RO_int8"/></value-item><acq-stamp-item direction="OUT" name="acqStamp"><scalar type="int64_t"/></acq-stamp-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><cycle-stamp-item direction="OUT" optional="true" name="cycleStamp"><scalar type="int64_t"/></cycle-stamp-item><get-action><server-action-ref server-action-name-ref="GetMyROBlock"/></get-action><acquisition-context-item direction="OUT"><processIndex direction="OUT" name="processIndex"><scalar type="int32_t"/></processIndex><sequenceIndex direction="OUT" name="sequenceIndex"><scalar type="int32_t"/></sequenceIndex><chainIndex direction="OUT" name="chainIndex"><scalar type="int32_t"/></chainIndex><eventNumber direction="OUT" name="eventNumber"><scalar type="int32_t"/></eventNumber><timingGroupID direction="OUT" name="timingGroupID"><scalar type="int32_t"/></timingGroupID><acquisitionStamp direction="OUT" name="acquisitionStamp"><scalar type="int64_t"/></acquisitionStamp><eventStamp direction="OUT" name="eventStamp"><scalar type="int64_t"/></eventStamp><processStartStamp direction="OUT" name="processStartStamp"><scalar type="int64_t"/></processStartStamp><sequenceStartStamp direction="OUT" name="sequenceStartStamp"><scalar type="int64_t"/></sequenceStartStamp><chainStartStamp direction="OUT" name="chainStartStamp"><scalar type="int64_t"/></chainStartStamp><acquisition-context-field-ref field-name-ref="acquisitionContext"/></acquisition-context-item></GSI-Acquisition-Property><GSI-Version-Property multiplexed="false" name="Version" on-change="false" subscribable="false" visibility="operational">
+                <GSI-Acquisition-Property name="MyROBlockProp" subscribable="true" multiplexed="false" on-change="true" visibility="development"><value-item name="RO_dt_fesa" direction="OUT"><scalar type="double"/><data-field-ref field-name-ref="RO_dt_fesa"/></value-item><value-item name="RO_real_fesa" direction="OUT"><scalar type="float"/><data-field-ref field-name-ref="RO_real_fesa"/></value-item><value-item name="RO_dint_fesa" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_dint_fesa"/></value-item><value-item name="RO_int_fesa" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_int_fesa"/></value-item><value-item name="RO_dword_fesa" direction="OUT"><scalar type="int64_t"/><data-field-ref field-name-ref="RO_dword_fesa"/></value-item><value-item name="RO_word_fesa" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_word_fesa"/></value-item><value-item name="RO_byte_fesa" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_byte_fesa"/></value-item><value-item name="RO_char_fesa" direction="OUT"><scalar type="int8_t"/><data-field-ref field-name-ref="RO_char_fesa"/></value-item><value-item name="RO_date_fesa" direction="OUT"><scalar type="double"/><data-field-ref field-name-ref="RO_date_fesa"/></value-item><value-item name="RO_string_fesa" direction="OUT"><array type="char"><dim>64</dim></array><data-field-ref field-name-ref="RO_string_fesa"/></value-item><value-item name="RO_float32_fesa" direction="OUT"><scalar type="float"/><data-field-ref field-name-ref="RO_float32_fesa"/></value-item><value-item name="RO_uint32_fesa" direction="OUT"><scalar type="int64_t"/><data-field-ref field-name-ref="RO_uint32_fesa"/></value-item><value-item name="RO_int32_fesa" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_int32_fesa"/></value-item><value-item name="RO_uint16_fesa" direction="OUT"><scalar type="int32_t"/><data-field-ref field-name-ref="RO_uint16_fesa"/></value-item><value-item name="RO_int16_fesa" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_int16_fesa"/></value-item><value-item name="RO_uint8_fesa" direction="OUT"><scalar type="int16_t"/><data-field-ref field-name-ref="RO_uint8_fesa"/></value-item><value-item name="RO_int8" direction="OUT"><scalar type="int8_t"/><data-field-ref field-name-ref="RO_int8"/></value-item><acq-stamp-item direction="OUT" name="acqStamp"><scalar type="int64_t"/></acq-stamp-item><update-flag-item direction="OUT" optional="true" name="updateFlags"><builtin-type-scalar data-type-name-ref="NOTIFICATION_UPDATE"/></update-flag-item><cycle-name-item direction="OUT" optional="true" name="cycleName"><array type="char"><dim>32</dim></array></cycle-name-item><cycle-stamp-item direction="OUT" optional="true" name="cycleStamp"><scalar type="int64_t"/></cycle-stamp-item><get-action><server-action-ref server-action-name-ref="GetMyROBlockProp"/></get-action><acquisition-context-item direction="OUT"><processIndex direction="OUT" name="processIndex"><scalar type="int32_t"/></processIndex><sequenceIndex direction="OUT" name="sequenceIndex"><scalar type="int32_t"/></sequenceIndex><chainIndex direction="OUT" name="chainIndex"><scalar type="int32_t"/></chainIndex><eventNumber direction="OUT" name="eventNumber"><scalar type="int32_t"/></eventNumber><timingGroupID direction="OUT" name="timingGroupID"><scalar type="int32_t"/></timingGroupID><acquisitionStamp direction="OUT" name="acquisitionStamp"><scalar type="int64_t"/></acquisitionStamp><eventStamp direction="OUT" name="eventStamp"><scalar type="int64_t"/></eventStamp><processStartStamp direction="OUT" name="processStartStamp"><scalar type="int64_t"/></processStartStamp><sequenceStartStamp direction="OUT" name="sequenceStartStamp"><scalar type="int64_t"/></sequenceStartStamp><chainStartStamp direction="OUT" name="chainStartStamp"><scalar type="int64_t"/></chainStartStamp><acquisition-context-field-ref field-name-ref="acquisitionContext"/></acquisition-context-item></GSI-Acquisition-Property><GSI-Version-Property multiplexed="false" name="Version" on-change="false" subscribable="false" visibility="operational">
                     <acq-stamp-item direction="OUT" name="acqStamp">
                         <scalar type="int64_t"/>
                     </acq-stamp-item>
@@ -586,12 +586,12 @@
                 </GSI-module-status-labels-field>
             </configuration>
             <setting>
-                <field name="WO_dt" shared="true" multiplexed="false" persistent="true"><array type="double"><dim>10</dim></array></field><field name="WO_real" shared="true" multiplexed="false" persistent="true"><array type="float"><dim>10</dim></array></field><field name="WO_dint" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_int" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_dword" shared="true" multiplexed="false" persistent="true"><array type="int64_t"><dim>10</dim></array></field><field name="WO_word" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_byte" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_char" shared="true" multiplexed="false" persistent="true"><array type="int8_t"><dim>10</dim></array></field><field name="WO_date" shared="true" multiplexed="false" persistent="true"><array type="double"><dim>10</dim></array></field><field name="WO_string" shared="true" multiplexed="false" persistent="true"><array2D type="char"><dim1>10</dim1><dim2>64</dim2></array2D></field><field name="WO_float32" shared="true" multiplexed="false" persistent="true"><array type="float"><dim>10</dim></array></field><field name="WO_uint32" shared="true" multiplexed="false" persistent="true"><array type="int64_t"><dim>10</dim></array></field><field name="WO_int32" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_uint16" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_int16" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_uint8" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_int8" shared="true" multiplexed="false" persistent="true"><array type="int8_t"><dim>10</dim></array></field><field name="RW_dt" multiplexed="false" persistent="true"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_real" multiplexed="false" persistent="true"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_dint" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_dword" multiplexed="false" persistent="true"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_word" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_byte" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_char" multiplexed="false" persistent="true"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_date" multiplexed="false" persistent="true"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_float32" multiplexed="false" persistent="true"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint32" multiplexed="false" persistent="true"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int32" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint16" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int16" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint8" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int8" multiplexed="false" persistent="true"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><GSI-power-field multiplexed="false" name="power" persistent="false">
+                <field name="WO_dt_fesa" shared="true" multiplexed="false" persistent="true"><array type="double"><dim>10</dim></array></field><field name="WO_real_fesa" shared="true" multiplexed="false" persistent="true"><array type="float"><dim>10</dim></array></field><field name="WO_dint_fesa" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_int_fesa" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_dword_fesa" shared="true" multiplexed="false" persistent="true"><array type="int64_t"><dim>10</dim></array></field><field name="WO_word_fesa" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_byte_fesa" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_char_fesa" shared="true" multiplexed="false" persistent="true"><array type="int8_t"><dim>10</dim></array></field><field name="WO_date_fesa" shared="true" multiplexed="false" persistent="true"><array type="double"><dim>10</dim></array></field><field name="WO_string_fesa" shared="true" multiplexed="false" persistent="true"><array2D type="char"><dim1>10</dim1><dim2>64</dim2></array2D></field><field name="WO_float32_fesa" shared="true" multiplexed="false" persistent="true"><array type="float"><dim>10</dim></array></field><field name="WO_uint32_fesa" shared="true" multiplexed="false" persistent="true"><array type="int64_t"><dim>10</dim></array></field><field name="WO_int32_fesa" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_uint16_fesa" shared="true" multiplexed="false" persistent="true"><array type="int32_t"><dim>10</dim></array></field><field name="WO_int16_fesa" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_uint8_fesa" shared="true" multiplexed="false" persistent="true"><array type="int16_t"><dim>10</dim></array></field><field name="WO_int8" shared="true" multiplexed="false" persistent="true"><array type="int8_t"><dim>10</dim></array></field><field name="RW_dt_fesa" multiplexed="false" persistent="true"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_real_fesa" multiplexed="false" persistent="true"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_dint_fesa" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int_fesa" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_dword_fesa" multiplexed="false" persistent="true"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_word_fesa" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_byte_fesa" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_char_fesa" multiplexed="false" persistent="true"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_date_fesa" multiplexed="false" persistent="true"><array2D type="double"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_float32_fesa" multiplexed="false" persistent="true"><array2D type="float"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint32_fesa" multiplexed="false" persistent="true"><array2D type="int64_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int32_fesa" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint16_fesa" multiplexed="false" persistent="true"><array2D type="int32_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int16_fesa" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_uint8_fesa" multiplexed="false" persistent="true"><array2D type="int16_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><field name="RW_int8" multiplexed="false" persistent="true"><array2D type="int8_t"><dim1>2</dim1><dim2>2</dim2></array2D></field><GSI-power-field multiplexed="false" name="power" persistent="false">
                     <custom-type-scalar data-type-name-ref="DEVICE_POWER"/>
                 </GSI-power-field>
             </setting>
             <acquisition>
-                <field name="RO_dt" multiplexed="false" persistent="false"><scalar type="double"/></field><field name="RO_real" multiplexed="false" persistent="false"><scalar type="float"/></field><field name="RO_dint" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_int" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_dword" multiplexed="false" persistent="false"><scalar type="int64_t"/></field><field name="RO_word" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_byte" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_char" multiplexed="false" persistent="false"><scalar type="int8_t"/></field><field name="RO_date" multiplexed="false" persistent="false"><scalar type="double"/></field><field name="RO_string" multiplexed="false" persistent="false"><array type="char"><dim>64</dim></array></field><field name="RO_float32" multiplexed="false" persistent="false"><scalar type="float"/></field><field name="RO_uint32" multiplexed="false" persistent="false"><scalar type="int64_t"/></field><field name="RO_int32" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_uint16" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_int16" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_uint8" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_int8" multiplexed="false" persistent="false"><scalar type="int8_t"/></field><GSI-control-field multiplexed="false" name="control">
+                <field name="RO_dt_fesa" multiplexed="false" persistent="false"><scalar type="double"/></field><field name="RO_real_fesa" multiplexed="false" persistent="false"><scalar type="float"/></field><field name="RO_dint_fesa" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_int_fesa" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_dword_fesa" multiplexed="false" persistent="false"><scalar type="int64_t"/></field><field name="RO_word_fesa" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_byte_fesa" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_char_fesa" multiplexed="false" persistent="false"><scalar type="int8_t"/></field><field name="RO_date_fesa" multiplexed="false" persistent="false"><scalar type="double"/></field><field name="RO_string_fesa" multiplexed="false" persistent="false"><array type="char"><dim>64</dim></array></field><field name="RO_float32_fesa" multiplexed="false" persistent="false"><scalar type="float"/></field><field name="RO_uint32_fesa" multiplexed="false" persistent="false"><scalar type="int64_t"/></field><field name="RO_int32_fesa" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_uint16_fesa" multiplexed="false" persistent="false"><scalar type="int32_t"/></field><field name="RO_int16_fesa" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_uint8_fesa" multiplexed="false" persistent="false"><scalar type="int16_t"/></field><field name="RO_int8" multiplexed="false" persistent="false"><scalar type="int8_t"/></field><GSI-control-field multiplexed="false" name="control">
                     <custom-type-scalar data-type-name-ref="DEVICE_CONTROL"/>
                 </GSI-control-field>
                 <GSI-powerState-field multiplexed="false" name="powerState">
@@ -652,6 +652,6 @@
         <get-server-action implementation="default" name="AcquisitionGetAction"/>
         <get-server-action implementation="default" name="StatusGetAction"/>
         <get-server-action implementation="default" name="VersionGetAction"/><get-server-action implementation="default" name="ModuleStatusGetAction"/>
-    <get-server-action name="GetMyROBlock" implementation="default"/><rt-action name="RecvMyROBlock"><notified-property property-name-ref="MyROBlock" automatic="true"/></rt-action><set-server-action name="SendMyRWBlock" implementation="custom"/><get-server-action name="RecvMyRWBlock" implementation="custom"/><set-server-action name="SendMyWOBlock" implementation="custom"/><get-server-action name="GetMyWOBlock" implementation="default"/></actions>
+    <get-server-action name="GetMyROBlockProp" implementation="default"/><rt-action name="RecvMyROBlockProp"><notified-property property-name-ref="MyROBlockProp" automatic="true"/></rt-action><set-server-action name="SendMyRWBlockProp" implementation="custom"/><get-server-action name="RecvMyRWBlockProp" implementation="custom"/><set-server-action name="SendMyWOBlockProp" implementation="custom"/><get-server-action name="GetMyWOBlockProp" implementation="default"/></actions>
 
-<events><sources><timing-event-source name="Timing"/><timer-event-source name="Timer"/></sources><logical-events><logical-event name="RecvMyROBlockEvent" use="required" type="timer"/></logical-events></events><scheduling-units><scheduling-unit name="RecvMyROBlockUnit"><rt-action-ref rt-action-name-ref="RecvMyROBlock"/><logical-event-ref logical-event-name-ref="RecvMyROBlockEvent"/></scheduling-unit></scheduling-units></equipment-model>
+<events><sources><timing-event-source name="Timing"/><timer-event-source name="Timer"/></sources><logical-events><logical-event name="RecvMyROBlockPropEvent" use="required" type="timer"/></logical-events></events><scheduling-units><scheduling-unit name="RecvMyROBlockPropUnit"><rt-action-ref rt-action-name-ref="RecvMyROBlockProp"/><logical-event-ref logical-event-name-ref="RecvMyROBlockPropEvent"/></scheduling-unit></scheduling-units></equipment-model>
diff --git a/silecs-model/src/xml/DesignSchema.xsd b/silecs-model/src/xml/DesignSchema.xsd
index aa754bc..bdfac8e 100644
--- a/silecs-model/src/xml/DesignSchema.xsd
+++ b/silecs-model/src/xml/DesignSchema.xsd
@@ -133,6 +133,11 @@ along with this program.  If not, see http://www.gnu.org/licenses/.-->
                                                 Defines if the code-generation will generate a FESA-Property and the related Actions/Events/etc for this block
                                             </xs:appinfo>
                                         </xs:annotation>
+                                    </xs:attribute>
+                                    <xs:attribute name="fesaPropertyName" type="BlockNameType" use="optional">
+                                        <xs:annotation>
+                                            <xs:appinfo>Defines the name of the generated Fesa-Property. If not set, the Blockname will be used.</xs:appinfo>
+                                        </xs:annotation>
                                     </xs:attribute>
 								</xs:complexType>
 							</xs:element>
@@ -296,6 +301,11 @@ along with this program.  If not, see http://www.gnu.org/licenses/.-->
             </xs:appinfo>
         </xs:annotation>
     </xs:attribute>
+    <xs:attribute name="fesaFieldName" type="RegisterNameType" use="optional">
+        <xs:annotation>
+            <xs:appinfo>Defines the name of the generated Fesa-Field. If not set, the Registername will be used.</xs:appinfo>
+        </xs:annotation>
+    </xs:attribute>
 </xs:complexType>
 
                                     
-- 
GitLab