diff --git a/CMakeLists.txt b/CMakeLists.txt
index ec8785f3..1228d365 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,7 +6,7 @@
 cmake_minimum_required(VERSION 3.12)
 
 project(icub_firmware_shared
-        VERSION 1.25.1)
+        VERSION 1.26.0)
 
 find_package(YCM 0.11.0 REQUIRED)
 
diff --git a/can/canProtocolLib/iCubCanProto_classes.h b/can/canProtocolLib/iCubCanProto_classes.h
index 56b5ab1b..86f2541b 100644
--- a/can/canProtocolLib/iCubCanProto_classes.h
+++ b/can/canProtocolLib/iCubCanProto_classes.h
@@ -52,11 +52,12 @@ extern "C" {
 #define ICUBCANPROTO_CLASS_PERIODIC_ANALOGSENSOR              0x03
 #define ICUBCANPROTO_CLASS_PERIODIC_SKIN                      0x04
 #define ICUBCANPROTO_CLASS_PERIODIC_INERTIALSENSOR            0x05
+#define ICUBCANPROTO_CLASS_PERIODIC_BATTERY                   0x06
 #define ICUBCANPROTO_CLASS_BOOTLOADER                         0x07
 // marco.accame: is this macro ICUBCANPROTO_CLASS_MAXNUM used? 
 //               if, so, after the addition of new class ICUBCANPROTO_CLASS_PERIODIC_INERTIALSENSOR, it should become 0x06 
 //               (the ICUBCANPROTO_CLASS_BOOTLOADER is not strangely not counted). 
-#define ICUBCANPROTO_CLASS_MAXNUM                             0x05
+#define ICUBCANPROTO_CLASS_MAXNUM                             0x07
 
 
 // - declaration of public user-defined types ------------------------------------------------------------------------- 
diff --git a/can/canProtocolLib/iCubCanProto_types.h b/can/canProtocolLib/iCubCanProto_types.h
index cd879151..c265b1ff 100644
--- a/can/canProtocolLib/iCubCanProto_types.h
+++ b/can/canProtocolLib/iCubCanProto_types.h
@@ -76,6 +76,7 @@ extern "C" {
 #define ICUBCANPROTO_BOARDTYPE__MTB4W   16
 #define ICUBCANPROTO_BOARDTYPE__PMC     17
 #define ICUBCANPROTO_BOARDTYPE__AMCBLDC 18
+#define ICUBCANPROTO_BOARDTYPE__BMS     19
 #define ICUBCANPROTO_BOARDTYPE__UNKNOWN 255
 
 // skin types
@@ -111,6 +112,7 @@ typedef enum
     icubCanProto_boardType__mtb4w   = ICUBCANPROTO_BOARDTYPE__MTB4W,
     icubCanProto_boardType__pmc     = ICUBCANPROTO_BOARDTYPE__PMC,
     icubCanProto_boardType__amcbldc = ICUBCANPROTO_BOARDTYPE__AMCBLDC,
+    icubCanProto_boardType__bms     = ICUBCANPROTO_BOARDTYPE__BMS,
     icubCanProto_boardType__unknown = ICUBCANPROTO_BOARDTYPE__UNKNOWN
 } icubCanProto_boardType_t;
 
diff --git a/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.c b/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.c
index df815e2a..051e3d44 100644
--- a/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.c
+++ b/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.c
@@ -88,7 +88,8 @@ static const char * s_eoas_sensors_strings[] =
     "eoas_temperature",
     "eoas_psc_angle",
     "eoas_pos_angle",
-    "eoas_ft"
+    "eoas_ft",
+    "eoas_battery"
 };  EO_VERIFYsizeof(s_eoas_sensors_strings, eoas_sensors_numberof*sizeof(const char *));    
 
 
@@ -426,13 +427,29 @@ extern const eObrd_info_t * eoas_temperature_setof_boardinfos_find(const eOas_te
 // 
 
 static const eObrd_cantype_t s_eoas_ft_supportedboards_types[] = { eobrd_cantype_strain, eobrd_cantype_strain2 };
+static const eObrd_cantype_t s_eoas_bms_supportedboards_types[] = { eobrd_cantype_bms };
 
 
+extern uint8_t eoas_battery_supportedboards_numberof(void)
+{
+    return sizeof(s_eoas_bms_supportedboards_types)/sizeof(eObrd_cantype_t);
+}
+
 extern uint8_t eoas_ft_supportedboards_numberof(void)
 {
     return sizeof(s_eoas_ft_supportedboards_types)/sizeof(eObrd_cantype_t);
 }
 
+extern eObrd_cantype_t eoas_battery_supportedboards_gettype(uint8_t pos)
+{
+    if(pos >= eoas_battery_supportedboards_numberof())
+    {
+        return eobrd_cantype_none;
+    }
+    
+    return s_eoas_bms_supportedboards_types[pos];    
+}
+
 extern eObrd_cantype_t eoas_ft_supportedboards_gettype(uint8_t pos)
 {
     if(pos >= eoas_ft_supportedboards_numberof())
@@ -456,6 +473,20 @@ extern eObool_t eoas_ft_isboardvalid(eObrd_cantype_t boardtype)
     return eobool_false;    
 }
 
+extern eObool_t eoas_battery_isboardvalid(eObrd_cantype_t boardtype)
+{
+    for(uint8_t n=0; n<eoas_battery_supportedboards_numberof(); n++)
+    {
+        if(boardtype == s_eoas_bms_supportedboards_types[n])
+        {
+            return eobool_true;
+        }
+    }
+    
+    return eobool_false;    
+}
+
+
 // --------------------------------------------------------------------------------------------------------------------
 // - definition of extern hidden functions 
 // --------------------------------------------------------------------------------------------------------------------
diff --git a/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.h b/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.h
index 7db14671..0da8217c 100644
--- a/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.h
+++ b/eth/embobj/plus/comm-v2/icub/EoAnalogSensors.h
@@ -78,12 +78,13 @@ typedef enum
     eoas_psc_angle              = 16,
     eoas_pos_angle              = 17,
     eoas_ft                     = 18,
+    eoas_battery             = 19,
     // add in here eoas_xxxnameetc
     eoas_unknown                = 254,  
     eoas_none                   = 255   
 } eOas_sensor_t;
 
