diff --git a/driver/software/MiWi/MiWi_Mesh/inc/miwi_app.h b/driver/software/MiWi/MiWi_Mesh/inc/miwi_app.h
index dd3f14f..c35555d 100644
--- a/driver/software/MiWi/MiWi_Mesh/inc/miwi_app.h
+++ b/driver/software/MiWi/MiWi_Mesh/inc/miwi_app.h
@@ -76,11 +76,13 @@ typedef enum AppState_t {
 	APP_STATE_SLEEP,
     APP_STATE_FREQUENCY_AGILITY,
     APP_STATE_NOISE_DETECTION,
+    APP_ADD_ACCEPTED_ADDRESS
 } AppState_t;
 
 extern AppState_t appStates;
 extern uint8_t channelCount;
 extern uint8_t maxRSSI;
+extern uint8_t deviceCountRem;
 //extern bool deviceCanSleep;
 extern SYS_TIME_HANDLE testtimehandle;
 // *****************************************************************************
diff --git a/driver/software/MiWi/MiWi_Mesh/src/miwi_app.c b/driver/software/MiWi/MiWi_Mesh/src/miwi_app.c
index df5f07f..40879a4 100644
--- a/driver/software/MiWi/MiWi_Mesh/src/miwi_app.c
+++ b/driver/software/MiWi/MiWi_Mesh/src/miwi_app.c
@@ -75,6 +75,14 @@ static bool deviceCanSleep = false;
 static STACK_API_Request apiReq;
 uint8_t channelCount = 0U;
 uint8_t maxRSSI;
+uint8_t bloomFilterValue[BLOOM_FILTER_SIZE];
+uint8_t maxNumDevices = MAX_NUMBER_OF_DEVICES_IN_NETWORK;
+uint8_t acceptedDeviceCount = 0;
+// Increase the number of devices that can join the network by changing the parameter "numDevices".  Also add the device address, which can form a part of the network, in the array "acceptedDeviceAddress".
+//This Address filtering feature is activated only by enabling the macor "ADDRESS_CHECK"
+uint8_t const numDevices = 1;
+uint64_t acceptedDeviceAddress [1] = {0x22665544332211AB};//{0x33665544332211AB, 0x22665544332211AB,0x55665544332211AB,0x66665544332211AB,0x77665544332211AB,0x88665544332211AB, 0x99665544332211AB, 0x44665544332211AB, 0x11555544332211AB,0x22555544332211AB};
+uint8_t deviceCountRem = numDevices;
 static uint8_t gOptimalChannel = 0xFFU;
 static uint8_t minRSSI = 0xFFU;
 // *****************************************************************************
@@ -460,9 +468,35 @@ void MiAPP_TaskHandler(APP_Msg_T *appState)
         apiReq.paramSize = (uint8_t)sizeof(startNetworkReq_t);
         apiReq.uApiID = (uint8_t)MIWI_START_NW;
         MIWI_API_CALL((STACK_API_Request*)&apiReq);
+        APP_Msg_T    appMsg;
+        APP_Msg_T *appState;
+        appState = &appMsg;
+        appStates = APP_ADD_ACCEPTED_ADDRESS;
+        appState->msgId = (uint8_t)APP_ADD_ACCEPTED_ADDRESS;
+        OSAL_QUEUE_Send(&appData.appQueue, appState, 0);
 	break;
 	}
 
