source: libvcomm/vactions.c @ dd0acb5

Revision dd0acb5, 8.7 KB checked in by Tarmo Kople <tarmo@…>, 8 years ago (diff)

+ build directories for Linux, Os X, Windows

  • Property mode set to 100755
Line 
1/*
2 * vactions.c
3 *
4 *  Created on: 11.09.2012
5 *      Author: tarmo
6 */
7
8#include <stdint.h>
9#include <stdio.h>
10#include <string.h>
11#include "hidapi.h"
12#include "proto.h"
13#include "vcomm.h"
14
15
16VCOMMAPI int VCOMMCALL Vget_event(hid_device **vhandle, irevent_t *ev, int eventnum) {
17
18        int resp;
19        response_t response;
20        request_t request;
21
22        request.type = REQ_GET_EVENT;
23        request.data[0] = eventnum & 0xFF;
24        request.data[1] = (eventnum & 0xFF00) >> 8;
25
26        if ((resp = Vcomm(vhandle, &request, &response)))
27                return resp;
28
29        memcpy(ev, &response.data[0], sizeof(irevent_t));
30        return SUCCESS;
31
32}
33
34VCOMMAPI int VCOMMCALL Vget_eventmap(hid_device **vhandle, eventmap_t *em) {
35
36        int resp;
37        response_t response;
38        request_t request;
39
40        request.type = REQ_GET_EVENTMAP;
41
42        if ((resp = Vcomm(vhandle, &request, &response)))
43                // FAIL
44                return resp;
45
46        memcpy(em, &response.data[0], sizeof(eventmap_t));
47        return SUCCESS;
48}
49
50VCOMMAPI int VCOMMCALL Vget_ircode(hid_device **vhandle, ircode_t *ircode) {
51
52        int resp;
53        response_t response;
54        request_t request;
55
56        request.type = REQ_GET_IRCODE;
57        resp = Vcomm(vhandle, &request, &response);
58        if (resp)
59                // FAIL
60                return resp;
61
62        memcpy(ircode, &response.data[0], sizeof(ircode_t));
63        return SUCCESS;
64}
65
66VCOMMAPI int VCOMMCALL Vget_irframe(hid_device **vhandle, irframe_t *irframe) {
67        int resp;
68        response_t response;
69        request_t request;
70
71        request.type = REQ_GET_IR_FRAME;
72        resp = Vcomm(vhandle, &request, &response);
73        if (resp)
74                return resp;
75
76        memcpy(irframe, &response.data[0], sizeof(irframe_t));
77        return SUCCESS;
78}
79
80VCOMMAPI int VCOMMCALL Vget_id(hid_device **vhandle, hwid_t *id) {
81        int resp;
82        response_t response;
83        request_t request;
84
85        request.type = REQ_GET_ID;
86        resp = Vcomm(vhandle, &request, &response);
87        if (resp)
88                return resp;
89
90        memcpy(id, &response.data[0], sizeof(hwid_t));
91        return SUCCESS;
92}
93
94VCOMMAPI int VCOMMCALL Vget_fw_version(hid_device **vhandle, uint32_t *fwver) {
95        int resp;
96        response_t response;
97        request_t request;
98
99        request.type = REQ_GET_FW_VERSION;
100        if ((resp = Vcomm(vhandle, &request, &response)))
101                        return resp;
102
103        memcpy(fwver, &response.data[0], sizeof(uint32_t));
104        return SUCCESS;
105}
106
107VCOMMAPI int VCOMMCALL Vget_fw(hid_device **vhandle, uint8_t *fwdata) {
108        int resp;
109        response_t response;
110        request_t request;
111
112        request.type = REQ_GET_FW;
113        if ((resp = Vcomm(vhandle, &request, &response)))
114                        return resp;
115
116        memcpy(fwdata, &response.data[0], 32 * 1024);
117        return SUCCESS;
118}
119
120VCOMMAPI int VCOMMCALL Vset_mode(hid_device **vhandle, int mode){
121        int resp;
122        response_t response;
123        request_t request;
124
125        if(mode != REQ_SET_MODE_NORMAL && mode != REQ_SET_MODE_CAPT && mode != REQ_SET_MODE_CFG){
126                return ERR_ARGUMENT_ERROR;
127        }
128        request.type = mode;
129
130        if ((resp = Vcomm(vhandle, &request, &response)))
131                        return resp;
132
133        return response.data[0];
134}
135
136VCOMMAPI int VCOMMCALL Vset_led(hid_device **vhandle, int ledstate){
137        int resp;
138        response_t response;
139        request_t request;
140
141        if(ledstate != 0 && ledstate != 1){
142                return ERR_ARGUMENT_ERROR;
143        }
144        request.type = REQ_SET_LED;
145        request.data[0] = ledstate;
146
147        if ((resp = Vcomm(vhandle, &request, &response)))
148                        return resp;
149
150        return response.data[0];
151}
152
153VCOMMAPI int VCOMMCALL Vclear_last(hid_device **vhandle){
154        int resp;
155        response_t response;
156        request_t request;
157
158        request.type = REQ_CLEAR_LAST;
159
160        if ((resp = Vcomm(vhandle, &request, &response)))
161                        return resp;
162
163        return response.data[0];
164}
165
166VCOMMAPI int VCOMMCALL Vclear_eventmap(hid_device **vhandle){
167        int resp;
168        response_t response;
169        request_t request;
170
171        request.type = REQ_CLEAR_EVENTMAP;
172
173        if ((resp = Vcomm(vhandle, &request, &response)))
174                        return resp;
175
176        return response.data[0];
177}
178
179
180VCOMMAPI int VCOMMCALL Vset_ircode(hid_device **vhandle, ircode_t *ircode, cmdstat_t *cmdstat ){
181        int resp;
182        response_t response;
183        request_t request;
184
185        // create request
186        request.type = REQ_SET_IRCODE;
187        memcpy(&request.data[0], ircode, sizeof(ircode_t));
188
189
190        if ((resp = Vcomm(vhandle, &request, &response)))
191                // FAIL
192                return resp;
193
194        cmdstat->type = response.type;
195        cmdstat->err_code = response.data[0];
196
197        return SUCCESS;
198
199}
200
201VCOMMAPI int VCOMMCALL Vset_event(hid_device **vhandle, ircode_t *from_ircode, ircode_t *to_ircode, cmdstat_t *cmdstat ){
202        int resp;
203        response_t response;
204        request_t request;
205
206        // create IRevent
207        irevent_t *ev;
208        ev = (irevent_t *)&request.data[0];
209        // fill in ircode
210        memcpy(&ev->in, from_ircode, sizeof(ircode_t));
211        memcpy(&ev->out, to_ircode, sizeof(ircode_t));
212
213        // set request type
214        request.type = REQ_SET_EVENT;
215
216
217        if ((resp = Vcomm(vhandle, &request, &response)))
218                // FAIL
219                return resp;
220
221        cmdstat->type = response.type;
222        cmdstat->err_code = response.data[0];
223
224        return SUCCESS;
225
226}
227
228VCOMMAPI int VCOMMCALL Vset_irframe_page(hid_device **vhandle, uint8_t page_num, uint32_t *page_data, cmdstat_t *cmdstat ){
229
230        int resp;
231        response_t response;
232        request_t request;
233
234        // set request type
235        request.type = REQ_SET_IRFRAME_PAGE;
236        request.data[0] = page_num;
237        memcpy(&request.data[1], page_data, 48);
238
239        if ((resp = Vcomm(vhandle, &request, &response)))
240                // FAIL
241                return resp;
242
243        cmdstat->type = response.type;
244        cmdstat->err_code = response.data[0];
245
246        return SUCCESS;
247
248}
249VCOMMAPI int VCOMMCALL Vset_irframe_info(hid_device **vhandle, uint16_t num_pulses, cmdstat_t *cmdstat ){
250
251        int resp;
252        response_t response;
253        request_t request;
254
255        // set request type
256        request.type = REQ_SET_IRFRAME_INFO;
257        request.data[0] = num_pulses & 0xFF;
258        request.data[1] = (num_pulses & 0xFF00) >> 8;
259
260        if ((resp = Vcomm(vhandle, &request, &response)))
261                // FAIL
262                return resp;
263
264        cmdstat->type = response.type;
265        cmdstat->err_code = response.data[0];
266
267        return SUCCESS;
268
269}
270
271VCOMMAPI int VCOMMCALL Vset_irframe(hid_device **vhandle, irframe_t *irframe){
272
273        uint32_t numpages = 0;
274        uint8_t pagenum = 0;
275        cmdstat_t cmdstat;
276        int resp;
277
278        numpages = irframe->num_pulses / 12;
279        if(irframe->num_pulses % 12) numpages++;
280
281        for (pagenum = 0; pagenum < numpages; ++pagenum) {
282                if( (resp = Vset_irframe_page(vhandle, pagenum, &irframe->length[pagenum * 12], &cmdstat))){
283                        return resp;
284                }
285        }
286
287        if((resp=Vset_irframe_info(vhandle, irframe->num_pulses, &cmdstat))) return resp;
288
289        return SUCCESS;
290
291}
292
293
294VCOMMAPI int VCOMMCALL Vclear_event_ircode(hid_device **vhandle, ircode_t *ircode, cmdstat_t *cmdstat ){
295        int resp;
296        response_t response;
297        request_t request;
298
299        memcpy(&request.data[0], ircode, sizeof(ircode_t));
300
301
302        // set request type
303        request.type = REQ_CLEAR_EVENT_IRCODE;
304
305
306        if ((resp = Vcomm(vhandle, &request, &response)))
307                // FAIL
308                return resp;
309
310        cmdstat->type = response.type;
311        cmdstat->err_code = response.data[0];
312
313        return SUCCESS;
314
315}
316
317VCOMMAPI int VCOMMCALL Vclear_event_num(hid_device **vhandle, int eventnum, cmdstat_t *cmdstat ){
318        int resp;
319        response_t response;
320        request_t request;
321
322
323        // set request type
324        request.type = REQ_CLEAR_EVENT_NUM;
325
326        request.data[0] = eventnum & 0xFF;
327        request.data[1] = (eventnum & 0xFF00) >> 8;
328
329
330        if ((resp = Vcomm(vhandle, &request, &response)))
331                // FAIL
332                return resp;
333
334        cmdstat->type = response.type;
335        cmdstat->err_code = response.data[0];
336
337        return SUCCESS;
338
339}
340
341VCOMMAPI int VCOMMCALL Vget_config(hid_device **vhandle, config_t *config ){
342        int resp;
343        response_t response;
344        request_t request;
345
346        // set request type
347        request.type = REQ_GET_CONFIG;
348
349
350        if ((resp = Vcomm(vhandle, &request, &response)))
351                // FAIL
352                return resp;
353
354        memcpy(config, &response.data[0], sizeof(config_t));
355        return SUCCESS;
356}
357
358VCOMMAPI int VCOMMCALL Vset_config(hid_device **vhandle, config_t *config ){
359        int resp;
360        response_t response;
361        request_t request;
362
363        // set request type
364        request.type = REQ_SET_CONFIG;
365
366        memcpy(&request.data[0], config, sizeof(config_t));
367
368        if ((resp = Vcomm(vhandle, &request, &response)))
369                // FAIL
370                return resp;
371
372        return SUCCESS;
373}
374
375VCOMMAPI int VCOMMCALL Vreset_config(hid_device **vhandle){
376        int resp;
377        response_t response;
378        request_t request;
379
380        // set request type
381        request.type = REQ_RESET_CONFIG;
382
383        if ((resp = Vcomm(vhandle, &request, &response)))
384                // FAIL
385                return resp;
386
387        return SUCCESS;
388}
389
390VCOMMAPI int VCOMMCALL Vget_stat(hid_device **vhandle, stat_t *stat ){
391
392        int resp;
393        response_t response;
394        request_t request;
395
396        // set request type
397        request.type = REQ_GET_STAT;
398
399
400        if ((resp = Vcomm(vhandle, &request, &response)))
401                // FAIL
402                return resp;
403
404        memcpy(stat, &response.data[0], sizeof(stat_t));
405
406        return SUCCESS;
407
408}
409
410VCOMMAPI int VCOMMCALL Venter_isp(hid_device **vhandle, uint8_t time ){
411
412        response_t response;
413        request_t request;
414
415        // set request type
416        request.type = REQ_ENTER_ISP;
417
418        if (time < 10) time = 10;
419        request.data[0] = time;
420        Vcomm(vhandle, &request, &response);
421
422        Vclose(vhandle);
423
424        return SUCCESS;
425
426}
427
428VCOMMAPI int VCOMMCALL Vget_btn(hid_device **vhandle, uint8_t *state ){
429
430        int resp;
431        response_t response;
432        request_t request;
433
434        // set request type
435        request.type = REQ_GET_BTN;
436
437
438        if ((resp = Vcomm(vhandle, &request, &response)))
439                // FAIL
440                return resp;
441
442        *state = response.data[0];
443
444        return SUCCESS;
445}
446
Note: See TracBrowser for help on using the repository browser.