/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 event.c

  • Committer: Suren A. Chilingaryan
  • Date: 2015-04-20 20:01:04 UTC
  • Revision ID: csa@suren.me-20150420200104-b5xny65io8lvoz3w
Big redign of model structures

Show diffs side-by-side

added added

removed removed

Lines of Context:
event.c
30
30
pcilib_event_t pcilib_find_event(pcilib_t *ctx, const char *event) {
31
31
    int i;
32
32
 
33
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
34
 
    pcilib_event_description_t *events = model_info->events;
 
33
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
34
    const pcilib_event_description_t *events = model_info->events;
35
35
 
36
36
    for (i = 0; events[i].name; i++) {
37
37
        if (!strcasecmp(events[i].name, event)) return events[i].evid;
43
43
pcilib_event_data_type_t pcilib_find_event_data_type(pcilib_t *ctx, pcilib_event_t event, const char *data_type) {
44
44
    int i;
45
45
    
46
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
47
 
    pcilib_event_data_type_description_t *data_types = model_info->data_types;
 
46
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
47
    const pcilib_event_data_type_description_t *data_types = model_info->data_types;
48
48
    
49
49
    for (i = 0; data_types[i].name; i++) {
50
50
        if ((data_types[i].evid&event)&&(!strcasecmp(data_types[i].name, data_type))) return data_types[i].data_type;
54
54
}
55
55
 
56
56
int pcilib_init_event_engine(pcilib_t *ctx) {
57
 
    pcilib_event_api_description_t *api;
58
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
59
 
 
60
 
    api = model_info->event_api;
61
 
 
62
 
//    api = pcilib_model[model].event_api;
 
57
    const pcilib_event_api_description_t *api;
 
58
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
59
 
 
60
    api = model_info->api;
 
61
 
 
62
//    api = pcilib_model[model].api;
63
63
    if ((api)&&(api->init)) {
64
64
        ctx->event_ctx = api->init(ctx);
65
65
        if (ctx->event_ctx) {
71
71
}
72
72
 
73
73
int pcilib_reset(pcilib_t *ctx) {
74
 
    pcilib_event_api_description_t *api;
 
74
    const pcilib_event_api_description_t *api;
75
75
    
76
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
76
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
77
77
 
78
 
    api = model_info->event_api;
 
78
    api = model_info->api;
79
79
    if (!api) {
80
80
        pcilib_error("Event API is not supported by the selected model");
81
81
        return PCILIB_ERROR_NOTSUPPORTED;
88
88
}
89
89
 
90
90
int pcilib_configure_rawdata_callback(pcilib_t *ctx, pcilib_event_rawdata_callback_t callback, void *user) {
91
 
    pcilib_event_api_description_t *api;
92
 
    
93
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
91
    const pcilib_event_api_description_t *api;
 
92
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
94
93
 
95
 
    api = model_info->event_api;
 
94
    api = model_info->api;
96
95
    if (!api) {
97
96
        pcilib_error("Event API is not supported by the selected model");
98
97
        return PCILIB_ERROR_NOTSUPPORTED;
105
104
}
106
105
 
107
106
int pcilib_configure_autostop(pcilib_t *ctx, size_t max_events, pcilib_timeout_t duration) {
108
 
    pcilib_event_api_description_t *api;
109
 
    
110
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
107
    const pcilib_event_api_description_t *api;
 
108
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
111
109
 
112
 
    api = model_info->event_api;
 
110
    api = model_info->api;
113
111
    if (!api) {
114
112
        pcilib_error("Event API is not supported by the selected model");
115
113
        return PCILIB_ERROR_NOTSUPPORTED;
131
129
}
132
130
 
133
131
int pcilib_configure_preprocessing_threads(pcilib_t *ctx, size_t max_threads) {
134
 
    pcilib_event_api_description_t *api;
135
 
    
136
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
132
    const pcilib_event_api_description_t *api;
 
133
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
137
134
 
138
 
    api = model_info->event_api;
 
135
    api = model_info->api;
139
136
    if (!api) {
140
137
        pcilib_error("Event API is not supported by the selected model");
141
138
        return PCILIB_ERROR_NOTSUPPORTED;
147
144
}
148
145
 
149
146
int pcilib_start(pcilib_t *ctx, pcilib_event_t event_mask, pcilib_event_flags_t flags) {
150
 
    pcilib_event_api_description_t *api;
151
 
    
152
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
147
    const pcilib_event_api_description_t *api;
 
148
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
153
149
 
154
 
    api = model_info->event_api;
 
150
    api = model_info->api;
155
151
    if (!api) {
156
152
        pcilib_error("Event API is not supported by the selected model");
157
153
        return PCILIB_ERROR_NOTSUPPORTED;
164
160
}
165
161
 
166
162
int pcilib_stop(pcilib_t *ctx, pcilib_event_flags_t flags) {
167
 
    pcilib_event_api_description_t *api;
168
 
    
169
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
163
    const pcilib_event_api_description_t *api;
 
164
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
170
165
 
171
 
    api = model_info->event_api;
 
166
    api = model_info->api;
172
167
    if (!api) {
173
168
        pcilib_error("Event API is not supported by the selected model");
174
169
        return PCILIB_ERROR_NOTSUPPORTED;
181
176
}
182
177
 
183
178
int pcilib_stream(pcilib_t *ctx, pcilib_event_callback_t callback, void *user) {
184
 
    pcilib_event_api_description_t *api;
185
 
    
186
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
179
    const pcilib_event_api_description_t *api;
 
180
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
187
181
 
188
 
    api = model_info->event_api;
 
182
    api = model_info->api;
189
183
    if (!api) {
190
184
        pcilib_error("Event API is not supported by the selected model");
191
185
        return PCILIB_ERROR_NOTSUPPORTED;
215
209
*/
216
210
 
217
211
int pcilib_get_next_event(pcilib_t *ctx, pcilib_timeout_t timeout, pcilib_event_id_t *evid, size_t info_size, pcilib_event_info_t *info) {
218
 
    pcilib_event_api_description_t *api;
 
212
    const pcilib_event_api_description_t *api;
219
213
//    pcilib_return_event_callback_context_t user;
220
 
    
221
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
214
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
222
215
 
223
 
    api = model_info->event_api;
 
216
    api = model_info->api;
224
217
    if (!api) {
225
218
        pcilib_error("Event API is not supported by the selected model");
226
219
        return PCILIB_ERROR_NOTSUPPORTED;
246
239
}
247
240
 
248
241
int pcilib_trigger(pcilib_t *ctx, pcilib_event_t event, size_t trigger_size, void *trigger_data) {
249
 
    pcilib_event_api_description_t *api;
250
 
    
251
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
242
    const pcilib_event_api_description_t *api;
 
243
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
252
244
 
253
 
    api = model_info->event_api;
 
245
    api = model_info->api;
254
246
    if (!api) {
255
247
        pcilib_error("Event API is not supported by the selected model");
256
248
        return PCILIB_ERROR_NOTSUPPORTED;
267
259
void *pcilib_get_data_with_argument(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t arg_size, void *arg, size_t *size) {
268
260
    int err;
269
261
    void *res = NULL;
270
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
271
 
 
272
 
    pcilib_event_api_description_t *api = model_info->event_api;
 
262
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
263
    const pcilib_event_api_description_t *api = model_info->api;
273
264
    if (!api) {
274
265
        if (size) *size = (size_t)PCILIB_ERROR_NOTSUPPORTED;
275
266
        pcilib_error("Event API is not supported by the selected model");
292
283
int pcilib_copy_data_with_argument(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t arg_size, void *arg, size_t size, void *buf, size_t *retsize) {
293
284
    int err;
294
285
    void *res = buf;
295
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
296
 
 
297
 
    pcilib_event_api_description_t *api = model_info->event_api;
 
286
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
287
    const pcilib_event_api_description_t *api = model_info->api;
298
288
    if (!api) {
299
289
        pcilib_error("Event API is not supported by the selected model");
300
290
        return PCILIB_ERROR_NOTSUPPORTED;
317
307
void *pcilib_get_data(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t *size) {
318
308
    int err;
319
309
    void *res = NULL;
320
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
321
 
 
322
 
    pcilib_event_api_description_t *api = model_info->event_api;
 
310
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
311
    const pcilib_event_api_description_t *api = model_info->api;
323
312
    if (!api) {
324
313
        pcilib_error("Event API is not supported by the selected model");
325
314
        if (size) *size = (size_t)PCILIB_ERROR_NOTSUPPORTED;
342
331
int pcilib_copy_data(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t size, void *buf, size_t *ret_size) {
343
332
    int err;
344
333
    void *res = buf;
345
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
346
 
 
347
 
    pcilib_event_api_description_t *api = model_info->event_api;
 
334
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
335
    const pcilib_event_api_description_t *api = model_info->api;
348
336
    if (!api) {
349
337
        pcilib_error("Event API is not supported by the selected model");
350
338
        return PCILIB_ERROR_NOTSUPPORTED;
364
352
}
365
353
 
366
354
int pcilib_return_data(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, void *data) {
367
 
    pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
368
 
    
369
 
    pcilib_event_api_description_t *api = model_info->event_api;
 
355
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
 
356
    const pcilib_event_api_description_t *api = model_info->api;
370
357
    if (!api) {
371
358
        pcilib_error("Event API is not supported by the selected model");
372
359
        return PCILIB_ERROR_NOTSUPPORTED;