-enum { eoas_sensors_numberof = 19 };
+enum { eoas_sensors_numberof = 20 };
 
 
 /** @typedef    typedef enum eOas_entity_t;
@@ -99,10 +100,11 @@ typedef enum
     eoas_entity_inertial3                   = 4,
     eoas_entity_psc                         = 5,
     eoas_entity_pos                         = 6,
-    eoas_entity_ft                          = 7
+    eoas_entity_ft                          = 7,
+    eoas_entity_battery                  = 8
 } eOas_entity_t;
 
-enum { eoas_entities_numberof = 8 };
+enum { eoas_entities_numberof = 9 };
 
 
 // -- all the possible enum
@@ -679,9 +681,7 @@ typedef struct                      // size is: 4+32+4 = 40
 
 
 enum { eOas_ft_sensors_maxnumber = 4 };
-
-
-
+enum { eOas_battery_sensors_maxnumber = 1 };
 
 typedef struct
 {
@@ -697,6 +697,19 @@ typedef struct
     eOas_ft_sensordescriptor_t  data[eOas_ft_sensors_maxnumber];
 } eOas_ft_arrayof_sensors_t;  EO_VERIFYsizeof(eOas_ft_arrayof_sensors_t, 36)
 
+typedef struct
+{
+    eObrd_info_t boardinfo;//6
+    eObrd_canlocation_t canloc;//8
+    uint8_t ffu;
+} eOas_battery_sensordescriptor_t; EO_VERIFYsizeof(eOas_battery_sensordescriptor_t, 8)
+
+typedef struct
+{
+    eOarray_head_t              head;//4                                                                                                  
+    eOas_battery_sensordescriptor_t  data[eOas_battery_sensors_maxnumber];
+} eOas_battery_arrayof_sensors_t;  EO_VERIFYsizeof(eOas_battery_arrayof_sensors_t, 12)
+
 
 typedef enum { eoas_ft_mode_raw = 0, eoas_ft_mode_calibrated = 1 } eOas_ft_mode_t;
 
@@ -746,6 +759,48 @@ typedef struct
 } eOas_ft_t; EO_VERIFYsizeof(eOas_ft_t, 64)
 
 
+
+typedef struct
+{
+    uint8_t                 period;           // if 0 -> DONT TX, else TX
+    uint8_t                 filler[3];
+} eOas_battery_config_t;         EO_VERIFYsizeof(eOas_battery_config_t, 4)
+
+
+typedef struct
+{
+    uint8_t                 enable;         /**< use 0 or 1*/
+    uint8_t                 filler[3];
+} eOas_battery_commands_t;       EO_VERIFYsizeof(eOas_battery_commands_t, 4)
+
+
+typedef struct
+{
+    eOabstime_t             age;          // timeoflife in usec. better using this because yarp may ask the board to have its time
+    int16_t                 temperature;  // in steps of 0.1 celsius degree (pos and neg).
+    int8_t                  status;
+    uint8_t                 filler;
+    float32_t               voltage;  
+    float32_t               current;  
+    float32_t               charge;  
+
+} eOas_battery_timedvalue_t;     EO_VERIFYsizeof(eOas_battery_timedvalue_t, 24)
+//char (*luca)[sizeof( eOas_battery_timedvalue_t )] = 1;
+
+typedef struct    
+{   // 40 + 12 + 4 = 56
+    eOas_battery_timedvalue_t    timedvalue;
+} eOas_battery_status_t;         EO_VERIFYsizeof(eOas_battery_status_t, 24)
+
+
+typedef struct
+{
+    // size is: 4 + 4 + 56 = 64
+    eOas_battery_config_t        config;
+    eOas_battery_commands_t      cmmnds;
+    eOas_battery_status_t        status;
+} eOas_battery_t; EO_VERIFYsizeof(eOas_battery_t, 32)
+
 // - declaration of extern public variables, ... but better using use _get/_set instead -------------------------------
 // empty-section
 
@@ -777,6 +832,9 @@ extern eObrd_cantype_t eoas_temperature_supportedboards_gettype(uint8_t pos);
 extern uint8_t eoas_ft_supportedboards_numberof(void);
 extern eObrd_cantype_t eoas_ft_supportedboards_gettype(uint8_t pos);
 extern eObool_t eoas_ft_isboardvalid(eObrd_cantype_t boardtype);
