source: libvcomm/vactions.c @ 2fba30a

Revision 2fba30a, 9.0 KB checked in by Tarmo Kople <tarmo@…>, 5 years ago (diff)

+ added Vblast_irframe action

Vblast_irframe(hid_device vhandle, uint8_t freq, uint8_t duty)
Blasts previously captured or set IRframe

  • 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
293VCOMMAPI int VCOMMCALL Vblast_irframe(hid_device **vhandle, uint8_t freq, uint8_t duty){
294        int resp;
295        response_t response;
296        request_t request;
297
298        request.type = REQ_BLAST_IRFRAME;
299        request.data[0] = freq;
300        request.data[1] = duty;
301
302        if ((resp = Vcomm(vhandle, &request, &response)))
303                        return resp;
304
305        return response.data[0];
306}
307
308VCOMMAPI int VCOMMCALL Vclear_event_ircode(hid_device **vhandle, ircode_t *ircode, cmdstat_t *cmdstat ){
309        int resp;
310        response_t response;
311        request_t request;
312
313        memcpy(&request.data[0], ircode, sizeof(ircode_t));
314
315
316        // set request type
317        request.type = REQ_CLEAR_EVENT_IRCODE;
318
319
320        if ((resp = Vcomm(vhandle, &request, &response)))
321                // FAIL
322                return resp;
323
324        cmdstat->type = response.type;
325        cmdstat->err_code = response.data[0];
326
327        return SUCCESS;
328
329}
330
331VCOMMAPI int VCOMMCALL Vclear_event_num(hid_device **vhandle, int eventnum, cmdstat_t *cmdstat ){
332        int resp;
333        response_t response;
334        request_t request;
335
336
337        // set request type
338        request.type = REQ_CLEAR_EVENT_NUM;
339
340        request.data[0] = eventnum & 0xFF;
341        request.data[1] = (eventnum & 0xFF00) >> 8;
342
343
344        if ((resp = Vcomm(vhandle, &request, &response)))
345                // FAIL
346                return resp;
347
348        cmdstat->type = response.type;
349        cmdstat->err_code = response.data[0];
350
351        return SUCCESS;
352
353}
354
355VCOMMAPI int VCOMMCALL Vget_config(hid_device **vhandle, config_t *config ){
356        int resp;
357        response_t response;
358        request_t request;
359
360        // set request type
361        request.type = REQ_GET_CONFIG;
362
363
364        if ((resp = Vcomm(vhandle, &request, &response)))
365                // FAIL
366                return resp;
367
368        memcpy(config, &response.data[0], sizeof(config_t));
369        return SUCCESS;
370}
371
372VCOMMAPI int VCOMMCALL Vset_config(hid_device **vhandle, config_t *config ){
373        int resp;
374        response_t response;
375        request_t request;
376
377        // set request type
378        request.type = REQ_SET_CONFIG;
379
380        memcpy(&request.data[0], config, sizeof(config_t));
381
382        if ((resp = Vcomm(vhandle, &request, &response)))
383                // FAIL
384                return resp;
385
386        return SUCCESS;
387}
388
389VCOMMAPI int VCOMMCALL Vreset_config(hid_device **vhandle){
390        int resp;
391        response_t response;
392        request_t request;
393
394        // set request type
395        request.type = REQ_RESET_CONFIG;
396
397        if ((resp = Vcomm(vhandle, &request, &response)))
398                // FAIL
399                return resp;
400
401        return SUCCESS;
402}
403
404VCOMMAPI int VCOMMCALL Vget_stat(hid_device **vhandle, stat_t *stat ){
405
406        int resp;
407        response_t response;
408        request_t request;
409
410        // set request type
411        request.type = REQ_GET_STAT;
412
413
414        if ((resp = Vcomm(vhandle, &request, &response)))
415                // FAIL
416                return resp;
417
418        memcpy(stat, &response.data[0], sizeof(stat_t));
419
420        return SUCCESS;
421
422}
423
424VCOMMAPI int VCOMMCALL Venter_isp(hid_device **vhandle, uint8_t time ){
425
426        response_t response;
427        request_t request;
428
429        // set request type
430        request.type = REQ_ENTER_ISP;
431
432        if (time < 10) time = 10;
433        request.data[0] = time;
434        Vcomm(vhandle, &request, &response);
435
436        Vclose(vhandle);
437
438        return SUCCESS;
439
440}
441
442VCOMMAPI int VCOMMCALL Vget_btn(hid_device **vhandle, uint8_t *state ){
443
444        int resp;
445        response_t response;
446        request_t request;
447
448        // set request type
449        request.type = REQ_GET_BTN;
450
451
452        if ((resp = Vcomm(vhandle, &request, &response)))
453                // FAIL
454                return resp;
455
456        *state = response.data[0];
457
458        return SUCCESS;
459}
460
Note: See TracBrowser for help on using the repository browser.