+    case APP_ADD_ACCEPTED_ADDRESS:
+    {
+        if (deviceCountRem !=0)
+        {
+            if (!bloomFilterAutoJoin)
+                {
+                    if (acceptedDeviceAddress[acceptedDeviceCount]!= 0)
+                        {
+                            bool addNewDevice = MiApp_Commissioning_AddNewDevice(acceptedDeviceAddress[acceptedDeviceCount], true);
+                            if (addNewDevice == true);
+                            {
+                                deviceCountRem--;
+                                acceptedDeviceCount++;
+                            }
+                        }
+                }
+        }  
+    break;
+    }
+
 #else
 	case (uint8_t)APP_STATE_CONNECT_NETWORK:
 	{
diff --git a/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_commissioning.c b/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_commissioning.c
index 9375ad2..1824be8 100644
--- a/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_commissioning.c
+++ b/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_commissioning.c
@@ -54,7 +54,11 @@ static uint8_t initiateNetworkBloomUpdate(void);
 #if defined(PAN_COORDINATOR)
 static uint8_t NumOfCommnDevices = 0;
 #endif
+#ifndef ADDRESS_CHECK
 bool bloomFilterAutoJoin = true;
+#else
+bool bloomFilterAutoJoin = false;
+#endif
 
 /************************ Function Definitions **********************************/
 
@@ -282,6 +286,15 @@ static void commandConfcb(uint8_t handle, miwi_status_t status, uint8_t* msgPoin
      (void)handle;
      (void)status;
      (void)msgPointer;
+        if (!bloomFilterAutoJoin)
+        {
+            APP_Msg_T    appMsg;
+            APP_Msg_T *appState;
+            appState = &appMsg;
+            appStates = APP_ADD_ACCEPTED_ADDRESS;
+            appState->msgId = (uint8_t)APP_ADD_ACCEPTED_ADDRESS;
+            OSAL_QUEUE_Send(&appData.appQueue, appState, 0);  
+        }
 }
 
 /************************************************************************************
diff --git a/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_join.c b/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_join.c
index 8d5e3b3..ccbabd5 100644
--- a/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_join.c
+++ b/driver/software/MiWi/MiWi_Mesh/src/miwi_mesh_join.c
@@ -69,7 +69,7 @@ uint16_t myParentShortAddress = 0xFFFFU;
 static bool connectionPermit = false;
 static uint8_t endDeviceCapacityPercent = 0U;
 static uint8_t SleepEndDeviceCapacityPercent = 0U;
-uint8_t bloomFilterValue[BLOOM_FILTER_SIZE];
+//uint8_t bloomFilterValue[BLOOM_FILTER_SIZE];
 uint8_t backupChannel = 0U;
 #ifndef PAN_COORDINATOR
 uint8_t edLinkFailureAttempts;
@@ -474,11 +474,6 @@ bool MiApp_StartConnection(uint8_t Mode, uint8_t ScanDuration, uint32_t ChannelM
     /* Store scan duration */
     gChannelMap = ChannelMap;
 
-    /* bloom filter feature*/
-	if (!bloomFilterAutoJoin)
-	{
-        MiApp_Commissioning_AddNewDevice(0x11665544332211AB, true); //0x11665544332211AB is ieee address which can be modified for bloom filter enable
-    }
     
     switch(Mode)
     {
diff --git a/driver/software/MiWi/MiWi_P2P/inc/miwi_p2p_star.h b/driver/software/MiWi/MiWi_P2P/inc/miwi_p2p_star.h
index 75d03d5..710e397 100644
--- a/driver/software/MiWi/MiWi_P2P/inc/miwi_p2p_star.h
+++ b/driver/software/MiWi/MiWi_P2P/inc/miwi_p2p_star.h
@@ -228,4 +228,8 @@ extern uint8_t optimalChannel;
 #endif
 bool    isSameAddress(uint8_t *Address1, uint8_t *Address2);
 
+void addAcceptedDeviceAddr(uint64_t *acceptedAddr);
+uint64_t convert_to_64bit(uint8_t* memory_location);
+bool checkDevAddr(uint8_t* addressToCheck);
+
 #endif //__MIWI_P2P_STAR_H_
\ No newline at end of file
diff --git a/driver/software/MiWi/MiWi_P2P/src/miwi_app.c b/driver/software/MiWi/MiWi_P2P/src/miwi_app.c
index 4270b5c..38de3bb 100644
--- a/driver/software/MiWi/MiWi_P2P/src/miwi_app.c
+++ b/driver/software/MiWi/MiWi_P2P/src/miwi_app.c
@@ -111,6 +111,8 @@ uint8_t myChannel = 26U;
  recommendation from Data Sheet for European band (ie.,Channel 0)*/
 #endif
 
+
+uint64_t devicesToBeAccepted[CONNECTION_SIZE] = {0x33665544332211AB,0x22665544332211AB,0x44665544332211AB,0,0};
 /*********************************************************************
 * Function: bool freezer_feature(void)
 *
@@ -293,6 +295,7 @@ bool Initialize_Demo(bool freezer_enable)
     DemoOutput_Channel(myChannel, 0U);
 
     startNetwork =  false;
+    addAcceptedDeviceAddr(devicesToBeAccepted);
 
     /* Try to establish a new connection with peer device by broadcast Connection Request */
     return MiApp_EstablishConnection(myChannel, 2U, (uint8_t*)&broadcastAddr, 0U, Connection_Confirm);
diff --git a/driver/software/MiWi/MiWi_P2P/src/miwi_p2p_star.c b/driver/software/MiWi/MiWi_P2P/src/miwi_p2p_star.c
index 7764e54..c12f9c2 100644
--- a/driver/software/MiWi/MiWi_P2P/src/miwi_p2p_star.c
+++ b/driver/software/MiWi/MiWi_P2P/src/miwi_p2p_star.c
@@ -113,6 +113,11 @@ typedef struct _TxFrame_t
         buffer_t* pMemClr;
 } __attribute__((packed, aligned(1)))TxFrame_t;
 
+typedef struct
+{
+    uint64_t deviceAddress;
+} AcceptedDeviceTable_t;
+
 /********************* Global and Static Variables *************************************/
 static DataConf_callback_t sentFrameCb;
 uint8_t busyLock = 0;
@@ -236,6 +241,12 @@ PacketIndCallback_t pktRxcallback = NULL;
 #if defined(ENABLE_SECURITY)
 API_UINT32_UNION IncomingFrameCounter[CONNECTION_SIZE];  // If authentication is used, IncomingFrameCounter can prevent replay attack
 #endif
+#if defined (ADDRESS_CHECK)
+bool filterDeviceAddress = true;
+#else
+bool filterDeviceAddress = false;
+#endif
+AcceptedDeviceTable_t acceptedDevTable[CONNECTION_SIZE];
 /************************************** Function Prototypes****************************************************/
 bool frameTransmit(bool Broadcast,API_UINT16_UNION DestinationPANID, uint8_t *DestinationAddress, bool isCommand, bool SecurityEnabled,
                     uint8_t msgLen,  uint8_t* msgPtr,  uint8_t msghandle,  bool ackReq,  DataConf_callback_t ConfCallback, buffer_t* memClrPtr);
@@ -287,6 +298,45 @@ static void StartChannelHopping(void);
 static void channelHopCmdCallback(uint8_t msgConfHandle, miwi_status_t status, uint8_t* msgPointer);
 #endif
 /********************* Function Definitions *******************************************/
+void addAcceptedDeviceAddr(uint64_t *acceptedAddr)
+{
+    if (filterDeviceAddress)
+    {
+        for (uint8_t i = 0; i<CONNECTION_SIZE; i++)
+        {
+            //if (acceptedAddr[i]!=0)
+            acceptedDevTable[i].deviceAddress = acceptedAddr[i];
+        }
+    }   
+}
+
+uint64_t convert_to_64bit(uint8_t* memory_location) 
+{
+    uint64_t result = 0;
+    for (uint8_t i = 0; i < 8; i++) 
+    {
+        result |= ((uint64_t)memory_location[7-i]) << (8 * (7 - i));
+    }
+    return result;
+}
+
+bool checkDevAddr(uint8_t* addressToCheck)
+{
+    if (filterDeviceAddress)
+    {
+    uint64_t addr = convert_to_64bit(addressToCheck);
+    for (uint8_t i=0; i<CONNECTION_SIZE; i++)
+    {
+        if (addr == acceptedDevTable[i].deviceAddress)
+        {
+            return true;
+        }
+    }
+    return false;
+    }
+    return true;
+}
+
 miwi_status_t MiApp_ProtocolInit(defaultParametersRomOrRam_t *defaultRomOrRamParams,
                                        defaultParametersRamOnly_t *defaultRamOnlyParams)
 {
@@ -2106,6 +2156,11 @@ void frameParse(MAC_RECEIVED_PACKET *macRxPacket)
                 else
 #endif
                 {
+                bool addrPresent = checkDevAddr(MACRxPacket.SourceAddress);
+                if (!addrPresent)
+                {
+                    return;
+                }
                     /* Request accepted, try to add the requesting device into P2P Connection Entry */
                     status = AddConnection(rxMessage.Payload[2]);
                 }
diff --git a/driver/software/MiWi/MiWi_Star/inc/miwi_p2p_star.h b/driver/software/MiWi/MiWi_Star/inc/miwi_p2p_star.h
index 97026c9..d8c0471 100644
--- a/driver/software/MiWi/MiWi_Star/inc/miwi_p2p_star.h
+++ b/driver/software/MiWi/MiWi_Star/inc/miwi_p2p_star.h
@@ -234,4 +234,7 @@ extern uint8_t optimalChannel;
 #endif
 bool    isSameAddress(uint8_t *Address1, uint8_t *Address2);
 
+void addAcceptedDeviceAddr(uint64_t *acceptedAddr);
+uint64_t convert_to_64bit(uint8_t* memory_location);
+bool checkDevAddr(uint8_t* addressToCheck);
 #endif //__MIWI_P2P_STAR_H_
\ No newline at end of file
diff --git a/driver/software/MiWi/MiWi_Star/src/miwi_app.c b/driver/software/MiWi/MiWi_Star/src/miwi_app.c
index 078b818..1e3c433 100644
--- a/driver/software/MiWi/MiWi_Star/src/miwi_app.c
+++ b/driver/software/MiWi/MiWi_Star/src/miwi_app.c
@@ -111,6 +111,8 @@ uint8_t myChannel = 26U;
  recommendation from Data Sheet for European band (ie.,Channel 0)*/
 #endif
 
+
+uint64_t devicesToBeAccepted[CONNECTION_SIZE] = {0x33665544332211AB,0x22665544332211AB,0x44665544332211AB,0,0};
 /*********************************************************************
 * Function: bool freezer_feature(void)
 *
@@ -298,6 +300,8 @@ bool Initialize_Demo(bool freezer_enable)
     DemoOutput_Channel(myChannel, 0U);
 
     startNetwork =  false;
+    
+    addAcceptedDeviceAddr(devicesToBeAccepted);
 
     /* Try to establish a new connection with peer device by broadcast Connection Request */
     return MiApp_EstablishConnection(myChannel, 2U, (uint8_t*)&broadcastAddr, 0U, Connection_Confirm);
diff --git a/driver/software/MiWi/MiWi_Star/src/miwi_p2p_star.c b/driver/software/MiWi/MiWi_Star/src/miwi_p2p_star.c
index 4a92030..65891c4 100644
--- a/driver/software/MiWi/MiWi_Star/src/miwi_p2p_star.c
+++ b/driver/software/MiWi/MiWi_Star/src/miwi_p2p_star.c
@@ -113,6 +113,12 @@ typedef struct _TxFrame_t
         buffer_t* pMemClr;
 } __attribute__((packed, aligned(1)))TxFrame_t;
 
+
+typedef struct
+{
+    uint64_t deviceAddress;
+} AcceptedDeviceTable_t;
+
 /********************* Global and Static Variables *************************************/
 static DataConf_callback_t sentFrameCb;
 uint8_t busyLock = 0U;
@@ -240,6 +246,13 @@ PacketIndCallback_t pktRxcallback = NULL;
 #if defined(ENABLE_SECURITY)
 API_UINT32_UNION IncomingFrameCounter[CONNECTION_SIZE];  // If authentication is used, IncomingFrameCounter can prevent replay attack
 #endif
+
+#if defined (ADDRESS_CHECK)
+bool filterDeviceAddress = true;
+#else
+bool filterDeviceAddress = false;
+#endif
+AcceptedDeviceTable_t acceptedDevTable[CONNECTION_SIZE];
 /************************************** Function Prototypes****************************************************/
 bool frameTransmit(bool Broadcast,API_UINT16_UNION DestinationPANID, uint8_t *DestinationAddress, bool isCommand, bool SecurityEnabled,
                     uint8_t msgLen,  uint8_t* msgPtr,  uint8_t msghandle,  bool ackReq,  DataConf_callback_t ConfCallback, buffer_t* memClrPtr);
@@ -296,6 +309,46 @@ static void channelHopCmdCallback(uint8_t msgConfHandle, miwi_status_t status, u
 //extern uint8_t ConnMode;
 //extern uint8_t LatestConnection;
 //extern CONNECTION_ENTRY connectionTable[CONNECTION_SIZE];
+void addAcceptedDeviceAddr(uint64_t *acceptedAddr)
+{
+    if (filterDeviceAddress)
+    {
+        for (uint8_t i = 0; i<CONNECTION_SIZE; i++)
+        {
+            //if (acceptedAddr[i]!=0)
+            acceptedDevTable[i].deviceAddress = acceptedAddr[i];
+        }
+    }   
+}
+
+uint64_t convert_to_64bit(uint8_t* memory_location) 
+{
+    uint64_t result = 0;
+    for (uint8_t i = 0; i < 8; i++) 
+    {
+        result |= ((uint64_t)memory_location[7-i]) << (8 * (7 - i));
+    }
+    return result;
+}
+
+bool checkDevAddr(uint8_t* addressToCheck)
+{
+    if (filterDeviceAddress)
+    {
+    uint64_t addr = convert_to_64bit(addressToCheck);
+    for (uint8_t i=0; i<CONNECTION_SIZE; i++)
+    {
+        if (addr == acceptedDevTable[i].deviceAddress)
+        {
+            return true;
+        }
+    }
+    return false;
+    }
+    return true;
+}
+
+
 /********************* Function Definitions *******************************************/
 miwi_status_t MiApp_ProtocolInit(defaultParametersRomOrRam_t *defaultRomOrRamParams,
                                        defaultParametersRamOnly_t *defaultRamOnlyParams)
@@ -2138,6 +2191,11 @@ void frameParse(MAC_RECEIVED_PACKET *macRxPacket)
                 else
 #endif
                 {
+                bool addrPresent = checkDevAddr(MACRxPacket.SourceAddress);
+                if (!addrPresent)
+                {
+                    return;
+                }
                     /* Request accepted, try to add the requesting device into P2P Connection Entry */
                     status = AddConnection(rxMessage.Payload[2]);
                 }
diff --git a/release_notes.md b/release_notes.md
index 73401db..b03f89a 100644
--- a/release_notes.md
+++ b/release_notes.md
@@ -14,6 +14,10 @@ With MiWi, application developers can switch between RF transceivers and wireles
 The three layers are linked together by MiMAC and MiApp interfaces. The Application layer uses MiApp interfaces to communicate to the protocol layer. In the protocol layer, there are implementations of MiWi Mesh, MiWi P2P, MiWi Star wireless communication protocols. 
 The drivers for WBZ451 and other Standalone Microchip RF transceivers (AT86RF233, AT86RF212B, AT86RF215) are called by protocol layers via MiMAC interfaces.
 
+## New Features
+
+-   Introduced Address Filtering fearute during network formation, activated by enabling the macro ADDRESS_CHECK.
+
 ## Known Issues / Limitations
 
 -	OTAU is not supported.