+extern uint8_t eoas_battery_supportedboards_numberof(void);
+extern eObrd_cantype_t eoas_battery_supportedboards_gettype(uint8_t pos);
+extern eObool_t eoas_battery_isboardvalid(eObrd_cantype_t boardtype);
 
 
 /** @}
diff --git a/eth/embobj/plus/comm-v2/icub/EoBoards.c b/eth/embobj/plus/comm-v2/icub/EoBoards.c
index c2525886..a9b3a7b0 100644
--- a/eth/embobj/plus/comm-v2/icub/EoBoards.c
+++ b/eth/embobj/plus/comm-v2/icub/EoBoards.c
@@ -91,7 +91,8 @@ static const uint64_t s_eoboards_is_can_mask =  (0x1LL << eobrd_mc4) |
                                                 (0x1LL << eobrd_psc) |
                                                 (0x1LL << eobrd_mtb4w) |
                                                 (0x1LL << eobrd_pmc)   |
-                                                (0x1LL << eobrd_amcbldc);
+                                                (0x1LL << eobrd_amcbldc)|
+                                                (0x1LL << eobrd_bms);
        
    
 static const eOmap_str_str_u08_t s_eoboards_map_of_boards[] =
@@ -121,6 +122,7 @@ static const eOmap_str_str_u08_t s_eoboards_map_of_boards[] =
     {"mtb4w", "eobrd_mtb4w", eobrd_mtb4w},
     {"pmc", "eobrd_pmc", eobrd_pmc},
     {"amcbldc", "eobrd_amcbldc", eobrd_amcbldc},
+    {"bms", "eobrd_bms", eobrd_bms},
     
     {"none", "eobrd_none", eobrd_none},
     {"unknown", "eobrd_unknown", eobrd_unknown}
diff --git a/eth/embobj/plus/comm-v2/icub/EoBoards.h b/eth/embobj/plus/comm-v2/icub/EoBoards.h
index 8bb753dc..95726472 100644
--- a/eth/embobj/plus/comm-v2/icub/EoBoards.h
+++ b/eth/embobj/plus/comm-v2/icub/EoBoards.h
@@ -76,6 +76,7 @@ typedef enum
     eobrd_cantype_mtb4w             = ICUBCANPROTO_BOARDTYPE__MTB4W,    // 16 (mtb4 for waseda university)
     eobrd_cantype_pmc               = ICUBCANPROTO_BOARDTYPE__PMC,      // 17 (pmc = piezo motor control)
     eobrd_cantype_amcbldc           = ICUBCANPROTO_BOARDTYPE__AMCBLDC,  // 18 (amcbldc)
+    eobrd_cantype_bms        = ICUBCANPROTO_BOARDTYPE__BMS,      // 19 (bms)
     eobrd_cantype_none              = 254, 	
     eobrd_cantype_unknown           = ICUBCANPROTO_BOARDTYPE__UNKNOWN   // 255 
 } eObrd_cantype_t;
@@ -128,12 +129,13 @@ typedef enum
     eobrd_mtb4w                 = eobrd_cantype_mtb4w,
     eobrd_pmc                   = eobrd_cantype_pmc,
     eobrd_amcbldc               = eobrd_cantype_amcbldc,
+    eobrd_bms            = eobrd_cantype_bms,
 
     eobrd_none                  = 254,                      
     eobrd_unknown               = 255  // = ICUBCANPROTO_BOARDTYPE__UNKNOWN                     
 } eObrd_type_t;
 
-enum { eobrd_type_numberof = 23 };
+enum { eobrd_type_numberof = 24 };
 
 
 typedef struct                  
diff --git a/eth/embobj/plus/comm-v2/icub/EoError.c b/eth/embobj/plus/comm-v2/icub/EoError.c
index 38336dd0..6760c96a 100644
--- a/eth/embobj/plus/comm-v2/icub/EoError.c
+++ b/eth/embobj/plus/comm-v2/icub/EoError.c
@@ -345,7 +345,13 @@ const eoerror_valuestring_t eoerror_valuestrings_CFG[] =
     {eoerror_value_CFG_ft_not_verified_yet, "CFG: theFTservice is not verified yet"},
     {eoerror_value_CFG_ft_using_onboard_config, "CFG: theFTservice is using onboard config"},
     {eoerror_value_CFG_ft_failed_notsupported, "CFG: theFTservice is not supported"},
-    {eoerror_value_CFG_ft_failed_fullscales, "CFG: theFTservice cannot get fullscales"}
+    {eoerror_value_CFG_ft_failed_fullscales, "CFG: theFTservice cannot get fullscales"},
+
+    {eoerror_value_CFG_bat_ok, "CFG: theBATservice is OK"},
+    {eoerror_value_CFG_bat_failed_candiscovery, "CFG: theBATservice failed CAN discovery"},
+    {eoerror_value_CFG_bat_not_verified_yet, "CFG: theBATservice is not verified yet"},
+    {eoerror_value_CFG_bat_using_onboard_config, "CFG: theBATservice is using onboard config"},
+    {eoerror_value_CFG_bat_failed_notsupported, "CFG: theBATservice is not supported"},
         
 };  EO_VERIFYsizeof(eoerror_valuestrings_CFG, eoerror_value_CFG_numberof*sizeof(const eoerror_valuestring_t))
 
diff --git a/eth/embobj/plus/comm-v2/icub/EoError.h b/eth/embobj/plus/comm-v2/icub/EoError.h
index 2f23437c..c000d341 100644
--- a/eth/embobj/plus/comm-v2/icub/EoError.h
+++ b/eth/embobj/plus/comm-v2/icub/EoError.h
@@ -398,11 +398,16 @@ typedef enum
     eoerror_value_CFG_ft_not_verified_yet               = 92,
     eoerror_value_CFG_ft_using_onboard_config           = 93,
     eoerror_value_CFG_ft_failed_notsupported            = 94,
-    eoerror_value_CFG_ft_failed_fullscales              = 95
-    
+    eoerror_value_CFG_ft_failed_fullscales              = 95,
+
+    eoerror_value_CFG_bat_ok                            = 96,
+    eoerror_value_CFG_bat_failed_candiscovery           = 97,
+    eoerror_value_CFG_bat_not_verified_yet              = 98,
+    eoerror_value_CFG_bat_using_onboard_config          = 99,
+    eoerror_value_CFG_bat_failed_notsupported           = 100,
 } eOerror_value_CFG_t;
 
-enum { eoerror_value_CFG_numberof = 96 };
+enum { eoerror_value_CFG_numberof = 101 };
 
 
 /** @typedef    typedef enum eOerror_value_ETHMON_t
diff --git a/eth/embobj/plus/comm-v2/icub/EoManagement.c b/eth/embobj/plus/comm-v2/icub/EoManagement.c
index 50c42c94..19fb371e 100644
--- a/eth/embobj/plus/comm-v2/icub/EoManagement.c
+++ b/eth/embobj/plus/comm-v2/icub/EoManagement.c
@@ -86,7 +86,8 @@ static const char * s_mn_servicetype_strings[] =
     "eomn_serv_AS_pos",
     "eomn_serv_MC_mc4plusfaps",
     "eomn_serv_MC_mc4pluspmc",
-    "eomn_serv_AS_ft"
+    "eomn_serv_AS_ft",
+    "eomn_serv_AS_battery"
 };  EO_VERIFYsizeof(s_mn_servicetype_strings, eomn_serv_types_numberof*sizeof(const char *))   
  
 static const char * s_mn_servicetype_string_unknown = "eomn_serv_UNKNOWN";
diff --git a/eth/embobj/plus/comm-v2/icub/EoManagement.h b/eth/embobj/plus/comm-v2/icub/EoManagement.h
index f24e5308..2d51d7a0 100644
--- a/eth/embobj/plus/comm-v2/icub/EoManagement.h
+++ b/eth/embobj/plus/comm-v2/icub/EoManagement.h
@@ -437,12 +437,13 @@ typedef enum
     eomn_serv_category_psc              = 7,
     eomn_serv_category_pos              = 8,
     eomn_serv_category_ft               = 9,
+    eomn_serv_category_battery          = 10,
     eomn_serv_category_all              = 128,
     eomn_serv_category_unknown          = 254,
     eomn_serv_category_none             = 255
 } eOmn_serv_category_t;
 
-enum { eomn_serv_categories_numberof = 10 };
+enum { eomn_serv_categories_numberof = 11 };
 
 typedef enum 
 {
@@ -464,11 +465,12 @@ typedef enum
     eomn_serv_MC_mc4plusfaps    = 15,
     eomn_serv_MC_mc4pluspmc     = 16,
     eomn_serv_AS_ft             = 17,
+    eomn_serv_AS_battery        = 18,
     eomn_serv_UNKNOWN           = 254,
     eomn_serv_NONE              = 255
 } eOmn_serv_type_t;
 
-enum { eomn_serv_types_numberof = 18 };
+enum { eomn_serv_types_numberof = 19 };
 
 typedef enum
 {
@@ -544,6 +546,11 @@ typedef struct
     eOas_ft_arrayof_sensors_t           arrayofsensors;
 } eOmn_serv_config_data_as_ft_t;        EO_VERIFYsizeof(eOmn_serv_config_data_as_ft_t, 40)
 
+typedef struct
+{
+    eObrd_canmonitor_cfg_t                   canmonitorconfig;
+    eOas_battery_arrayof_sensors_t           arrayofsensors;
+} eOmn_serv_config_data_as_battery_t;        EO_VERIFYsizeof(eOmn_serv_config_data_as_battery_t, 16)
 
 typedef union
 {   // max(6, 6, 44, 108, 156, 8, 6, 40)
@@ -555,10 +562,10 @@ typedef union
     eOmn_serv_config_data_as_psc_t          psc;
     eOmn_serv_config_data_as_pos_t          pos;
     eOmn_serv_config_data_as_ft_t           ft;
+    eOmn_serv_config_data_as_battery_t      battery;
 } eOmn_serv_config_data_as_t;               EO_VERIFYsizeof(eOmn_serv_config_data_as_t, 156)
 
 
-
 enum { eomn_serv_skin_maxpatches = 4 };
 
 typedef struct
@@ -664,7 +671,6 @@ typedef union
 } eOmn_serv_config_data_t;                  EO_VERIFYsizeof(eOmn_serv_config_data_t, 328) 
 
 
-
 typedef struct                              
 {   // 1+3+324=328
     uint8_t                                 type;               // use eOmn_serv_type_t to identify what kind of service it is
@@ -673,7 +679,6 @@ typedef struct
     eOmn_serv_config_data_t                 data;   
 } eOmn_serv_configuration_t;                EO_VERIFYsizeof(eOmn_serv_configuration_t, 332) 
 
-
 enum { eOmn_serv_capacity_arrayof_id32 = 41 };
 typedef struct
 {
@@ -754,7 +759,7 @@ typedef struct
 typedef struct
 {   // 32 + 32
     uint8_t                                 stateofservice[eomn_serv_categories_numberof];     // use eOmn_serv_state_t
-    uint8_t                                 filler[6];    
+    uint8_t                                 filler[5];    
     eOmn_service_command_result_t           commandresult;
 } eOmn_service_status_t;                    EO_VERIFYsizeof(eOmn_service_status_t, 48) 
 
@@ -767,7 +772,7 @@ typedef struct
     eOmn_service_status_t                   status;
     eOmn_service_cmmnds_t                   cmmnds;
 } eOmn_service_t;                           EO_VERIFYsizeof(eOmn_service_t, 384)  
-
+//char (*luca)[sizeof( eOmn_service_t )] = 1;
 
 // - declaration of extern public variables, ... but better using use _get/_set instead -------------------------------
 // empty-section
diff --git a/eth/embobj/plus/comm-v2/protocol/api/EoProtocol.h b/eth/embobj/plus/comm-v2/protocol/api/EoProtocol.h
index 9df29cb2..f8475dd4 100644
--- a/eth/embobj/plus/comm-v2/protocol/api/EoProtocol.h
+++ b/eth/embobj/plus/comm-v2/protocol/api/EoProtocol.h
@@ -218,10 +218,11 @@ typedef enum
     eoprot_entity_as_pos                    = eoas_entity_pos,          /**<  */ 
     eoprot_entity_as_ft                     = eoas_entity_ft,           /**<  */      
     eoprot_entity_sk_skin                   = eosk_entity_skin,         /**<  */
