expose releaseAddress() for master node (#244)

* resolves #219
* expose mesh_address in python wrapper
* fix py bindings for getNodeID() and renewAddress()
* don't expose addrList due to unsatisfied  implementation details

RF24Mesh.cpp

@@ -89,11 +89,7 @@ uint8_t ESBMesh<network_t, radio_t>::update()
         }
         else if (type == MESH_ADDR_RELEASE) {
             uint16_t* fromAddr = (uint16_t*)network.frame_buffer;
-            for (uint8_t i = 0; i < addrListTop; i++) {
-                if (addrList[i].address == *fromAddr) {
-                    addrList[i].address = 0;
-                }
-            }
+            releaseAddress(*fromAddr);
         }
     }
 #endif //!NO_MASTER
@@ -288,6 +284,22 @@ bool ESBMesh<network_t, radio_t>::releaseAddress()
 
 /*****************************************************/
 
+#ifndef MESH_NO_MASTER
+template<class network_t, class radio_t>
+bool ESBMesh<network_t, radio_t>::releaseAddress(uint16_t address)
+{
+    for (uint8_t i = 0; i < addrListTop; ++i) {
+        if (addrList[i].address == address) {
+            addrList[i].address = 0;
+            return true;
+        }
+    }
+    return false;
+}
+#endif
+
+/*****************************************************/
+
 template<class network_t, class radio_t>
 uint16_t ESBMesh<network_t, radio_t>::renewAddress(uint32_t timeout)
 {

RF24Mesh.h

@@ -341,6 +341,18 @@ class ESBMesh
     addrListStruct* addrList;
     /** @brief The number of entries in the addrListStruct of assigned addresses. */
     uint8_t addrListTop;
+
+    /**
+     * Releases the specified address if leased to a mesh node's ID.
+     *
+     * This is specific to master nodes, so network administrators can
+     * manage assigned addresses without notifying the nodes that
+     * might be appropriating them.
+     *
+     * @param address The address to release from any mesh node.
+     * @return True if successfully released, otherwise false.
+     */
+    bool releaseAddress(uint16_t address);
 #endif
     /**@}*/
 

pyRF24Mesh/pyRF24Mesh.cpp

@@ -65,7 +65,16 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(renewAddress_overload, RF24Mesh::renewAdd
 // ******************** RF24Mesh exposed  **************************
 BOOST_PYTHON_MODULE(RF24Mesh)
 {
-    { //::RF24Mesh
+    {
+        /* Binding this class is useless unless we can properly expose RF24Mesh::addrList.
+           A converter from addrListStruct[] to bp::list<AddrListStruct> needs to be implemented.
+        // ::RF24Mesh::addrListStruct
+        bp::class_<RF24Mesh::addrListStruct>("addrListStruct", bp::init<>())
+            .def_readonly("nodeID", &RF24Mesh::addrListStruct::nodeID)
+            .def_readwrite("address", &RF24Mesh::addrListStruct::address);
+        */
+
+        //::RF24Mesh
         bp::class_<RF24Mesh>("RF24Mesh", bp::init<RF24&, RF24Network&>((bp::arg("_radio"), bp::arg("_network"))))
             //bool begin(uint8_t channel = MESH_DEFAULT_CHANNEL, rf24_datarate_e data_rate = RF24_1MBPS, uint32_t timeout=MESH_RENEWAL_TIMEOUT );
             .def("begin", &RF24Mesh::begin, begin_overload(bp::args("channel", "data_rate", "timeout")))
@@ -80,14 +89,22 @@ BOOST_PYTHON_MODULE(RF24Mesh)
             .def("setNodeID", &RF24Mesh::setNodeID, (bp::arg("nodeID")))
             //void DHCP();
             .def("DHCP", &RF24Mesh::DHCP)
-            //int16_t getNodeID(uint16_t address=MESH_BLANK_ID);
+            //int16_t getNodeID(uint16_t address);
             .def("getNodeID", &RF24Mesh::getNodeID, getNodeID_overload(bp::args("address")))
+            //int16_t getNodeID(); where address arg defaults to MESH_BLANK_ID
+            .def("getNodeID", &RF24Mesh::getNodeID, getNodeID_overload())
             //bool checkConnection();
             .def("checkConnection", &RF24Mesh::checkConnection)
-            //uint16_t renewAddress(uint32_t timeout=MESH_RENEWAL_TIMEOUT);
-            .def("renewAddress", &RF24Mesh::renewAddress, getNodeID_overload(bp::args("timeout")))
+            //uint16_t renewAddress(uint32_t timeout);
+            .def("renewAddress", &RF24Mesh::renewAddress, renewAddress_overload(bp::args("timeout")))
+            //uint16_t renewAddress(); where timeout arg defaults to MESH_RENEWAL_TIMEOUT
+            .def("renewAddress", &RF24Mesh::renewAddress, renewAddress_overload())
             //bool releaseAddress();
-            .def("releaseAddress", &RF24Mesh::releaseAddress)
+            .def("releaseAddress", (bool(RF24Mesh::*)()) & RF24Mesh::releaseAddress)
+#ifndef MESH_NO_MASTER
+            //bool releaseAddress(uint16_t address);
+            .def("releaseAddress", (bool(RF24Mesh::*)(uint16_t)) & RF24Mesh::releaseAddress, (bp::args("address")))
+#endif
             //int16_t getAddress(uint8_t nodeID);
             .def("getAddress", &RF24Mesh::getAddress, (bp::arg("nodeID")))
             //void setChannel(uint8_t _channel);
@@ -100,6 +117,14 @@ BOOST_PYTHON_MODULE(RF24Mesh)
             .def("saveDHCP", &RF24Mesh::saveDHCP)
             //void loadDHCP();
             .def("loadDHCP", &RF24Mesh::loadDHCP)
+            // mesh_address
+            .def_readwrite("mesh_address", &RF24Mesh::mesh_address)
+
+            // Returning an array of wrapped addrListStruct objects in boost.python is non-trivial.
+            // I'm commenting out the members related to the RF24Mesh::addrList until a solution can be found.
+            // .def_readonly("addrListTop", &RF24Mesh::addrListTop)
+            // .def_readonly("addrList", &RF24Mesh::addrList)
+
             //void setStaticAddress(uint8_t nodeID, uint16_t address);
             .def("setStaticAddress", &RF24Mesh::setStaticAddress, (bp::arg("nodeID"), bp::arg("address")));
     }

pyRF24Mesh/setup.py

@@ -45,7 +45,6 @@
             "RF24Mesh",
             sources=["pyRF24Mesh.cpp"],
             libraries=["rf24mesh", "rf24network", "rf24", BOOST_LIB],
-            extra_compile_args=["-DRF24_NO_INTERRUPT"]
         )
     ],
 )