Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2026-02-04 14:40:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
pocketpy/3rd/periphery/src/periphery.c
blueloveTH 9d2cb89b24 fix struct gen
2025-12-17 11:27:02 +08:00

1109 lines
38 KiB
C
Raw Blame History

#include "pocketpy.h"
#include <string.h>
#include <stdint.h>
#include "periphery.h"
#define ADD_ENUM(name) py_newint(py_emplacedict(mod, py_name(#name)), name)
static bool gpio_config__new__(int argc, py_Ref argv) {
py_Type cls = py_totype(argv);
py_newobject(py_retval(), cls, 0, sizeof(gpio_config_t));
return true;
}
static bool gpio_config__init__(int argc, py_Ref argv) {
gpio_config_t* self = py_touserdata(argv);
if(argc == 1) {
memset(self, 0, sizeof(gpio_config_t));
} else if(argc == 1 + 8) {
if(!py_checkint(py_arg(1))) return false;
self->direction = (gpio_direction_t)py_toint(py_arg(1));
if(!py_checkint(py_arg(2))) return false;
self->edge = (gpio_edge_t)py_toint(py_arg(2));
if(!py_checkint(py_arg(3))) return false;
self->event_clock = (gpio_event_clock_t)py_toint(py_arg(3));
if(!py_checkint(py_arg(4))) return false;
self->debounce_us = py_toint(py_arg(4));
if(!py_checkint(py_arg(5))) return false;
self->bias = (gpio_bias_t)py_toint(py_arg(5));
if(!py_checkint(py_arg(6))) return false;
self->drive = (gpio_drive_t)py_toint(py_arg(6));
if(!py_checkbool(py_arg(7))) return false;
self->inverted = py_tobool(py_arg(7));
// _7 label is read-only
} else {
return TypeError("expected 1 or 9 arguments");
}
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_direction(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), (py_i64)self->direction);
return true;
}
static bool gpio_config__set_direction(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->direction = (gpio_direction_t)py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_edge(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), (py_i64)self->edge);
return true;
}
static bool gpio_config__set_edge(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->edge = (gpio_edge_t)py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_event_clock(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), (py_i64)self->event_clock);
return true;
}
static bool gpio_config__set_event_clock(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->event_clock = (gpio_event_clock_t)py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_debounce_us(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), self->debounce_us);
return true;
}
static bool gpio_config__set_debounce_us(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->debounce_us = py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_bias(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), (py_i64)self->bias);
return true;
}
static bool gpio_config__set_bias(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->bias = (gpio_bias_t)py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_drive(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newint(py_retval(), (py_i64)self->drive);
return true;
}
static bool gpio_config__set_drive(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->drive = (gpio_drive_t)py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_inverted(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newbool(py_retval(), self->inverted);
return true;
}
static bool gpio_config__set_inverted(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_config_t* self = py_touserdata(argv);
if(!py_checkbool(py_arg(1))) return false;
self->inverted = py_tobool(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool gpio_config__get_label(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_config_t* self = py_touserdata(argv);
py_newstr(py_retval(), self->label);
return true;
}
static py_Type register__gpio_config(py_GlobalRef mod) {
py_Type type = py_newtype("gpio_config", tp_stdc_Memory, mod, NULL);
py_newint(py_emplacedict(py_tpobject(type), py_name("size")), sizeof(gpio_config_t));
py_bindmethod(type, "__new__", gpio_config__new__);
py_bindmethod(type, "__init__", gpio_config__init__);
py_bindproperty(type, "direction", gpio_config__get_direction, gpio_config__set_direction);
py_bindproperty(type, "edge", gpio_config__get_edge, gpio_config__set_edge);
py_bindproperty(type, "event_clock", gpio_config__get_event_clock, gpio_config__set_event_clock);
py_bindproperty(type, "debounce_us", gpio_config__get_debounce_us, gpio_config__set_debounce_us);
py_bindproperty(type, "bias", gpio_config__get_bias, gpio_config__set_bias);
py_bindproperty(type, "drive", gpio_config__get_drive, gpio_config__set_drive);
py_bindproperty(type, "inverted", gpio_config__get_inverted, gpio_config__set_inverted);
py_bindproperty(type, "label", gpio_config__get_label, NULL);
return type;
}
static py_Type tp_user_gpio_config;
static bool periphery_version__new__(int argc, py_Ref argv) {
py_Type cls = py_totype(argv);
py_newobject(py_retval(), cls, 0, sizeof(periphery_version_t));
return true;
}
static bool periphery_version__init__(int argc, py_Ref argv) {
periphery_version_t* self = py_touserdata(argv);
if(argc == 1) {
memset(self, 0, sizeof(periphery_version_t));
} else if(argc == 1 + 4) {
if(!py_checkint(py_arg(1))) return false;
self->major = py_toint(py_arg(1));
if(!py_checkint(py_arg(2))) return false;
self->minor = py_toint(py_arg(2));
if(!py_checkint(py_arg(3))) return false;
self->patch = py_toint(py_arg(3));
// _3 commit_id is read-only
} else {
return TypeError("expected 1 or 5 arguments");
}
py_newnone(py_retval());
return true;
}
static bool periphery_version__get_major(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
periphery_version_t* self = py_touserdata(argv);
py_newint(py_retval(), self->major);
return true;
}
static bool periphery_version__set_major(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
periphery_version_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->major = py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool periphery_version__get_minor(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
periphery_version_t* self = py_touserdata(argv);
py_newint(py_retval(), self->minor);
return true;
}
static bool periphery_version__set_minor(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
periphery_version_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->minor = py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool periphery_version__get_patch(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
periphery_version_t* self = py_touserdata(argv);
py_newint(py_retval(), self->patch);
return true;
}
static bool periphery_version__set_patch(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
periphery_version_t* self = py_touserdata(argv);
if(!py_checkint(py_arg(1))) return false;
self->patch = py_toint(py_arg(1));
py_newnone(py_retval());
return true;
}
static bool periphery_version__get_commit_id(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
periphery_version_t* self = py_touserdata(argv);
py_newstr(py_retval(), self->commit_id);
return true;
}
static py_Type register__periphery_version(py_GlobalRef mod) {
py_Type type = py_newtype("periphery_version", tp_stdc_Memory, mod, NULL);
py_newint(py_emplacedict(py_tpobject(type), py_name("size")), sizeof(periphery_version_t));
py_bindmethod(type, "__new__", periphery_version__new__);
py_bindmethod(type, "__init__", periphery_version__init__);
py_bindproperty(type, "major", periphery_version__get_major, periphery_version__set_major);
py_bindproperty(type, "minor", periphery_version__get_minor, periphery_version__set_minor);
py_bindproperty(type, "patch", periphery_version__get_patch, periphery_version__set_patch);
py_bindproperty(type, "commit_id", periphery_version__get_commit_id, NULL);
return type;
}
static py_Type tp_user_periphery_version;
/* functions */
static bool cfunc__gpio_new(int argc, py_Ref argv) {
PY_CHECK_ARGC(0);
gpio_t* res = gpio_new();
py_newint(py_retval(), (py_i64)res);
return true;
}
static bool cfunc__gpio_open(int argc, py_Ref argv) {
PY_CHECK_ARGC(4);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
const char* _1;
if(!py_checkstr(py_arg(1))) return false;
_1 = py_tostr(py_arg(1));
unsigned _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
gpio_direction_t _3;
if(!py_checkint(py_arg(3))) return false;
_3 = (gpio_direction_t)py_toint(py_arg(3));
int res = gpio_open(_0, _1, _2, _3);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_open_name(int argc, py_Ref argv) {
PY_CHECK_ARGC(4);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
const char* _1;
if(!py_checkstr(py_arg(1))) return false;
_1 = py_tostr(py_arg(1));
const char* _2;
if(!py_checkstr(py_arg(2))) return false;
_2 = py_tostr(py_arg(2));
gpio_direction_t _3;
if(!py_checkint(py_arg(3))) return false;
_3 = (gpio_direction_t)py_toint(py_arg(3));
int res = gpio_open_name(_0, _1, _2, _3);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_open_advanced(int argc, py_Ref argv) {
PY_CHECK_ARGC(4);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
const char* _1;
if(!py_checkstr(py_arg(1))) return false;
_1 = py_tostr(py_arg(1));
unsigned _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
const gpio_config_t* _3;
if(!py_checkint(py_arg(3))) return false;
_3 = (const gpio_config_t*)py_toint(py_arg(3));
int res = gpio_open_advanced(_0, _1, _2, _3);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_open_name_advanced(int argc, py_Ref argv) {
PY_CHECK_ARGC(4);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
const char* _1;
if(!py_checkstr(py_arg(1))) return false;
_1 = py_tostr(py_arg(1));
const char* _2;
if(!py_checkstr(py_arg(2))) return false;
_2 = py_tostr(py_arg(2));
const gpio_config_t* _3;
if(!py_checkint(py_arg(3))) return false;
_3 = (const gpio_config_t*)py_toint(py_arg(3));
int res = gpio_open_name_advanced(_0, _1, _2, _3);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_open_sysfs(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
unsigned _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
gpio_direction_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = (gpio_direction_t)py_toint(py_arg(2));
int res = gpio_open_sysfs(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_read(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
bool* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (bool*)py_toint(py_arg(1));
int res = gpio_read(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_write(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
bool _1;
if(!py_checkbool(py_arg(1))) return false;
_1 = py_tobool(py_arg(1));
int res = gpio_write(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_poll(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
int _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
int res = gpio_poll(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_close(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
int res = gpio_close(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_free(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_free(_0);
py_newnone(py_retval());
return true;
}
static bool cfunc__gpio_read_event(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_edge_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_edge_t*)py_toint(py_arg(1));
uint64_t* _2;
if(!py_checkint(py_arg(2))) return false;
_2 = (uint64_t*)py_toint(py_arg(2));
int res = gpio_read_event(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_poll_multiple(int argc, py_Ref argv) {
PY_CHECK_ARGC(4);
gpio_t** _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t**)py_toint(py_arg(0));
size_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
int _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
bool* _3;
if(!py_checkint(py_arg(3))) return false;
_3 = (bool*)py_toint(py_arg(3));
int res = gpio_poll_multiple(_0, _1, _2, _3);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_direction(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_direction_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_direction_t*)py_toint(py_arg(1));
int res = gpio_get_direction(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_edge(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_edge_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_edge_t*)py_toint(py_arg(1));
int res = gpio_get_edge(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_event_clock(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_event_clock_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_event_clock_t*)py_toint(py_arg(1));
int res = gpio_get_event_clock(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_debounce_us(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
uint32_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (uint32_t*)py_toint(py_arg(1));
int res = gpio_get_debounce_us(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_bias(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_bias_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_bias_t*)py_toint(py_arg(1));
int res = gpio_get_bias(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_drive(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_drive_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_drive_t*)py_toint(py_arg(1));
int res = gpio_get_drive(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_get_inverted(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
bool* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (bool*)py_toint(py_arg(1));
int res = gpio_get_inverted(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_direction(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_direction_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_direction_t)py_toint(py_arg(1));
int res = gpio_set_direction(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_edge(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_edge_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_edge_t)py_toint(py_arg(1));
int res = gpio_set_edge(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_event_clock(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_event_clock_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_event_clock_t)py_toint(py_arg(1));
int res = gpio_set_event_clock(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_debounce_us(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
uint32_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
int res = gpio_set_debounce_us(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_bias(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_bias_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_bias_t)py_toint(py_arg(1));
int res = gpio_set_bias(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_drive(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
gpio_drive_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (gpio_drive_t)py_toint(py_arg(1));
int res = gpio_set_drive(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_set_inverted(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
bool _1;
if(!py_checkbool(py_arg(1))) return false;
_1 = py_tobool(py_arg(1));
int res = gpio_set_inverted(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_line(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
unsigned res = gpio_line(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_fd(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
int res = gpio_fd(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_name(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = gpio_name(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_label(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = gpio_label(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_chip_fd(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
int res = gpio_chip_fd(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_chip_name(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = gpio_chip_name(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_chip_label(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = gpio_chip_label(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_tostring(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = gpio_tostring(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_errno(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
int res = gpio_errno(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__gpio_errmsg(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
gpio_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (gpio_t*)py_toint(py_arg(0));
const char* res = gpio_errmsg(_0);
py_newstr(py_retval(), res);
return true;
}
static bool cfunc__pwm_new(int argc, py_Ref argv) {
PY_CHECK_ARGC(0);
pwm_t* res = pwm_new();
py_newint(py_retval(), (py_i64)res);
return true;
}
static bool cfunc__pwm_open(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
unsigned _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
unsigned _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = pwm_open(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_enable(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
int res = pwm_enable(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_disable(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
int res = pwm_disable(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_close(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
int res = pwm_close(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_free(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
pwm_free(_0);
py_newnone(py_retval());
return true;
}
static bool cfunc__pwm_get_enabled(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
bool* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (bool*)py_toint(py_arg(1));
int res = pwm_get_enabled(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_period_ns(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
uint64_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (uint64_t*)py_toint(py_arg(1));
int res = pwm_get_period_ns(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_duty_cycle_ns(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
uint64_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (uint64_t*)py_toint(py_arg(1));
int res = pwm_get_duty_cycle_ns(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_period(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (double*)py_toint(py_arg(1));
int res = pwm_get_period(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_duty_cycle(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (double*)py_toint(py_arg(1));
int res = pwm_get_duty_cycle(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_frequency(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (double*)py_toint(py_arg(1));
int res = pwm_get_frequency(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_get_polarity(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
pwm_polarity_t* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (pwm_polarity_t*)py_toint(py_arg(1));
int res = pwm_get_polarity(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_enabled(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
bool _1;
if(!py_checkbool(py_arg(1))) return false;
_1 = py_tobool(py_arg(1));
int res = pwm_set_enabled(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_period_ns(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
uint64_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
int res = pwm_set_period_ns(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_duty_cycle_ns(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
uint64_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = py_toint(py_arg(1));
int res = pwm_set_duty_cycle_ns(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_period(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double _1;
if(!py_castfloat(py_arg(1), &_1)) return false;
int res = pwm_set_period(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_duty_cycle(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double _1;
if(!py_castfloat(py_arg(1), &_1)) return false;
int res = pwm_set_duty_cycle(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_frequency(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
double _1;
if(!py_castfloat(py_arg(1), &_1)) return false;
int res = pwm_set_frequency(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_set_polarity(int argc, py_Ref argv) {
PY_CHECK_ARGC(2);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
pwm_polarity_t _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (pwm_polarity_t)py_toint(py_arg(1));
int res = pwm_set_polarity(_0, _1);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_chip(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
unsigned res = pwm_chip(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_channel(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
unsigned res = pwm_channel(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_tostring(int argc, py_Ref argv) {
PY_CHECK_ARGC(3);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
char* _1;
if(!py_checkint(py_arg(1))) return false;
_1 = (char*)py_toint(py_arg(1));
size_t _2;
if(!py_checkint(py_arg(2))) return false;
_2 = py_toint(py_arg(2));
int res = pwm_tostring(_0, _1, _2);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_errno(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
int res = pwm_errno(_0);
py_newint(py_retval(), res);
return true;
}
static bool cfunc__pwm_errmsg(int argc, py_Ref argv) {
PY_CHECK_ARGC(1);
pwm_t* _0;
if(!py_checkint(py_arg(0))) return false;
_0 = (pwm_t*)py_toint(py_arg(0));
const char* res = pwm_errmsg(_0);
py_newstr(py_retval(), res);
return true;
}
static bool cfunc__periphery_version(int argc, py_Ref argv) {
PY_CHECK_ARGC(0);
const char* res = periphery_version();
py_newstr(py_retval(), res);
return true;
}
static bool cfunc__periphery_version_info(int argc, py_Ref argv) {
PY_CHECK_ARGC(0);
const periphery_version_t* res = periphery_version_info();
py_newint(py_retval(), (py_i64)res);
return true;
}
void py__add_module_periphery() {
py_GlobalRef mod = py_newmodule("periphery");
/* structs */
tp_user_gpio_config = register__gpio_config(mod);
tp_user_periphery_version = register__periphery_version(mod);
/* aliases */
py_setdict(mod, py_name("gpio_direction_t"), py_tpobject(tp_int));
py_setdict(mod, py_name("gpio_edge_t"), py_tpobject(tp_int));
py_setdict(mod, py_name("gpio_event_clock_t"), py_tpobject(tp_int));
py_setdict(mod, py_name("gpio_bias_t"), py_tpobject(tp_int));
py_setdict(mod, py_name("gpio_drive_t"), py_tpobject(tp_int));
py_setdict(mod, py_name("pwm_polarity_t"), py_tpobject(tp_int));
/* functions */
py_bindfunc(mod, "gpio_new", &cfunc__gpio_new);
py_bindfunc(mod, "gpio_open", &cfunc__gpio_open);
py_bindfunc(mod, "gpio_open_name", &cfunc__gpio_open_name);
py_bindfunc(mod, "gpio_open_advanced", &cfunc__gpio_open_advanced);
py_bindfunc(mod, "gpio_open_name_advanced", &cfunc__gpio_open_name_advanced);
py_bindfunc(mod, "gpio_open_sysfs", &cfunc__gpio_open_sysfs);
py_bindfunc(mod, "gpio_read", &cfunc__gpio_read);
py_bindfunc(mod, "gpio_write", &cfunc__gpio_write);
py_bindfunc(mod, "gpio_poll", &cfunc__gpio_poll);
py_bindfunc(mod, "gpio_close", &cfunc__gpio_close);
py_bindfunc(mod, "gpio_free", &cfunc__gpio_free);
py_bindfunc(mod, "gpio_read_event", &cfunc__gpio_read_event);
py_bindfunc(mod, "gpio_poll_multiple", &cfunc__gpio_poll_multiple);
py_bindfunc(mod, "gpio_get_direction", &cfunc__gpio_get_direction);
py_bindfunc(mod, "gpio_get_edge", &cfunc__gpio_get_edge);
py_bindfunc(mod, "gpio_get_event_clock", &cfunc__gpio_get_event_clock);
py_bindfunc(mod, "gpio_get_debounce_us", &cfunc__gpio_get_debounce_us);
py_bindfunc(mod, "gpio_get_bias", &cfunc__gpio_get_bias);
py_bindfunc(mod, "gpio_get_drive", &cfunc__gpio_get_drive);
py_bindfunc(mod, "gpio_get_inverted", &cfunc__gpio_get_inverted);
py_bindfunc(mod, "gpio_set_direction", &cfunc__gpio_set_direction);
py_bindfunc(mod, "gpio_set_edge", &cfunc__gpio_set_edge);
py_bindfunc(mod, "gpio_set_event_clock", &cfunc__gpio_set_event_clock);
py_bindfunc(mod, "gpio_set_debounce_us", &cfunc__gpio_set_debounce_us);
py_bindfunc(mod, "gpio_set_bias", &cfunc__gpio_set_bias);
py_bindfunc(mod, "gpio_set_drive", &cfunc__gpio_set_drive);
py_bindfunc(mod, "gpio_set_inverted", &cfunc__gpio_set_inverted);
py_bindfunc(mod, "gpio_line", &cfunc__gpio_line);
py_bindfunc(mod, "gpio_fd", &cfunc__gpio_fd);
py_bindfunc(mod, "gpio_name", &cfunc__gpio_name);
py_bindfunc(mod, "gpio_label", &cfunc__gpio_label);
py_bindfunc(mod, "gpio_chip_fd", &cfunc__gpio_chip_fd);
py_bindfunc(mod, "gpio_chip_name", &cfunc__gpio_chip_name);
py_bindfunc(mod, "gpio_chip_label", &cfunc__gpio_chip_label);
py_bindfunc(mod, "gpio_tostring", &cfunc__gpio_tostring);
py_bindfunc(mod, "gpio_errno", &cfunc__gpio_errno);
py_bindfunc(mod, "gpio_errmsg", &cfunc__gpio_errmsg);
py_bindfunc(mod, "pwm_new", &cfunc__pwm_new);
py_bindfunc(mod, "pwm_open", &cfunc__pwm_open);
py_bindfunc(mod, "pwm_enable", &cfunc__pwm_enable);
py_bindfunc(mod, "pwm_disable", &cfunc__pwm_disable);
py_bindfunc(mod, "pwm_close", &cfunc__pwm_close);
py_bindfunc(mod, "pwm_free", &cfunc__pwm_free);
py_bindfunc(mod, "pwm_get_enabled", &cfunc__pwm_get_enabled);
py_bindfunc(mod, "pwm_get_period_ns", &cfunc__pwm_get_period_ns);
py_bindfunc(mod, "pwm_get_duty_cycle_ns", &cfunc__pwm_get_duty_cycle_ns);
py_bindfunc(mod, "pwm_get_period", &cfunc__pwm_get_period);
py_bindfunc(mod, "pwm_get_duty_cycle", &cfunc__pwm_get_duty_cycle);
py_bindfunc(mod, "pwm_get_frequency", &cfunc__pwm_get_frequency);
py_bindfunc(mod, "pwm_get_polarity", &cfunc__pwm_get_polarity);
py_bindfunc(mod, "pwm_set_enabled", &cfunc__pwm_set_enabled);
py_bindfunc(mod, "pwm_set_period_ns", &cfunc__pwm_set_period_ns);
py_bindfunc(mod, "pwm_set_duty_cycle_ns", &cfunc__pwm_set_duty_cycle_ns);
py_bindfunc(mod, "pwm_set_period", &cfunc__pwm_set_period);
py_bindfunc(mod, "pwm_set_duty_cycle", &cfunc__pwm_set_duty_cycle);
py_bindfunc(mod, "pwm_set_frequency", &cfunc__pwm_set_frequency);
py_bindfunc(mod, "pwm_set_polarity", &cfunc__pwm_set_polarity);
py_bindfunc(mod, "pwm_chip", &cfunc__pwm_chip);
py_bindfunc(mod, "pwm_channel", &cfunc__pwm_channel);
py_bindfunc(mod, "pwm_tostring", &cfunc__pwm_tostring);
py_bindfunc(mod, "pwm_errno", &cfunc__pwm_errno);
py_bindfunc(mod, "pwm_errmsg", &cfunc__pwm_errmsg);
py_bindfunc(mod, "periphery_version", &cfunc__periphery_version);
py_bindfunc(mod, "periphery_version_info", &cfunc__periphery_version_info);
/* enums */
ADD_ENUM(GPIO_ERROR_ARG);
ADD_ENUM(GPIO_ERROR_OPEN);
ADD_ENUM(GPIO_ERROR_NOT_FOUND);
ADD_ENUM(GPIO_ERROR_QUERY);
ADD_ENUM(GPIO_ERROR_CONFIGURE);
ADD_ENUM(GPIO_ERROR_UNSUPPORTED);
ADD_ENUM(GPIO_ERROR_INVALID_OPERATION);
ADD_ENUM(GPIO_ERROR_IO);
ADD_ENUM(GPIO_ERROR_CLOSE);
ADD_ENUM(GPIO_DIR_IN);
ADD_ENUM(GPIO_DIR_OUT);
ADD_ENUM(GPIO_DIR_OUT_LOW);
ADD_ENUM(GPIO_DIR_OUT_HIGH);
ADD_ENUM(GPIO_EDGE_NONE);
ADD_ENUM(GPIO_EDGE_RISING);
ADD_ENUM(GPIO_EDGE_FALLING);
ADD_ENUM(GPIO_EDGE_BOTH);
ADD_ENUM(GPIO_EVENT_CLOCK_REALTIME);
ADD_ENUM(GPIO_EVENT_CLOCK_MONOTONIC);
ADD_ENUM(GPIO_EVENT_CLOCK_HTE);
ADD_ENUM(GPIO_BIAS_DEFAULT);
ADD_ENUM(GPIO_BIAS_PULL_UP);
ADD_ENUM(GPIO_BIAS_PULL_DOWN);
ADD_ENUM(GPIO_BIAS_DISABLE);
ADD_ENUM(GPIO_DRIVE_DEFAULT);
ADD_ENUM(GPIO_DRIVE_OPEN_DRAIN);
ADD_ENUM(GPIO_DRIVE_OPEN_SOURCE);
ADD_ENUM(PWM_ERROR_ARG);
ADD_ENUM(PWM_ERROR_OPEN);
ADD_ENUM(PWM_ERROR_QUERY);
ADD_ENUM(PWM_ERROR_CONFIGURE);
ADD_ENUM(PWM_ERROR_CLOSE);
ADD_ENUM(PWM_POLARITY_NORMAL);
ADD_ENUM(PWM_POLARITY_INVERSED);
}
Reference in New Issue View Git Blame Copy Permalink