+    eoprot_entity_as_battery             = eoas_entity_battery,   /**<  */      
     eoprot_entity_none                      = EOK_uint08dummy
 } eOprot_entity_t;
 
-enum { eoprot_entities_numberof = 16 }; // it does not count the eoprot_entity_none.
+enum { eoprot_entities_numberof = 17 }; // it does not count the eoprot_entity_none.
 
 
 /** @typedef    typedef enum eOprot_index_t
@@ -271,7 +272,7 @@ typedef struct
 } eOprot_callbacks_endpoint_descriptor_t;
 
 
-enum { eoprot_maxvalueof_entity = 7 }; // must be higher equal than the values inside eOprot_entity_t
+enum { eoprot_maxvalueof_entity = 8 }; // must be higher equal than the values inside eOprot_entity_t
 enum { eoprot_entities_maxnumberofsupported = eoprot_maxvalueof_entity+1 }; // it is used to shape data structures
 // it is what is enough to configure an endpoint
 typedef struct                     
diff --git a/eth/embobj/plus/comm-v2/protocol/api/EoProtocolAS.h b/eth/embobj/plus/comm-v2/protocol/api/EoProtocolAS.h
index 5e1c0570..2e939484 100644
--- a/eth/embobj/plus/comm-v2/protocol/api/EoProtocolAS.h
+++ b/eth/embobj/plus/comm-v2/protocol/api/EoProtocolAS.h
@@ -57,7 +57,7 @@ extern "C" {
 // - declaration of public user-defined types ------------------------------------------------------------------------- 
 
 
-enum { eoprot_version_as_major = 1, eoprot_version_as_minor = 6 };
+enum { eoprot_version_as_major = 1, eoprot_version_as_minor = 7 };
 
 
 enum { eoprot_entities_as_numberof = eoas_entities_numberof };
@@ -346,6 +346,38 @@ typedef enum
 
 enum { eoprot_rwms_as_ft_numberof = 5 };  // it MUST be equal to the number of rw modes. 
 
+// - entity battery
+
+
+/** @typedef    typedef enum eOprot_tag_as_battery_t
+    @brief      It contains the tags for all variables of the battery entity.
+                See definition of eOas_battery_t (and its fields) in file EoAnalogSensors.h for explanation of the variables.
+ **/
+typedef enum
+{
+    eoprot_tag_as_battery_config                                        = 0,
+    eoprot_tag_as_battery_cmmnds_enable                                 = 1,
+    eoprot_tag_as_battery_status                                        = 2,
+    eoprot_tag_as_battery_status_timedvalue                             = 3,
+} eOprot_tag_as_battery_t;
+
+enum { eoprot_tags_as_battery_numberof = 4 };  // it MUST be equal to the number of tags. 
+
+
+/** @typedef    typedef enum eOprot_rwm_as_battery_t
+    @brief      It contains the rw modes for all variables of the ft entity. There must be a one-to-one
+                correspondence to the values in eOprot_tag_as_battery_t.
+ **/
+typedef enum
+{
+    eoprot_rwm_as_battery_config                                        = eo_nv_rwmode_RW,
+    eoprot_rwm_as_battery_cmmnds_enable                                 = eo_nv_rwmode_RW,
+    eoprot_rwm_as_battery_status                                        = eo_nv_rwmode_RO,
+    eoprot_rwm_as_battery_status_timedvalue                             = eo_nv_rwmode_RO,
+} eOprot_rwm_as_battery_t; 
+
+enum { eoprot_rwms_as_battery_numberof = 4 };  // it MUST be equal to the number of rw modes. 
+
 
 
 // - structures implementing the endpoints
