6
* \brief Global pointer to pcilib_t context.
7
* Used by setPcilib and read_register.
12
* \brief Wraping for vsnprintf function, that saves string to char*
13
* \return saved from vsnprintf string
15
char* vmake_str(const char* msg, va_list vl)
23
sz = vsnprintf(NULL, 0, msg, vl);
24
buf = (char *)malloc(sz + 1);
31
vsnprintf(buf, sz+1, msg, vl_copy);
38
* \brief Wraping for vsnprintf function, that saves string to char*
39
* \return saved from vsnprintf string
41
char* make_str(const char* msg, ...)
45
char *buf = vmake_str(msg, vl);
51
* \brief Version of pcilib_logger_t, that saves error text to Python exeption
53
void pcilib_print_error_to_py(void *arg, const char *file, int line,
54
pcilib_log_priority_t prio, const char *msg,
56
char* buf_raw_msg = vmake_str(msg, va);
57
char* buf_wrapped_message = make_str("%s [%s:%d]\n", buf_raw_msg, file, line);
59
printf("%s", buf_wrapped_message);
60
PyErr_SetString(PyExc_Exception, buf_wrapped_message);
62
free(buf_wrapped_message);
67
* \brief Inits pcipywrap module at importing
69
void init_pcipywrap_module()
71
pcilib_set_logger(pcilib_get_logger_min_prio(),
72
pcilib_print_error_to_py,
73
pcilib_get_logger_argument());
77
* \brief Wraps for pcilib_open function.
78
* \param[in] fpga_device path to the device file [/dev/fpga0]
79
* \param[in] model specifies the model of hardware, autodetected if NULL is passed
80
* \return Pointer to pcilib_t, created by pcilib_open, serialized to bytearray; NULL with exeption text, if failed.
82
PyObject* createPcilibInstance(const char *fpga_device, const char *model)
85
pcilib_t* ctx = pcilib_open(fpga_device, model);
90
return PyByteArray_FromStringAndSize((const char*)&ctx, sizeof(pcilib_t*));
94
* \brief Closes current pciliv instance, if its open.
96
void closeCurrentPcilibInstance()
106
* \brief Returns current opened pcilib_t instatnce
107
* \return Pointer to pcilib_t, serialized to bytearray
109
PyObject* getCurrentPcilibInstance()
111
return PyByteArray_FromStringAndSize((const char*)&__ctx, sizeof(pcilib_t*));
115
* \brief Sets pcilib context to wraper.
116
* \param[in] addr Pointer to pcilib_t, serialized to bytearray
117
* \return 1, serialized to PyObject or NULL with exeption text, if failed.
119
PyObject* setPcilib(PyObject* addr)
121
if(!PyByteArray_Check(addr))
123
pcilib_error("Incorrect addr type. Only bytearray is allowed");
127
//deserializing adress
128
char* pAddr = PyByteArray_AsString(addr);
130
//hard copy context adress
131
for(int i = 0; i < sizeof(pcilib_t*) + 10; i++)
132
((char*)&__ctx)[i] = pAddr[i];
134
return PyInt_FromLong((long)1);
139
* \brief Reads register value. Wrap for pcilib_read_register function.
140
* \param[in] regname the name of the register
141
* \param[in] bank should specify the bank name if register with the same name may occur in multiple banks, NULL otherwise
142
* \return register value, can be integer or float type; NULL with exeption text, if failed.
144
PyObject* read_register(const char *regname, const char *bank)
148
pcilib_error("pcilib_t handler not initialized");
152
pcilib_value_t val = {0};
153
pcilib_register_value_t reg_value;
157
err = pcilib_read_register(__ctx, bank, regname, ®_value);
160
pcilib_error("Failed: pcilib_read_register (%i)", err);
164
err = pcilib_set_value_from_register_value(__ctx, &val, reg_value);
167
pcilib_error("Failed: pcilib_set_value_from_register_value (%i)", err);
171
return pcilib_convert_val_to_pyobject(__ctx, &val);
175
* \brief Writes value to register. Wrap for pcilib_write_register function.
176
* \param[in] val Register value, that needs to be set. Can be int, float or string.
177
* \param[in] regname the name of the register
178
* \param[in] bank should specify the bank name if register with the same name may occur in multiple banks, NULL otherwise
179
* \return 1, serialized to PyObject or NULL with exeption text, if failed.
181
PyObject* write_register(PyObject* val, const char *regname, const char *bank)
185
pcilib_error("pcilib_t handler not initialized");
189
pcilib_value_t val_internal = {0};
190
pcilib_register_value_t reg_value;
193
err = pcilib_convert_pyobject_to_val(__ctx, val, &val_internal);
196
pcilib_error("Failed pcilib_convert_pyobject_to_val (%i)", err);
200
reg_value = pcilib_get_value_as_register_value(__ctx, &val_internal, &err);
203
pcilib_error("Failed: pcilib_get_value_as_register_value (%i)", err);
207
err = pcilib_write_register(__ctx, bank, regname, reg_value);
210
pcilib_error("Failed: pcilib_write_register (%i)", err);
213
return PyInt_FromLong((long)1);
217
* \brief Reads propety value. Wrap for pcilib_get_property function.
218
* \param[in] prop property name (full name including path)
219
* \return property value, can be integer or float type; NULL with exeption text, if failed.
221
PyObject* get_property(const char *prop)
225
pcilib_error("pcilib_t handler not initialized");
230
pcilib_value_t val = {0};
232
err = pcilib_get_property(__ctx, prop, &val);
236
pcilib_error("Failed pcilib_get_property (%i)", err);
240
return pcilib_convert_val_to_pyobject(__ctx, &val);
244
* \brief Writes value to property. Wrap for pcilib_set_property function.
245
* \param[in] prop property name (full name including path)
246
* \param[in] val Property value, that needs to be set. Can be int, float or string.
247
* \return 1, serialized to PyObject or NULL with exeption text, if failed.
249
PyObject* set_property(const char *prop, PyObject* val)
255
pcilib_error("pcilib_t handler not initialized");
259
pcilib_value_t val_internal = {0};
260
err = pcilib_convert_pyobject_to_val(__ctx, val, &val_internal);
263
pcilib_error("Failed pcilib_convert_pyobject_to_val (%i)", err);
267
err = pcilib_set_property(__ctx, prop, &val_internal);
271
pcilib_error("Failed pcilib_get_property (%i)", err);
275
return PyInt_FromLong((long)1);
278
void add_pcilib_value_to_dict(PyObject* dict, pcilib_value_t* val, const char *name)
280
PyObject *py_val = (PyObject*)pcilib_convert_val_to_pyobject(__ctx, val);
284
PyString_FromString(name),
288
PyString_FromString("defvalue"),
289
PyString_FromString("invalid"));
292
PyObject * pcilib_convert_property_info_to_pyobject(pcilib_property_info_t listItem)
294
PyObject* pylistItem = PyDict_New();
297
PyDict_SetItem(pylistItem,
298
PyString_FromString("name"),
299
PyString_FromString(listItem.name));
301
if(listItem.description)
302
PyDict_SetItem(pylistItem,
303
PyString_FromString("description"),
304
PyString_FromString(listItem.description));
307
PyDict_SetItem(pylistItem,
308
PyString_FromString("path"),
309
PyString_FromString(listItem.path));
312
const char* type = "invalid";
313
switch(listItem.type)
315
case PCILIB_TYPE_INVALID:
318
case PCILIB_TYPE_STRING:
321
case PCILIB_TYPE_DOUBLE:
324
case PCILIB_TYPE_LONG :
330
PyDict_SetItem(pylistItem,
331
PyString_FromString("type"),
332
PyString_FromString(type));
336
PyObject* modes = PyList_New(0);
338
if((listItem.mode & PCILIB_ACCESS_R ) == PCILIB_REGISTER_R)
339
PyList_Append(modes, PyString_FromString("R"));
340
if((listItem.mode & PCILIB_ACCESS_W ) == PCILIB_REGISTER_W)
341
PyList_Append(modes, PyString_FromString("W"));
342
if((listItem.mode & PCILIB_ACCESS_RW ) == PCILIB_REGISTER_RW)
343
PyList_Append(modes, PyString_FromString("RW"));
344
if((listItem.mode & PCILIB_REGISTER_NO_CHK) == PCILIB_REGISTER_NO_CHK)
345
PyList_Append(modes, PyString_FromString("NO_CHK"));
347
PyDict_SetItem(pylistItem,
348
PyString_FromString("mode"),
352
PyObject* flags = PyList_New(0);
354
if((listItem.flags & PCILIB_LIST_FLAG_CHILDS ) == PCILIB_LIST_FLAG_CHILDS)
355
PyList_Append(flags, PyString_FromString("childs"));
357
PyDict_SetItem(pylistItem,
358
PyString_FromString("flags"),
362
PyDict_SetItem(pylistItem,
363
PyString_FromString("unit"),
364
PyString_FromString(listItem.unit));
369
PyObject * pcilib_convert_register_info_to_pyobject(pcilib_register_info_t listItem)
371
PyObject* pylistItem = PyDict_New();
374
PyDict_SetItem(pylistItem,
375
PyString_FromString("name"),
376
PyString_FromString(listItem.name));
378
if(listItem.description)
379
PyDict_SetItem(pylistItem,
380
PyString_FromString("description"),
381
PyString_FromString(listItem.description));
384
PyDict_SetItem(pylistItem,
385
PyString_FromString("bank"),
386
PyString_FromString(listItem.bank));
389
PyObject* modes = PyList_New(0);
391
if((listItem.mode & PCILIB_REGISTER_R) == PCILIB_REGISTER_R)
392
PyList_Append(modes, PyString_FromString("R"));
393
if((listItem.mode & PCILIB_REGISTER_W) == PCILIB_REGISTER_W)
394
PyList_Append(modes, PyString_FromString("W"));
395
if((listItem.mode & PCILIB_REGISTER_RW) == PCILIB_REGISTER_RW)
396
PyList_Append(modes, PyString_FromString("RW"));
397
if((listItem.mode & PCILIB_REGISTER_W1C) == PCILIB_REGISTER_W1C)
398
PyList_Append(modes, PyString_FromString("W1C"));
399
if((listItem.mode & PCILIB_REGISTER_RW1C) == PCILIB_REGISTER_RW1C)
400
PyList_Append(modes, PyString_FromString("RW1C"));
401
if((listItem.mode & PCILIB_REGISTER_W1I) == PCILIB_REGISTER_W1I)
402
PyList_Append(modes, PyString_FromString("W1I"));
403
if((listItem.mode & PCILIB_REGISTER_RW1I) == PCILIB_REGISTER_RW1I)
404
PyList_Append(modes, PyString_FromString("RW1I"));
405
if((listItem.mode & PCILIB_REGISTER_NO_CHK) == PCILIB_REGISTER_NO_CHK)
406
PyList_Append(modes, PyString_FromString("NO_CHK"));
408
PyDict_SetItem(pylistItem,
409
PyString_FromString("mode"),
412
pcilib_value_t defval = {0};
413
pcilib_set_value_from_register_value(__ctx, &defval, listItem.defvalue);
414
add_pcilib_value_to_dict(pylistItem, &defval, "defvalue");
418
pcilib_value_t minval = {0};
419
pcilib_set_value_from_register_value(__ctx, &minval, listItem.range->min);
421
pcilib_value_t maxval = {0};
422
pcilib_set_value_from_register_value(__ctx, &maxval, listItem.range->max);
424
PyObject* range = PyDict_New();
425
add_pcilib_value_to_dict(range, &minval, "min");
426
add_pcilib_value_to_dict(range, &maxval, "max");
427
PyDict_SetItem(pylistItem,
428
PyString_FromString("range"),
434
PyObject* values = PyList_New(0);
436
for (int j = 0; listItem.values[j].name; j++)
438
PyObject* valuesItem = PyDict_New();
440
pcilib_value_t val = {0};
441
pcilib_set_value_from_register_value(__ctx, &val, listItem.values[j].value);
443
pcilib_value_t min = {0};
444
pcilib_set_value_from_register_value(__ctx, &min, listItem.values[j].min);
446
pcilib_value_t max = {0};
447
pcilib_set_value_from_register_value(__ctx, &max, listItem.values[j].max);
449
add_pcilib_value_to_dict(valuesItem, &val, "value");
450
add_pcilib_value_to_dict(valuesItem, &min, "min");
451
add_pcilib_value_to_dict(valuesItem, &max, "max");
453
if(listItem.values[j].name)
454
PyDict_SetItem(valuesItem,
455
PyString_FromString("name"),
456
PyString_FromString(listItem.values[j].name));
458
if(listItem.values[j].description)
459
PyDict_SetItem(valuesItem,
460
PyString_FromString("name"),
461
PyString_FromString(listItem.values[j].description));
463
PyList_Append(values, valuesItem);
466
PyDict_SetItem(pylistItem,
467
PyString_FromString("values"),
474
PyObject* get_register_list(const char *bank)
478
pcilib_error("pcilib_t handler not initialized");
482
pcilib_register_info_t *list = pcilib_get_register_list(__ctx, bank, PCILIB_LIST_FLAGS_DEFAULT);
484
PyObject* pyList = PyList_New(0);
485
for(int i = 0; i < __ctx->num_reg; i++)
487
//serialize item attributes
488
PyObject* pylistItem = pcilib_convert_register_info_to_pyobject(list[i]);
489
PyList_Append(pyList, pylistItem);
492
pcilib_free_register_info(__ctx, list);
497
PyObject* get_register_info(const char* reg,const char *bank)
501
pcilib_error("pcilib_t handler not initialized");
505
pcilib_register_info_t *info = pcilib_get_register_info(__ctx, bank, reg, PCILIB_LIST_FLAGS_DEFAULT);
509
pcilib_error("Failed pcilib_get_register_info");
513
PyObject* py_info = pcilib_convert_register_info_to_pyobject(info[0]);
515
pcilib_free_register_info(__ctx, info);
520
PyObject* get_property_info(const char* branch)
524
pcilib_error("pcilib_t handler not initialized");
528
pcilib_property_info_t *list = pcilib_get_property_list(__ctx, branch, PCILIB_LIST_FLAGS_DEFAULT);
530
PyObject* pyList = PyList_New(0);
532
for(int i = 0; list[i].path; i++)
534
//serialize item attributes
535
PyObject* pylistItem = pcilib_convert_property_info_to_pyobject(list[i]);
536
PyList_Append(pyList, pylistItem);
539
pcilib_free_property_info(__ctx, list);