mirror of https://github.com/arendst/Tasmota.git
144 lines
4.6 KiB
C++
144 lines
4.6 KiB
C++
#include "boost/python.hpp"
|
|
#include "RF24/RF24.h"
|
|
#include "RF24Network/RF24Network.h"
|
|
|
|
namespace bp = boost::python;
|
|
|
|
// **************** expicit 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;
|
|
}
|
|
|
|
bp::tuple read_wrap(RF24Network& ref, size_t maxlen)
|
|
{
|
|
char *buf = new char[maxlen+1];
|
|
RF24NetworkHeader header;
|
|
|
|
uint16_t len = ref.read(header, buf, maxlen);
|
|
bp::object py_ba(bp::handle<>(PyByteArray_FromStringAndSize(buf, len)));
|
|
delete[] buf;
|
|
|
|
return bp::make_tuple(header, py_ba);
|
|
}
|
|
|
|
bool write_wrap(RF24Network& ref, RF24NetworkHeader& header, bp::object buf)
|
|
{
|
|
return ref.write(header, get_bytes_or_bytearray_str(buf), get_bytes_or_bytearray_ln(buf));
|
|
}
|
|
|
|
std::string toString_wrap(RF24NetworkHeader& ref)
|
|
{
|
|
return std::string(ref.toString());
|
|
}
|
|
|
|
|
|
// **************** RF24Network exposed *****************
|
|
//
|
|
BOOST_PYTHON_MODULE(RF24Network){
|
|
{ //::RF24Network
|
|
typedef bp::class_< RF24Network > RF24Network_exposer_t;
|
|
RF24Network_exposer_t RF24Network_exposer = RF24Network_exposer_t( "RF24Network", bp::init< RF24 & >(( bp::arg("_radio") )) );
|
|
bp::scope RF24Network_scope( RF24Network_exposer );
|
|
bp::implicitly_convertible< RF24 &, RF24Network >();
|
|
{ //::RF24Network::available
|
|
|
|
typedef bool ( ::RF24Network::*available_function_type )( ) ;
|
|
|
|
RF24Network_exposer.def(
|
|
"available"
|
|
, available_function_type( &::RF24Network::available ) );
|
|
|
|
}
|
|
{ //::RF24Network::begin
|
|
|
|
typedef void ( ::RF24Network::*begin_function_type )( ::uint8_t,::uint16_t ) ;
|
|
|
|
RF24Network_exposer.def(
|
|
"begin"
|
|
, begin_function_type( &::RF24Network::begin )
|
|
, ( bp::arg("_channel"), bp::arg("_node_address") ) );
|
|
|
|
}
|
|
{ //::RF24Network::parent
|
|
|
|
typedef ::uint16_t ( ::RF24Network::*parent_function_type )( ) const;
|
|
|
|
RF24Network_exposer.def(
|
|
"parent"
|
|
, parent_function_type( &::RF24Network::parent ) );
|
|
|
|
}
|
|
{ //::RF24Network::read
|
|
|
|
typedef bp::tuple ( *read_function_type )(::RF24Network&, size_t ) ;
|
|
|
|
RF24Network_exposer.def(
|
|
"read"
|
|
//, read_function_type( &::RF24Network::read )
|
|
, read_function_type( &read_wrap )
|
|
, ( bp::arg("maxlen") ) );
|
|
|
|
}
|
|
{ //::RF24Network::update
|
|
|
|
typedef void ( ::RF24Network::*update_function_type )( ) ;
|
|
|
|
RF24Network_exposer.def(
|
|
"update"
|
|
, update_function_type( &::RF24Network::update ) );
|
|
|
|
}
|
|
{ //::RF24Network::write
|
|
|
|
typedef bool ( *write_function_type )( ::RF24Network&, ::RF24NetworkHeader&, bp::object ) ;
|
|
|
|
RF24Network_exposer.def("write", write_function_type( &write_wrap ), ( bp::arg("header"), bp::arg("buf") ) );
|
|
|
|
}
|
|
RF24Network_exposer.def_readwrite( "txTimeout", &RF24Network::txTimeout );
|
|
}
|
|
|
|
// **************** RF24NetworkHeader exposed *****************
|
|
//
|
|
bp::class_< RF24NetworkHeader >( "RF24NetworkHeader", bp::init< >() )
|
|
.def( bp::init< uint16_t, bp::optional< unsigned char > >(( bp::arg("_to"), bp::arg("_type")=(unsigned char)(0) )) )
|
|
.def("toString", &toString_wrap )
|
|
.def_readwrite( "from_node", &RF24NetworkHeader::from_node )
|
|
.def_readwrite( "id", &RF24NetworkHeader::id )
|
|
.def_readwrite( "next_id", RF24NetworkHeader::next_id )
|
|
.def_readwrite( "reserved", &RF24NetworkHeader::reserved )
|
|
.def_readwrite( "to_node", &RF24NetworkHeader::to_node )
|
|
.def_readwrite( "type", &RF24NetworkHeader::type );
|
|
}
|
|
|