@@ -364,6 +396,7 @@ typedef struct                  // 56*1+48*1+8*1 = 112
     eOas_psc_t                  psc[1];
     eOas_pos_t                  pos[1];
     eOas_ft_t                   ft[1];
+    eOas_battery_t           battery[1];
 } eOprot_template_as_t;         //EO_VERIFYsizeof(eOprot_template_as_t, 112);
   
   
@@ -525,6 +558,19 @@ extern void eoprot_fun_UPDT_as_ft_status_fullscale(const EOnv* nv, const eOropde
 extern void eoprot_fun_INIT_as_ft_status_timedvalue(const EOnv* nv);
 extern void eoprot_fun_UPDT_as_ft_status_timedvalue(const EOnv* nv, const eOropdescriptor_t* rd);
 
+// -- battery
+
+extern void eoprot_fun_INIT_as_battery_config(const EOnv* nv);
+extern void eoprot_fun_UPDT_as_battery_config(const EOnv* nv, const eOropdescriptor_t* rd);
+
+extern void eoprot_fun_INIT_as_battery_cmmnds_enable(const EOnv* nv);
+extern void eoprot_fun_UPDT_as_battery_cmmnds_enable(const EOnv* nv, const eOropdescriptor_t* rd);
+
+extern void eoprot_fun_INIT_as_battery_status(const EOnv* nv);
+extern void eoprot_fun_UPDT_as_battery_status(const EOnv* nv, const eOropdescriptor_t* rd);
+
+extern void eoprot_fun_INIT_as_battery_status_timedvalue(const EOnv* nv);
+extern void eoprot_fun_UPDT_as_battery_status_timedvalue(const EOnv* nv, const eOropdescriptor_t* rd);
 /** @}            
     end of group eo_EoProtocolAS  
  **/
diff --git a/eth/embobj/plus/comm-v2/protocol/api/EoProtocolMN.h b/eth/embobj/plus/comm-v2/protocol/api/EoProtocolMN.h
index 3cd7ae81..3c8608c6 100644
--- a/eth/embobj/plus/comm-v2/protocol/api/EoProtocolMN.h
+++ b/eth/embobj/plus/comm-v2/protocol/api/EoProtocolMN.h
@@ -58,7 +58,7 @@ extern "C" {
 // - declaration of public user-defined types ------------------------------------------------------------------------- 
 
 
-enum { eoprot_version_mn_major = 2, eoprot_version_mn_minor = 21 };
+enum { eoprot_version_mn_major = 2, eoprot_version_mn_minor = 22 };
 
 
 enum { eoprot_entities_mn_numberof = eomn_entities_numberof };
diff --git a/eth/embobj/plus/comm-v2/protocol/src/EoProtocol.c b/eth/embobj/plus/comm-v2/protocol/src/EoProtocol.c
index 10d51c9c..4fdeb06e 100644
--- a/eth/embobj/plus/comm-v2/protocol/src/EoProtocol.c
+++ b/eth/embobj/plus/comm-v2/protocol/src/EoProtocol.c
@@ -132,7 +132,7 @@ const eOprot_EPcfg_t eoprot_arrayof_stdEPcfg[eoprot_endpoints_numberof] =
     }, 
     {
         EO_INIT(.endpoint)          eoprot_endpoint_analogsensors,
-        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber}
+        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber, 1}
     },
     {
         EO_INIT(.endpoint)          eoprot_endpoint_skin,
@@ -153,7 +153,7 @@ const eOprot_EPcfg_t eoprot_arrayof_maxEPcfg[eoprot_endpoints_numberof] =
     }, 
     {
         EO_INIT(.endpoint)          eoprot_endpoint_analogsensors,
-        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber}
+        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber, 1}
     },
     {
         EO_INIT(.endpoint)          eoprot_endpoint_skin,
@@ -170,7 +170,7 @@ const eOprot_EPcfg_t eoprot_arrayof_maxEPcfgOthers[eoprot_endpoints_numberof-1]
     }, 
     {
         EO_INIT(.endpoint)          eoprot_endpoint_analogsensors,
-        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber}
+        EO_INIT(.numberofentities)  {1, 1, 1, 1, 1, 1, 1, eOas_ft_sensors_maxnumber, 1}
     },
     {
         EO_INIT(.endpoint)          eoprot_endpoint_skin,
diff --git a/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_fun.c b/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_fun.c
index b85e44bf..ad38883e 100644
--- a/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_fun.c
+++ b/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_fun.c
@@ -411,6 +411,36 @@ EO_weak extern void eoprot_fun_INIT_as_ft_status_timedvalue(const EOnv* nv) {}
 EO_weak extern void eoprot_fun_UPDT_as_ft_status_timedvalue(const EOnv* nv, const eOropdescriptor_t* rd) {}
 #endif
     
+// -- battery
+    
+#if !defined(OVERRIDE_eoprot_fun_INIT_as_battery_config)
+EO_weak extern void eoprot_fun_INIT_as_battery_config(const EOnv* nv) {}
+#endif
+#if !defined(OVERRIDE_eoprot_fun_UPDT_as_battery_config)
+EO_weak extern void eoprot_fun_UPDT_as_battery_config(const EOnv* nv, const eOropdescriptor_t* rd) {}
+#endif
+
+#if !defined(OVERRIDE_eoprot_fun_INIT_as_battery_cmmnds_enable)
+EO_weak extern void eoprot_fun_INIT_as_battery_cmmnds_enable(const EOnv* nv) {}
+#endif
+#if !defined(OVERRIDE_eoprot_fun_UPDT_as_battery_cmmnds_enable)
+EO_weak extern void eoprot_fun_UPDT_as_battery_cmmnds_enable(const EOnv* nv, const eOropdescriptor_t* rd) {}
+#endif  
+    
+#if !defined(OVERRIDE_eoprot_fun_INIT_as_battery_status)
+EO_weak extern void eoprot_fun_INIT_as_battery_status(const EOnv* nv) {}
+#endif
+#if !defined(OVERRIDE_eoprot_fun_UPDT_as_battery_status)
+EO_weak extern void eoprot_fun_UPDT_as_battery_status(const EOnv* nv, const eOropdescriptor_t* rd) {}
+#endif
+    
+#if !defined(OVERRIDE_eoprot_fun_INIT_as_battery_status_timedvalue)
+EO_weak extern void eoprot_fun_INIT_as_battery_status_timedvalue(const EOnv* nv) {}
+#endif
+#if !defined(OVERRIDE_eoprot_fun_UPDT_as_battery_status_timedvalue)
+EO_weak extern void eoprot_fun_UPDT_as_battery_status_timedvalue(const EOnv* nv, const eOropdescriptor_t* rd) {}
+#endif
+       
 
 #endif//!defined(EOPROT_CFG_OVERRIDE_CALLBACKS_IN_RUNTIME)
 
diff --git a/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_rom.c b/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_rom.c
index 0974894d..474814c6 100644
--- a/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_rom.c
+++ b/eth/embobj/plus/comm-v2/protocol/src/EoProtocolAS_rom.c
@@ -111,6 +111,9 @@ static const eOas_pos_t eoprot_as_rom_pos_defaultvalue = { 0 };
 // - default value of a ft
 static const eOas_ft_t eoprot_as_rom_ft_defaultvalue = { 0 };
 
+// - default value of a battery
+static const eOas_battery_t eoprot_as_rom_battery_defaultvalue = { 0 };
+
 // - descriptors for the variables of a strain
 
 static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_strain_wholeitem =
@@ -743,6 +746,68 @@ static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_ft_status_fullscale =
 #endif
 };
 
