/alps/pcitool

To get this branch, use:
bzr branch http://suren.me/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to views/script.c

  • Committer: Vasilii Chernov
  • Date: 2016-02-08 10:55:33 UTC
  • mto: This revision was merged to the branch mainline in revision 353.
  • Revision ID: vchernov@inr.ru-20160208105533-fl0uue3ukv6di13b
Add support for setting register value to script transfrom. Add set_property and get_property functions to pcipywrap. Cleaning cmakelists from unused dependencies

Show diffs side-by-side

added added

removed removed

Lines of Context:
views/script.c
4
4
#include <stdlib.h>
5
5
 
6
6
#include "pci.h"
 
7
#include "pcipywrap.h"
7
8
#include "error.h"
8
9
 
9
10
#include "model.h"
10
11
#include "script.h"
11
12
 
12
 
static int pcilib_script_view_read(pcilib_t *ctx, pcilib_view_context_t *view_ctx, pcilib_register_value_t regval, pcilib_value_t *val) {
13
 
        
 
13
static int pcilib_script_view_module_init(pcilib_t *ctx, pcilib_script_view_description_t *v)
 
14
{
14
15
        int err;
15
 
 
16
 
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
17
 
    pcilib_script_view_description_t *v = (pcilib_script_view_description_t*)(model_info->views[view_ctx->view]);
18
16
        
19
17
        //Initialize python script, if it has not initialized already.
20
18
        if(!v->py_script_module)
103
101
                               NULL);
104
102
        }
105
103
        
 
104
        return 0;
 
105
}
 
106
 
 
107
static int pcilib_script_view_read(pcilib_t *ctx, pcilib_view_context_t *view_ctx, pcilib_register_value_t regval, pcilib_value_t *val) {
 
108
        
 
109
        int err;
 
110
 
 
111
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
112
    pcilib_script_view_description_t *v = (pcilib_script_view_description_t*)(model_info->views[view_ctx->view]);
 
113
        
 
114
        err = pcilib_script_view_module_init(ctx, v);
 
115
        if(err)
 
116
                return err;
106
117
        
107
118
        PyObject *ret = PyObject_CallMethod(v->py_script_module, "read_from_register", "()");
108
119
        if (!ret) 
112
123
           return PCILIB_ERROR_FAILED;
113
124
        }
114
125
        
115
 
        if(PyInt_Check(ret))
116
 
        {
117
 
                err = pcilib_set_value_from_int(ctx, val, PyInt_AsLong(ret));
118
 
        }
119
 
        else
120
 
                if(PyFloat_Check(ret))
121
 
                        err = pcilib_set_value_from_float(ctx, val, PyFloat_AsDouble(ret));
122
 
                else
123
 
                        if(PyString_Check(ret))
124
 
                                err = pcilib_set_value_from_static_string(ctx, val, PyString_AsString(ret));
125
 
                                else
126
 
                                {
127
 
                                        pcilib_error("Invalid return type in read_from_register() method. Return type should be int, float or string.");
128
 
                                        return PCILIB_ERROR_NOTSUPPORTED;
129
 
                                }
 
126
        err = pcilib_convert_pyobject_to_val(ctx, ret, val);
 
127
        
130
128
        if(err)
131
129
        {
132
130
                pcilib_error("Failed to convert python script return value to internal type: %i", err);
135
133
    return 0;
136
134
}
137
135
 
138
 
 
 
136
static int pcilib_script_view_write(pcilib_t *ctx, pcilib_view_context_t *view_ctx, pcilib_register_value_t *regval, pcilib_value_t *val) {
 
137
        
 
138
        int err;
 
139
 
 
140
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
141
    pcilib_script_view_description_t *v = (pcilib_script_view_description_t*)(model_info->views[view_ctx->view]);
 
142
        
 
143
        err = pcilib_script_view_module_init(ctx, v);
 
144
        if(err)
 
145
                return err;
 
146
                
 
147
        PyObject *input = pcilib_convert_val_to_pyobject(ctx, val, printf);
 
148
        if(!input)
 
149
        {
 
150
           printf("Failed to convert input value to Python object");
 
151
           PyErr_Print();
 
152
           return PCILIB_ERROR_FAILED;
 
153
        }
 
154
        
 
155
        PyObject *ret = PyObject_CallMethodObjArgs(v->py_script_module,
 
156
                                                                                           PyUnicode_FromString("write_to_register"),
 
157
                                                                                           input,
 
158
                                                                                           NULL);
 
159
        if (!ret) 
 
160
        {
 
161
           printf("Python script error: ");
 
162
           PyErr_Print();
 
163
           return PCILIB_ERROR_FAILED;
 
164
        }
 
165
        
 
166
        //convert output value back to pcilib_value_t
 
167
        //no need because it wont be used later, and the script return could be none
 
168
        /*
 
169
        err = pcilib_convert_pyobject_to_val(ctx, ret, val);
 
170
        if(err)
 
171
        {
 
172
                pcilib_error("failed to convert script write_to_register function return value to internal type: %i", err);
 
173
                return err;
 
174
        }
 
175
        
 
176
        uint64_t output = pcilib_get_value_as_register_value(ctx, val, &err);
 
177
        if(err)
 
178
        {
 
179
                pcilib_error("failed to convert value to register value (%i)", err);
 
180
                return err;
 
181
        }
 
182
        regval[0] = output;
 
183
        */
 
184
 
 
185
    return 0;
 
186
}
 
187
 
139
188
void pcilib_script_view_free_description (pcilib_t *ctx, pcilib_view_description_t *view)
140
189
{
141
190
        pcilib_script_view_description_t *v = (pcilib_script_view_description_t*)(view);
154
203
}
155
204
 
156
205
const pcilib_view_api_description_t pcilib_script_view_api =
157
 
  { PCILIB_VERSION, sizeof(pcilib_script_view_description_t), NULL, NULL, pcilib_script_view_free_description, pcilib_script_view_read, NULL};
 
206
  { PCILIB_VERSION, sizeof(pcilib_script_view_description_t), NULL, NULL, pcilib_script_view_free_description, pcilib_script_view_read, pcilib_script_view_write};