| Message ID | 20191125143157.26154-12-warthog618@gmail.com |
|---|---|
| State | New |
| Headers | show |
| Series | Add support for bias flags and SET_CONFIG | expand |
pon., 25 lis 2019 o 15:33 Kent Gibson <warthog618@gmail.com> napisał(a): > > Add methods to support setting line configuration. > > Signed-off-by: Kent Gibson <warthog618@gmail.com> > --- > bindings/python/gpiodmodule.c | 381 +++++++++++++++++++++++++++++++++- > 1 file changed, 379 insertions(+), 2 deletions(-) > > diff --git a/bindings/python/gpiodmodule.c b/bindings/python/gpiodmodule.c > index 4723771..4f5e117 100644 > --- a/bindings/python/gpiodmodule.c > +++ b/bindings/python/gpiodmodule.c > @@ -585,14 +585,149 @@ static PyObject *gpiod_Line_set_value(gpiod_LineObject *self, PyObject *args) > if (!bulk_obj) > return NULL; > > - vals = Py_BuildValue("((O))", val); > + vals = Py_BuildValue("(O)", val); Please don't try to sneak in changes like this. If you think this should be changed, make it a separate commit with proper explanation. I vaguely remember using this because previously I didn't use PyObject_CallMethod() but called the set_values() function directly and it was easier to package it right away. Anyway - is it broken? Do we gain something from changing it? If so, let's have a separate patch for this. > if (!vals) { > Py_DECREF(bulk_obj); > return NULL; > } > > ret = PyObject_CallMethod((PyObject *)bulk_obj, > - "set_values", "O", vals); > + "set_values", "(O)", vals); > + Py_DECREF(bulk_obj); > + Py_DECREF(vals); > + > + return ret; > +} > + > +PyDoc_STRVAR(gpiod_Line_set_config_doc, > +"set_config(direction,flags,value) -> None\n" > +"\n" > +"Set the configuration of this GPIO line.\n" > +"\n" > +" direction\n" > +" New direction (integer)\n" > +" flags\n" > +" New flags (integer)\n" > +" value\n" > +" New value (integer)"); > + > +static PyObject *gpiod_Line_set_config(gpiod_LineObject *self, PyObject *args) > +{ > + gpiod_LineBulkObject *bulk_obj; > + PyObject *dirn, *flags, *val, *vals, *ret; > + int rv; > + > + val = NULL; > + rv = PyArg_ParseTuple(args, "OO|O", &dirn, &flags, &val); > + if (!rv) > + return NULL; > + > + bulk_obj = gpiod_LineToLineBulk(self); > + if (!bulk_obj) > + return NULL; > + > + if (val) { > + vals = Py_BuildValue("(O)", val); > + if (!vals) { > + Py_DECREF(bulk_obj); > + return NULL; > + } > + ret = PyObject_CallMethod((PyObject *)bulk_obj, > + "set_config", "OO(O)", dirn, flags, vals); > + Py_DECREF(vals); > + } else > + ret = PyObject_CallMethod((PyObject *)bulk_obj, > + "set_config", "OO", dirn, flags); Please use brackets here even if it's a single line after you used it in the first branch. Same elsewhere if needed. > + > + Py_DECREF(bulk_obj); > + > + return ret; > +} > + > +PyDoc_STRVAR(gpiod_Line_set_flags_doc, > +"set_flags(flags) -> None\n" > +"\n" > +"Set the flags of this GPIO line.\n" > +"\n" > +" flags\n" > +" New flags (integer)"); > + > +static PyObject *gpiod_Line_set_flags(gpiod_LineObject *self, PyObject *args) > +{ > + gpiod_LineBulkObject *bulk_obj; > + PyObject *ret; > + > + bulk_obj = gpiod_LineToLineBulk(self); > + if (!bulk_obj) > + return NULL; > + > + ret = PyObject_CallMethod((PyObject *)bulk_obj, > + "set_flags", "O", args); > + Py_DECREF(bulk_obj); > + > + return ret; > +} > + > +PyDoc_STRVAR(gpiod_Line_set_direction_input_doc, > +"set_direction_input() -> None\n" > +"\n" > +"Set the direction of this GPIO line to input.\n"); > + > +static PyObject *gpiod_Line_set_direction_input(gpiod_LineObject *self, > + PyObject *Py_UNUSED(ignored)) > +{ > + gpiod_LineBulkObject *bulk_obj; > + PyObject *ret; > + > + bulk_obj = gpiod_LineToLineBulk(self); > + if (!bulk_obj) > + return NULL; > + > + ret = PyObject_CallMethod((PyObject *)bulk_obj, > + "set_direction_input", ""); > + Py_DECREF(bulk_obj); > + > + return ret; > +} > + > +PyDoc_STRVAR(gpiod_Line_set_direction_output_doc, > +"set_direction_output(value) -> None\n" > +"\n" > +"Set the direction of this GPIO line to output.\n" > +"\n" > +" value\n" > +" New value (integer)"); > + > +static PyObject *gpiod_Line_set_direction_output(gpiod_LineObject *self, > + PyObject *args) > +{ > + gpiod_LineBulkObject *bulk_obj; > + PyObject *val, *vals, *ret; > + int rv; > + const char *fmt; > + > + val = NULL; > + rv = PyArg_ParseTuple(args, "|O", &val); > + if (!rv) > + return NULL; > + > + if (val) { > + fmt = "(O)"; > + vals = Py_BuildValue(fmt, val); > + } else { > + vals = Py_BuildValue("()"); > + fmt = "O"; /* pass empty args to bulk */ > + } > + if (!vals) > + return NULL; > + > + bulk_obj = gpiod_LineToLineBulk(self); > + if (!bulk_obj) > + return NULL; > + > + ret = PyObject_CallMethod((PyObject *)bulk_obj, > + "set_direction_output", fmt, vals); > + > Py_DECREF(bulk_obj); > Py_DECREF(vals); > > @@ -838,6 +973,30 @@ static PyMethodDef gpiod_Line_methods[] = { > .ml_flags = METH_VARARGS, > .ml_doc = gpiod_Line_set_value_doc, > }, > + { > + .ml_name = "set_config", > + .ml_meth = (PyCFunction)gpiod_Line_set_config, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_Line_set_config_doc, > + }, > + { > + .ml_name = "set_flags", > + .ml_meth = (PyCFunction)gpiod_Line_set_flags, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_Line_set_flags_doc, > + }, > + { > + .ml_name = "set_direction_input", > + .ml_meth = (PyCFunction)gpiod_Line_set_direction_input, > + .ml_flags = METH_NOARGS, > + .ml_doc = gpiod_Line_set_direction_input_doc, > + }, > + { > + .ml_name = "set_direction_output", > + .ml_meth = (PyCFunction)gpiod_Line_set_direction_output, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_Line_set_direction_output_doc, > + }, > { > .ml_name = "release", > .ml_meth = (PyCFunction)gpiod_Line_release, > @@ -1283,6 +1442,200 @@ static PyObject *gpiod_LineBulk_set_values(gpiod_LineBulkObject *self, > Py_RETURN_NONE; > } > > +static int convert_values(PyObject *src, int *dst, Py_ssize_t n) Coding convention and readability: this module is a bit different as I tried to stay consistent with Python C code when naming symbols. Please use the common 'gpiod_' prefix even for non-exported functions and maybe name this routine something else as "convert_values" doesn't really indicate concrete functionality. I'm still not sure what it does. > +{ > + int val; > + Py_ssize_t num_vals, i; > + PyObject *iter, *next; > + > + num_vals = PyObject_Size(src); > + if (num_vals != n) { > + PyErr_SetString(PyExc_TypeError, > + "Number of values must correspond to the number of lines"); > + return -1; > + } > + iter = PyObject_GetIter(src); > + if (!iter) > + return -1; > + for (i = 0;; i++) { > + next = PyIter_Next(iter); > + if (!next) { > + Py_DECREF(iter); > + break; > + } > + val = PyLong_AsLong(next); > + Py_DECREF(next); > + if (PyErr_Occurred()) { > + Py_DECREF(iter); > + return -1; > + } > + dst[i] = (int)val; > + } > + return 0; > +} > + > +PyDoc_STRVAR(gpiod_LineBulk_set_config_doc, > +"set_config(direction,flags,values) -> None\n" > +"\n" > +"Set the configuration of all the lines held by this LineBulk object.\n" > +"\n" > +" direction\n" > +" New direction (integer)\n" > +" flags\n" > +" New flags (integer)\n" > +" values\n" > +" List of values (integers) to set when direction is output.\n" > +"\n" > +"The number of values in the list passed as argument must be the same as\n" > +"the number of lines held by this gpiod.LineBulk object. The index of each\n" > +"value corresponds to the index of each line in the object.\n"); > + > +static PyObject *gpiod_LineBulk_set_config(gpiod_LineBulkObject *self, > + PyObject *args) > +{ > + int rv, vals[GPIOD_LINE_BULK_MAX_LINES]; > + PyObject *val_list; > + struct gpiod_line_bulk bulk; > + const int *valp; > + int dirn, flags; > + > + if (gpiod_LineBulkOwnerIsClosed(self)) > + return NULL; > + > + gpiod_LineBulkObjToCLineBulk(self, &bulk); > + > + val_list = NULL; > + rv = PyArg_ParseTuple(args, "ii|(O)", &dirn, &flags, &val_list); > + if (!rv) > + return NULL; > + > + if (val_list == NULL) > + valp = NULL; > + else { > + memset(vals, 0, sizeof(vals)); > + rv = convert_values(val_list, vals, self->num_lines); > + if (rv) > + return NULL; > + valp = vals; > + } > + > + Py_BEGIN_ALLOW_THREADS; > + rv = gpiod_line_set_config_bulk(&bulk, dirn, flags, valp); > + Py_END_ALLOW_THREADS; > + if (rv) > + return PyErr_SetFromErrno(PyExc_OSError); > + > + Py_RETURN_NONE; > +} > + > +PyDoc_STRVAR(gpiod_LineBulk_set_flags_doc, > +"set_flags(flags) -> None\n" > +"\n" > +"Set the flags of all the lines held by this LineBulk object.\n" > +"\n" > +" flags\n" > +" New flags (integer)"); > + > +static PyObject *gpiod_LineBulk_set_flags(gpiod_LineBulkObject *self, > + PyObject *args) > +{ > + int rv; > + struct gpiod_line_bulk bulk; > + int flags; > + > + if (gpiod_LineBulkOwnerIsClosed(self)) > + return NULL; > + > + gpiod_LineBulkObjToCLineBulk(self, &bulk); > + > + rv = PyArg_ParseTuple(args, "i", &flags); > + if (!rv) > + return NULL; > + > + Py_BEGIN_ALLOW_THREADS; > + rv = gpiod_line_set_flags_bulk(&bulk, flags); > + Py_END_ALLOW_THREADS; > + if (rv) > + return PyErr_SetFromErrno(PyExc_OSError); > + > + Py_RETURN_NONE; > +} > + > +PyDoc_STRVAR(gpiod_LineBulk_set_direction_input_doc, > +"set_direction_input() -> None\n" > +"\n" > +"Set the direction of all the lines held by this LineBulk object to input.\n"); > + > +static PyObject *gpiod_LineBulk_set_direction_input(gpiod_LineBulkObject *self, > + PyObject *Py_UNUSED(ignored)) > +{ > + struct gpiod_line_bulk bulk; > + int rv; > + > + if (gpiod_LineBulkOwnerIsClosed(self)) > + return NULL; > + > + gpiod_LineBulkObjToCLineBulk(self, &bulk); > + > + Py_BEGIN_ALLOW_THREADS; > + rv = gpiod_line_set_direction_input_bulk(&bulk); > + Py_END_ALLOW_THREADS; > + if (rv) > + return PyErr_SetFromErrno(PyExc_OSError); > + > + Py_RETURN_NONE; > +} > + > +PyDoc_STRVAR(gpiod_LineBulk_set_direction_output_doc, > +"set_direction_output(value) -> None\n" > +"\n" > +"Set the direction of all the lines held by this LineBulk object to output.\n" > +"\n" > +" values\n" > +" List of values (integers) to set when direction is output.\n" > +"\n" > +"The number of values in the list passed as argument must be the same as\n" > +"the number of lines held by this gpiod.LineBulk object. The index of each\n" > +"value corresponds to the index of each line in the object.\n"); > + > +static PyObject *gpiod_LineBulk_set_direction_output( > + gpiod_LineBulkObject *self, > + PyObject *args) > +{ > + int rv, vals[GPIOD_LINE_BULK_MAX_LINES]; > + PyObject *val_list; > + struct gpiod_line_bulk bulk; > + const int *valp; > + > + if (gpiod_LineBulkOwnerIsClosed(self)) > + return NULL; > + > + gpiod_LineBulkObjToCLineBulk(self, &bulk); > + > + val_list = NULL; > + rv = PyArg_ParseTuple(args, "|O", &val_list); > + if (!rv) > + return NULL; > + > + if (val_list == NULL) > + valp = NULL; > + else { > + memset(vals, 0, sizeof(vals)); > + rv = convert_values(val_list, vals, self->num_lines); > + if (rv) > + return NULL; > + valp = vals; > + } > + > + Py_BEGIN_ALLOW_THREADS; > + rv = gpiod_line_set_direction_output_bulk(&bulk, valp); > + Py_END_ALLOW_THREADS; > + if (rv) > + return PyErr_SetFromErrno(PyExc_OSError); > + > + Py_RETURN_NONE; > +} > + > PyDoc_STRVAR(gpiod_LineBulk_release_doc, > "release() -> None\n" > "\n" > @@ -1431,6 +1784,30 @@ static PyMethodDef gpiod_LineBulk_methods[] = { > .ml_doc = gpiod_LineBulk_set_values_doc, > .ml_flags = METH_VARARGS, > }, > + { > + .ml_name = "set_config", > + .ml_meth = (PyCFunction)gpiod_LineBulk_set_config, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_LineBulk_set_config_doc, > + }, > + { > + .ml_name = "set_flags", > + .ml_meth = (PyCFunction)gpiod_LineBulk_set_flags, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_LineBulk_set_flags_doc, > + }, > + { > + .ml_name = "set_direction_input", > + .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_input, > + .ml_flags = METH_NOARGS, > + .ml_doc = gpiod_LineBulk_set_direction_input_doc, > + }, > + { > + .ml_name = "set_direction_output", > + .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_output, > + .ml_flags = METH_VARARGS, > + .ml_doc = gpiod_LineBulk_set_direction_output_doc, > + }, > { > .ml_name = "release", > .ml_meth = (PyCFunction)gpiod_LineBulk_release, > -- > 2.24.0 >
diff --git a/bindings/python/gpiodmodule.c b/bindings/python/gpiodmodule.c index 4723771..4f5e117 100644 --- a/bindings/python/gpiodmodule.c +++ b/bindings/python/gpiodmodule.c @@ -585,14 +585,149 @@ static PyObject *gpiod_Line_set_value(gpiod_LineObject *self, PyObject *args) if (!bulk_obj) return NULL; - vals = Py_BuildValue("((O))", val); + vals = Py_BuildValue("(O)", val); if (!vals) { Py_DECREF(bulk_obj); return NULL; } ret = PyObject_CallMethod((PyObject *)bulk_obj, - "set_values", "O", vals); + "set_values", "(O)", vals); + Py_DECREF(bulk_obj); + Py_DECREF(vals); + + return ret; +} + +PyDoc_STRVAR(gpiod_Line_set_config_doc, +"set_config(direction,flags,value) -> None\n" +"\n" +"Set the configuration of this GPIO line.\n" +"\n" +" direction\n" +" New direction (integer)\n" +" flags\n" +" New flags (integer)\n" +" value\n" +" New value (integer)"); + +static PyObject *gpiod_Line_set_config(gpiod_LineObject *self, PyObject *args) +{ + gpiod_LineBulkObject *bulk_obj; + PyObject *dirn, *flags, *val, *vals, *ret; + int rv; + + val = NULL; + rv = PyArg_ParseTuple(args, "OO|O", &dirn, &flags, &val); + if (!rv) + return NULL; + + bulk_obj = gpiod_LineToLineBulk(self); + if (!bulk_obj) + return NULL; + + if (val) { + vals = Py_BuildValue("(O)", val); + if (!vals) { + Py_DECREF(bulk_obj); + return NULL; + } + ret = PyObject_CallMethod((PyObject *)bulk_obj, + "set_config", "OO(O)", dirn, flags, vals); + Py_DECREF(vals); + } else + ret = PyObject_CallMethod((PyObject *)bulk_obj, + "set_config", "OO", dirn, flags); + + Py_DECREF(bulk_obj); + + return ret; +} + +PyDoc_STRVAR(gpiod_Line_set_flags_doc, +"set_flags(flags) -> None\n" +"\n" +"Set the flags of this GPIO line.\n" +"\n" +" flags\n" +" New flags (integer)"); + +static PyObject *gpiod_Line_set_flags(gpiod_LineObject *self, PyObject *args) +{ + gpiod_LineBulkObject *bulk_obj; + PyObject *ret; + + bulk_obj = gpiod_LineToLineBulk(self); + if (!bulk_obj) + return NULL; + + ret = PyObject_CallMethod((PyObject *)bulk_obj, + "set_flags", "O", args); + Py_DECREF(bulk_obj); + + return ret; +} + +PyDoc_STRVAR(gpiod_Line_set_direction_input_doc, +"set_direction_input() -> None\n" +"\n" +"Set the direction of this GPIO line to input.\n"); + +static PyObject *gpiod_Line_set_direction_input(gpiod_LineObject *self, + PyObject *Py_UNUSED(ignored)) +{ + gpiod_LineBulkObject *bulk_obj; + PyObject *ret; + + bulk_obj = gpiod_LineToLineBulk(self); + if (!bulk_obj) + return NULL; + + ret = PyObject_CallMethod((PyObject *)bulk_obj, + "set_direction_input", ""); + Py_DECREF(bulk_obj); + + return ret; +} + +PyDoc_STRVAR(gpiod_Line_set_direction_output_doc, +"set_direction_output(value) -> None\n" +"\n" +"Set the direction of this GPIO line to output.\n" +"\n" +" value\n" +" New value (integer)"); + +static PyObject *gpiod_Line_set_direction_output(gpiod_LineObject *self, + PyObject *args) +{ + gpiod_LineBulkObject *bulk_obj; + PyObject *val, *vals, *ret; + int rv; + const char *fmt; + + val = NULL; + rv = PyArg_ParseTuple(args, "|O", &val); + if (!rv) + return NULL; + + if (val) { + fmt = "(O)"; + vals = Py_BuildValue(fmt, val); + } else { + vals = Py_BuildValue("()"); + fmt = "O"; /* pass empty args to bulk */ + } + if (!vals) + return NULL; + + bulk_obj = gpiod_LineToLineBulk(self); + if (!bulk_obj) + return NULL; + + ret = PyObject_CallMethod((PyObject *)bulk_obj, + "set_direction_output", fmt, vals); + Py_DECREF(bulk_obj); Py_DECREF(vals); @@ -838,6 +973,30 @@ static PyMethodDef gpiod_Line_methods[] = { .ml_flags = METH_VARARGS, .ml_doc = gpiod_Line_set_value_doc, }, + { + .ml_name = "set_config", + .ml_meth = (PyCFunction)gpiod_Line_set_config, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_Line_set_config_doc, + }, + { + .ml_name = "set_flags", + .ml_meth = (PyCFunction)gpiod_Line_set_flags, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_Line_set_flags_doc, + }, + { + .ml_name = "set_direction_input", + .ml_meth = (PyCFunction)gpiod_Line_set_direction_input, + .ml_flags = METH_NOARGS, + .ml_doc = gpiod_Line_set_direction_input_doc, + }, + { + .ml_name = "set_direction_output", + .ml_meth = (PyCFunction)gpiod_Line_set_direction_output, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_Line_set_direction_output_doc, + }, { .ml_name = "release", .ml_meth = (PyCFunction)gpiod_Line_release, @@ -1283,6 +1442,200 @@ static PyObject *gpiod_LineBulk_set_values(gpiod_LineBulkObject *self, Py_RETURN_NONE; } +static int convert_values(PyObject *src, int *dst, Py_ssize_t n) +{ + int val; + Py_ssize_t num_vals, i; + PyObject *iter, *next; + + num_vals = PyObject_Size(src); + if (num_vals != n) { + PyErr_SetString(PyExc_TypeError, + "Number of values must correspond to the number of lines"); + return -1; + } + iter = PyObject_GetIter(src); + if (!iter) + return -1; + for (i = 0;; i++) { + next = PyIter_Next(iter); + if (!next) { + Py_DECREF(iter); + break; + } + val = PyLong_AsLong(next); + Py_DECREF(next); + if (PyErr_Occurred()) { + Py_DECREF(iter); + return -1; + } + dst[i] = (int)val; + } + return 0; +} + +PyDoc_STRVAR(gpiod_LineBulk_set_config_doc, +"set_config(direction,flags,values) -> None\n" +"\n" +"Set the configuration of all the lines held by this LineBulk object.\n" +"\n" +" direction\n" +" New direction (integer)\n" +" flags\n" +" New flags (integer)\n" +" values\n" +" List of values (integers) to set when direction is output.\n" +"\n" +"The number of values in the list passed as argument must be the same as\n" +"the number of lines held by this gpiod.LineBulk object. The index of each\n" +"value corresponds to the index of each line in the object.\n"); + +static PyObject *gpiod_LineBulk_set_config(gpiod_LineBulkObject *self, + PyObject *args) +{ + int rv, vals[GPIOD_LINE_BULK_MAX_LINES]; + PyObject *val_list; + struct gpiod_line_bulk bulk; + const int *valp; + int dirn, flags; + + if (gpiod_LineBulkOwnerIsClosed(self)) + return NULL; + + gpiod_LineBulkObjToCLineBulk(self, &bulk); + + val_list = NULL; + rv = PyArg_ParseTuple(args, "ii|(O)", &dirn, &flags, &val_list); + if (!rv) + return NULL; + + if (val_list == NULL) + valp = NULL; + else { + memset(vals, 0, sizeof(vals)); + rv = convert_values(val_list, vals, self->num_lines); + if (rv) + return NULL; + valp = vals; + } + + Py_BEGIN_ALLOW_THREADS; + rv = gpiod_line_set_config_bulk(&bulk, dirn, flags, valp); + Py_END_ALLOW_THREADS; + if (rv) + return PyErr_SetFromErrno(PyExc_OSError); + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(gpiod_LineBulk_set_flags_doc, +"set_flags(flags) -> None\n" +"\n" +"Set the flags of all the lines held by this LineBulk object.\n" +"\n" +" flags\n" +" New flags (integer)"); + +static PyObject *gpiod_LineBulk_set_flags(gpiod_LineBulkObject *self, + PyObject *args) +{ + int rv; + struct gpiod_line_bulk bulk; + int flags; + + if (gpiod_LineBulkOwnerIsClosed(self)) + return NULL; + + gpiod_LineBulkObjToCLineBulk(self, &bulk); + + rv = PyArg_ParseTuple(args, "i", &flags); + if (!rv) + return NULL; + + Py_BEGIN_ALLOW_THREADS; + rv = gpiod_line_set_flags_bulk(&bulk, flags); + Py_END_ALLOW_THREADS; + if (rv) + return PyErr_SetFromErrno(PyExc_OSError); + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(gpiod_LineBulk_set_direction_input_doc, +"set_direction_input() -> None\n" +"\n" +"Set the direction of all the lines held by this LineBulk object to input.\n"); + +static PyObject *gpiod_LineBulk_set_direction_input(gpiod_LineBulkObject *self, + PyObject *Py_UNUSED(ignored)) +{ + struct gpiod_line_bulk bulk; + int rv; + + if (gpiod_LineBulkOwnerIsClosed(self)) + return NULL; + + gpiod_LineBulkObjToCLineBulk(self, &bulk); + + Py_BEGIN_ALLOW_THREADS; + rv = gpiod_line_set_direction_input_bulk(&bulk); + Py_END_ALLOW_THREADS; + if (rv) + return PyErr_SetFromErrno(PyExc_OSError); + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(gpiod_LineBulk_set_direction_output_doc, +"set_direction_output(value) -> None\n" +"\n" +"Set the direction of all the lines held by this LineBulk object to output.\n" +"\n" +" values\n" +" List of values (integers) to set when direction is output.\n" +"\n" +"The number of values in the list passed as argument must be the same as\n" +"the number of lines held by this gpiod.LineBulk object. The index of each\n" +"value corresponds to the index of each line in the object.\n"); + +static PyObject *gpiod_LineBulk_set_direction_output( + gpiod_LineBulkObject *self, + PyObject *args) +{ + int rv, vals[GPIOD_LINE_BULK_MAX_LINES]; + PyObject *val_list; + struct gpiod_line_bulk bulk; + const int *valp; + + if (gpiod_LineBulkOwnerIsClosed(self)) + return NULL; + + gpiod_LineBulkObjToCLineBulk(self, &bulk); + + val_list = NULL; + rv = PyArg_ParseTuple(args, "|O", &val_list); + if (!rv) + return NULL; + + if (val_list == NULL) + valp = NULL; + else { + memset(vals, 0, sizeof(vals)); + rv = convert_values(val_list, vals, self->num_lines); + if (rv) + return NULL; + valp = vals; + } + + Py_BEGIN_ALLOW_THREADS; + rv = gpiod_line_set_direction_output_bulk(&bulk, valp); + Py_END_ALLOW_THREADS; + if (rv) + return PyErr_SetFromErrno(PyExc_OSError); + + Py_RETURN_NONE; +} + PyDoc_STRVAR(gpiod_LineBulk_release_doc, "release() -> None\n" "\n" @@ -1431,6 +1784,30 @@ static PyMethodDef gpiod_LineBulk_methods[] = { .ml_doc = gpiod_LineBulk_set_values_doc, .ml_flags = METH_VARARGS, }, + { + .ml_name = "set_config", + .ml_meth = (PyCFunction)gpiod_LineBulk_set_config, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_LineBulk_set_config_doc, + }, + { + .ml_name = "set_flags", + .ml_meth = (PyCFunction)gpiod_LineBulk_set_flags, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_LineBulk_set_flags_doc, + }, + { + .ml_name = "set_direction_input", + .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_input, + .ml_flags = METH_NOARGS, + .ml_doc = gpiod_LineBulk_set_direction_input_doc, + }, + { + .ml_name = "set_direction_output", + .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_output, + .ml_flags = METH_VARARGS, + .ml_doc = gpiod_LineBulk_set_direction_output_doc, + }, { .ml_name = "release", .ml_meth = (PyCFunction)gpiod_LineBulk_release,
Add methods to support setting line configuration. Signed-off-by: Kent Gibson <warthog618@gmail.com> --- bindings/python/gpiodmodule.c | 381 +++++++++++++++++++++++++++++++++- 1 file changed, 379 insertions(+), 2 deletions(-)