+// - descriptors for the variables of a battery
+
+
+static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_battery_config =
+{   
+    EO_INIT(.capacity)  sizeof(eoprot_as_rom_battery_defaultvalue.config),
+    EO_INIT(.rwmode)    eoprot_rwm_as_battery_config,
+    EO_INIT(.dummy)     0,    
+    EO_INIT(.resetval)  (const void*)&eoprot_as_rom_battery_defaultvalue.config,
+#ifdef EOPROT_CFG_OVERRIDE_CALLBACKS_IN_RUNTIME
+    EO_INIT(.init)      NULL,
+    EO_INIT(.update)    NULL
+#else       
+    EO_INIT(.init)      eoprot_fun_INIT_as_battery_config,
+    EO_INIT(.update)    eoprot_fun_UPDT_as_battery_config
+#endif
+};
+
+static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_battery_cmmnds_enable =
+{   
+    EO_INIT(.capacity)  sizeof(eoprot_as_rom_battery_defaultvalue.cmmnds.enable),
+    EO_INIT(.rwmode)    eoprot_rwm_as_battery_cmmnds_enable,
+    EO_INIT(.dummy)     0,    
+    EO_INIT(.resetval)  (const void*)&eoprot_as_rom_battery_defaultvalue.cmmnds.enable,
+#ifdef EOPROT_CFG_OVERRIDE_CALLBACKS_IN_RUNTIME
+    EO_INIT(.init)      NULL,
+    EO_INIT(.update)    NULL
+#else       
+    EO_INIT(.init)      eoprot_fun_INIT_as_battery_cmmnds_enable,
+    EO_INIT(.update)    eoprot_fun_UPDT_as_battery_cmmnds_enable
+#endif
+};
+
+static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_battery_status =
+{   
+    EO_INIT(.capacity)  sizeof(eoprot_as_rom_battery_defaultvalue.status),
+    EO_INIT(.rwmode)    eoprot_rwm_as_battery_status,
+    EO_INIT(.dummy)     0,    
+    EO_INIT(.resetval)  (const void*)&eoprot_as_rom_battery_defaultvalue.status,
+#ifdef EOPROT_CFG_OVERRIDE_CALLBACKS_IN_RUNTIME
+    EO_INIT(.init)      NULL,
+    EO_INIT(.update)    NULL
+#else       
+    EO_INIT(.init)      eoprot_fun_INIT_as_battery_status,
+    EO_INIT(.update)    eoprot_fun_UPDT_as_battery_status
+#endif
+};
+
+static EOPROT_ROMmap EOnv_rom_t eoprot_as_rom_descriptor_battery_status_timedvalue =
+{   
+    EO_INIT(.capacity)  sizeof(eoprot_as_rom_battery_defaultvalue.status.timedvalue),
+    EO_INIT(.rwmode)    eoprot_rwm_as_battery_status_timedvalue,
+    EO_INIT(.dummy)     0,    
+    EO_INIT(.resetval)  (const void*)&eoprot_as_rom_battery_defaultvalue.status.timedvalue,
+#ifdef EOPROT_CFG_OVERRIDE_CALLBACKS_IN_RUNTIME
+    EO_INIT(.init)      NULL,
+    EO_INIT(.update)    NULL
+#else       
+    EO_INIT(.init)      eoprot_fun_INIT_as_battery_status_timedvalue,
+    EO_INIT(.update)    eoprot_fun_UPDT_as_battery_status_timedvalue
+#endif
+};
 
 // --------------------------------------------------------------------------------------------------------------------
 // - definition (and initialisation) of extern variables
