Tasmota/lib/lib_rf/RF24/pyRF24/pyRF24Mesh/pyRF24Mesh.cpp

#include "boost/python.hpp"
#include "RF24/RF24.h"
#include "RF24Network/RF24Network.h"
#include "RF24Mesh/RF24Mesh.h"

namespace bp = boost::python;


// ******************** explicit wrappers **************************
// where needed, especially where buffer is involved

void throw_ba_exception(void)
{
    PyErr_SetString(PyExc_TypeError, "buf parameter must be bytes or bytearray");
    bp::throw_error_already_set();
}

char *get_bytes_or_bytearray_str(bp::object buf)
{
    PyObject *py_ba;
    py_ba = buf.ptr();
    if (PyByteArray_Check(py_ba))
        return PyByteArray_AsString(py_ba);
    else if (PyBytes_Check(py_ba))
        return PyBytes_AsString(py_ba);
    else
        throw_ba_exception();
    return NULL;
}

int get_bytes_or_bytearray_ln(bp::object buf)
{
    PyObject *py_ba;
    py_ba = buf.ptr();
    if (PyByteArray_Check(py_ba))
        return PyByteArray_Size(py_ba);
    else if (PyBytes_Check(py_ba))
        return PyBytes_Size(py_ba);
    else
        throw_ba_exception();
    return 0;
}

bool write_wrap1(RF24Mesh& ref, bp::object buf, uint8_t msg_type)
{
	return ref.write(get_bytes_or_bytearray_str(buf), msg_type, get_bytes_or_bytearray_ln(buf));
}

bool write_wrap2(RF24Mesh& ref, bp::object buf, uint8_t msg_type, uint8_t nodeID)
{
	return ref.write(get_bytes_or_bytearray_str(buf), msg_type, get_bytes_or_bytearray_ln(buf), nodeID);
}

bool write_to_node_wrap(RF24Mesh& ref, uint16_t to_node,  bp::object buf, uint8_t msg_type)
{
	return ref.write(to_node, get_bytes_or_bytearray_str(buf), msg_type, get_bytes_or_bytearray_ln(buf));
}

// ******************** overload wrappers **************************
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(begin_overload, RF24Mesh::begin, 0, 3)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getNodeID_overload, RF24Mesh::getNodeID, 0, 1)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(renewAddress_overload, RF24Mesh::renewAddress, 0, 1)

// ******************** RF24Mesh exposed  **************************
BOOST_PYTHON_MODULE(RF24Mesh)
{
    { //::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")))
            //uint8_t update();
            .def("update", &RF24Mesh::update)
            //bool write(const void* data, uint8_t msg_type, size_t size, uint8_t nodeID=0);
            .def("write", &write_wrap1, (bp::arg("data"), bp::arg("msg_type")))
            .def("write", &write_wrap2, (bp::arg("data"), bp::arg("msg_type"), bp::arg("nodeID")))
            //bool write(uint16_t to_node, const void* data, uint8_t msg_type, size_t size );
            .def("write", &write_to_node_wrap, (bp::arg("to_node"), bp::arg("data"), bp::arg("msg_type"), bp::arg("size")))
            //void setNodeID(uint8_t nodeID);
            .def("setNodeID", &RF24Mesh::setNodeID, (bp::arg("nodeID")))
            //void DHCP();
            .def("DHCP", &RF24Mesh::DHCP)
            //int16_t getNodeID(uint16_t address=MESH_BLANK_ID);
            .def("getNodeID", &RF24Mesh::getNodeID, getNodeID_overload(bp::args("address")))
            //bool checkConnection();
            .def("checkConnection", &RF24Mesh::checkConnection)
            //uint16_t renewAddress(uint32_t timeout=MESH_RENEWAL_TIMEOUT);
            .def("renewAddress", &RF24Mesh::renewAddress, getNodeID_overload(bp::args("timeout")))
            //bool releaseAddress();
            .def("releaseAddress", &RF24Mesh::releaseAddress)
            //int16_t getAddress(uint8_t nodeID);
            .def("getAddress", &RF24Mesh::getAddress, (bp::arg("nodeID")))
            //void setChannel(uint8_t _channel);
            .def("setChannel", &RF24Mesh::setChannel, (bp::arg("_channel")))
            //void setChild(bool allow);
            .def("setChild", &RF24Mesh::setChild, (bp::arg("allow")))
            //void setAddress(uint8_t nodeID, uint16_t address);
            .def("setAddress", &RF24Mesh::setAddress, (bp::arg("nodeID"), bp::arg("address")))
            //void saveDHCP();
            .def("saveDHCP", &RF24Mesh::saveDHCP)
            //void loadDHCP();
            .def("loadDHCP", &RF24Mesh::loadDHCP)
            //void setStaticAddress(uint8_t nodeID, uint16_t address);
            .def("setStaticAddress", &RF24Mesh::setStaticAddress, (bp::arg("nodeID"), bp::arg("address")));
    }
}