@@ -831,6 +896,14 @@ static EOPROT_ROMmap EOnv_rom_t * const s_eoprot_as_rom_ft_descriptors[] =
     &eoprot_as_rom_descriptor_ft_status_fullscale,
 };  EO_VERIFYsizeof(s_eoprot_as_rom_ft_descriptors, sizeof(EOPROT_ROMmap EOnv_rom_t* const)*(eoprot_tags_as_ft_numberof))
 
+static EOPROT_ROMmap EOnv_rom_t * const s_eoprot_as_rom_battery_descriptors[] =
+{   // here are eoprot_tags_as_inertial_numberof descriptors for the inertial entity
+    &eoprot_as_rom_descriptor_battery_config,
+    &eoprot_as_rom_descriptor_battery_cmmnds_enable,
+    &eoprot_as_rom_descriptor_battery_status,
+    &eoprot_as_rom_descriptor_battery_status_timedvalue,
+};  EO_VERIFYsizeof(s_eoprot_as_rom_battery_descriptors, sizeof(EOPROT_ROMmap EOnv_rom_t* const)*(eoprot_tags_as_battery_numberof))
+
 EOPROT_ROMmap EOnv_rom_t * const * const eoprot_as_rom_descriptors[] = 
 {
     (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_strain_descriptors,
@@ -840,10 +913,10 @@ EOPROT_ROMmap EOnv_rom_t * const * const eoprot_as_rom_descriptors[] =
     (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_inertial3_descriptors,
     (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_psc_descriptors,
     (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_pos_descriptors,
-    (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_ft_descriptors
+    (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_ft_descriptors,
+    (EOPROT_ROMmap EOnv_rom_t **)&s_eoprot_as_rom_battery_descriptors
 };  EO_VERIFYsizeof(eoprot_as_rom_descriptors, sizeof(EOPROT_ROMmap EOnv_rom_t** const)*(eoprot_entities_as_numberof))
 
-
 // the other constants: to be changed when a new entity is added
 
 const uint8_t eoprot_as_rom_tags_numberof[] = 
@@ -855,7 +928,8 @@ const uint8_t eoprot_as_rom_tags_numberof[] =
     eoprot_tags_as_inertial3_numberof,
     eoprot_tags_as_psc_numberof,
     eoprot_tags_as_pos_numberof,
-    eoprot_tags_as_ft_numberof
+    eoprot_tags_as_ft_numberof,
+    eoprot_tags_as_battery_numberof
 };  EO_VERIFYsizeof(eoprot_as_rom_tags_numberof, eoprot_entities_as_numberof*sizeof(uint8_t)) 
 
 const uint16_t eoprot_as_rom_entities_sizeof[] = 
@@ -867,7 +941,8 @@ const uint16_t eoprot_as_rom_entities_sizeof[] =
     sizeof(eOas_inertial3_t),
     sizeof(eOas_psc_t),
     sizeof(eOas_pos_t),
-    sizeof(eOas_ft_t)
+    sizeof(eOas_ft_t),
+    sizeof(eOas_battery_t)
 };  EO_VERIFYsizeof(eoprot_as_rom_entities_sizeof, eoprot_entities_as_numberof*sizeof(uint16_t)) 
 
 const void* const eoprot_as_rom_entities_defval[] = 
@@ -879,7 +954,8 @@ const void* const eoprot_as_rom_entities_defval[] =
     (const void*)&eoprot_as_rom_inertial3_defaultvalue,
     (const void*)&eoprot_as_rom_psc_defaultvalue,
     (const void*)&eoprot_as_rom_pos_defaultvalue,
-    (const void*)&eoprot_as_rom_ft_defaultvalue
+    (const void*)&eoprot_as_rom_ft_defaultvalue,
+    (const void*)&eoprot_as_rom_battery_defaultvalue,
 };  EO_VERIFYsizeof(eoprot_as_rom_entities_defval, eoprot_entities_as_numberof*sizeof(const void*)) 
 
 
@@ -894,7 +970,8 @@ const char * const eoprot_as_strings_entity[] =
     "eoprot_entity_as_inertial3",
     "eoprot_entity_as_psc",
     "eoprot_entity_as_pos",
-    "eoprot_entity_as_ft"
+    "eoprot_entity_as_ft",
+    "eoprot_entity_as_battery"
 };  EO_VERIFYsizeof(eoprot_as_strings_entity, eoprot_entities_as_numberof*sizeof(const char*)) 
 
 
@@ -971,6 +1048,14 @@ static const char * const s_eoprot_as_strings_tags_ft[] =
     "eoprot_tag_as_ft_status_timedvalue",
 };  EO_VERIFYsizeof(s_eoprot_as_strings_tags_ft, eoprot_tags_as_ft_numberof*sizeof(const char*)) 
 
+static const char * const s_eoprot_as_strings_tags_battery[] =
+{
+    "eoprot_tag_as_battery_config",
+    "eoprot_tag_as_battery_cmmnds_enable",
+    "eoprot_tag_as_battery_status",
+    "eoprot_tag_as_battery_status_timedvalue",
+};  EO_VERIFYsizeof(s_eoprot_as_strings_tags_battery, eoprot_tags_as_battery_numberof*sizeof(const char*)) 
+
 
 const char ** const eoprot_as_strings_tags[] =
 {
@@ -981,7 +1066,8 @@ const char ** const eoprot_as_strings_tags[] =
     (const char**)&s_eoprot_as_strings_tags_inertial3,
     (const char**)&s_eoprot_as_strings_tags_psc,
     (const char**)&s_eoprot_as_strings_tags_pos,
-    (const char**)&s_eoprot_as_strings_tags_ft
+    (const char**)&s_eoprot_as_strings_tags_ft,
+    (const char**)&s_eoprot_as_strings_tags_battery,
 };  EO_VERIFYsizeof(eoprot_as_strings_tags, eoprot_entities_as_numberof*sizeof(const char**)) 
 
 
@@ -1005,6 +1091,3 @@ const char ** const eoprot_as_strings_tags[] =
 // --------------------------------------------------------------------------------------------------------------------
 // - end-of-file (leave a blank line after)
 // --------------------------------------------------------------------------------------------------------------------
-
-
-