1 /*===================================================================================================================================================
2
3 USB Remote : Shooting Control Modules
4
5 - shooting control modules monitor the state of the "virtual switch" variable and take
6 appropriate action according to the logic defined for that mode
7 - all interface to the physical camera is performed by these modules
8 - the active control module is selected from a menu entry in the USB Remote menu
9 - to add a control module, create a new function here, add string to gui_USB_control_modes[]
10 in gui.c and add ptr below to stucture (*usb_control_module[10])(int)
11 ===================================================================================================================================================*/
12
13 #include "camera_info.h"
14 #include "stdlib.h"
15 #include "clock.h"
16 #include "shooting.h"
17 #include "keyboard.h"
18 #include "conf.h"
19 #include "action_stack.h"
20 #include "usb_remote.h"
21
22 /*===================================================================================================
23 Debug and error handling
24 ===================================================================================================*/
25
26 #ifdef USB_REMOTE_DEBUGGING
27
28 extern int debug_errors[] ;
29 extern void debug_error(int ) ;
30
31 #else
32
33 extern void debug_error(int ) ;
34
35 #endif
36
37
38 /*---------------------------------------------------------------------------------------------------
39 Control Module : Playback
40 - does right & left key presses in playback mode to allow scrolling through images in LCD
41 - most useful with stereo photography to allow sync'd review of multiple cameras
42 ---------------------------------------------------------------------------------------------------*/
43
44 void usb_playback_module()
45 {
46 static int time_stamp = 0 ;
47 static int direction = 0 ; // 0 = left button, 1 = right button
48 int i, current_time ;
49
50 current_time = get_tick_count();
51
52 switch( logic_module_state )
53 {
54 case LM_RESET :
55 logic_module_state = LM_RELEASE ;
56 break ;
57 case LM_RELEASE :
58 i = get_usb_power(LM_PULSE_COUNT) ;
59 switch( i )
60 {
61 case PLAYBACK_REVERSE :
62 direction = direction ? 0 : 1 ; // fall through to next case
63 case PLAYBACK_NEXT :
64 if ( direction ) kbd_key_press(KEY_LEFT);
65 else kbd_key_press(KEY_RIGHT);
66 logic_module_state = LM_KEY_PRESS ;
67 time_stamp = current_time ;
68 break ;
69 case PLAYBACK_LEFT :
70 direction = 0 ;
71 break ;
72 case PLAYBACK_RIGHT :
73 direction = 1 ;
74 break ;
75 default :
76 break ;
77 }
78 break ;
79
80 case LM_KEY_PRESS :
81 if( (current_time - time_stamp) > REMOTE_CLICK_TIME )
82 {
83 if ( direction ) kbd_key_release(KEY_LEFT);
84 else kbd_key_release(KEY_RIGHT);
85 logic_module_state = LM_RELEASE ;
86 }
87 break ;
88
89 default :
90 break ;
91 }
92 }
93
94 /*---------------------------------------------------------------------------------------------------
95 Control Module : Shoot Normal
96 - module to activate camera's half press key on virtual half press and full press key on virtual full press
97 - implements sync as follows :
98 1) one press switch - starts a full shoot on half press so that sync happens on "full press"
99 2) two press switch - does half press action, starts shoot on full press, sync will happen when full press released
100 3) CA-1 - does half press action, starts shoot on full press - sync happens at end of CA-1 150 mSec pulse
101 ---------------------------------------------------------------------------------------------------*/
102
103 void usb_shoot_module_normal()
104 {
105 static AS_ID usb_remote_stack_name = 0;
106
107 if ( conf.synch_enable == 0 ) // handle key presses differently if in sync mode
108 {
109 switch( logic_module_state )
110 {
111 case LM_RESET :
112 kbd_key_release(KEY_SHOOT_FULL);
113 kbd_key_release(KEY_SHOOT_HALF);
114 logic_module_state = LM_RELEASE ;
115 break ;
116 case LM_RELEASE :
117 switch ( virtual_remote_state )
118 {
119 case REMOTE_RELEASE :
120 break ;
121 case REMOTE_HALF_PRESS :
122 kbd_key_press(KEY_SHOOT_HALF);
123 logic_module_state = LM_HALF_PRESS ;
124 break ;
125 case REMOTE_FULL_PRESS:
126 kbd_key_press(KEY_SHOOT_HALF);
127 kbd_key_press(KEY_SHOOT_FULL);
128 logic_module_state = LM_FULL_PRESS ;
129 break ;
130 default :
131 debug_error(INVALID_STATE) ;
132 break ;
133 }
134 break ;
135
136 case LM_HALF_PRESS :
137 switch ( virtual_remote_state )
138 {
139 case REMOTE_RELEASE :
140 kbd_key_release(KEY_SHOOT_HALF);
141 logic_module_state = LM_RELEASE ;
142 break ;
143 case REMOTE_HALF_PRESS :
144 break ;
145 case REMOTE_FULL_PRESS:
146 kbd_key_press(KEY_SHOOT_FULL);
147 logic_module_state = LM_FULL_PRESS ;
148 break ;
149 default :
150 debug_error(INVALID_STATE) ;
151 break ;
152 }
153 break ;
154
155
156 case LM_FULL_PRESS :
157 switch ( virtual_remote_state )
158 {
159 case REMOTE_RELEASE :
160 kbd_key_release(KEY_SHOOT_FULL);
161 kbd_key_release(KEY_SHOOT_HALF);
162 logic_module_state = LM_RELEASE ;
163 break ;
164 case REMOTE_HALF_PRESS:
165 kbd_key_release(KEY_SHOOT_FULL);
166 logic_module_state = LM_HALF_PRESS ;
167 break ;
168 case REMOTE_FULL_PRESS:
169 break ;
170 default :
171 debug_error(INVALID_STATE) ;
172 break ;
173 }
174 break ;
175
176 default :
177 debug_error(INVALID_STATE) ;
178 break ;
179
180 }
181 }
182 else // syncable remote mode
183 {
184 switch( logic_module_state )
185 {
186 case LM_RESET :
187 logic_module_state = LM_RELEASE ;
188 break ;
189
190 case LM_RELEASE :
191 switch ( virtual_remote_state )
192 {
193 case REMOTE_HALF_PRESS :
194 switch ( switch_type)
195 {
196 case SW_ONE_PRESS :
197 usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
198 usb_sync_wait_flag = 1;
199 logic_module_state = LM_HALF_PRESS ;
200 break ;
201 case SW_TWO_PRESS :
202 case SW_RICOH_CA1 :
203 kbd_key_press(KEY_SHOOT_HALF);
204 logic_module_state = LM_HALF_PRESS ;
205 break ;
206 default :
207 break ;
208 }
209 break ;
210
211 case REMOTE_RELEASE :
212 case REMOTE_FULL_PRESS:
213 break ;
214 default :
215 debug_error(INVALID_STATE) ;
216 break ;
217 }
218 break ;
219
220 case LM_HALF_PRESS :
221 switch ( virtual_remote_state )
222 {
223 case REMOTE_FULL_PRESS:
224 switch ( switch_type)
225 {
226 case SW_ONE_PRESS :
227 logic_module_state = LM_FULL_PRESS ;
228 break ;
229 case SW_TWO_PRESS :
230 case SW_RICOH_CA1 :
231 usb_sync_wait_flag = 1;
232 kbd_key_press(KEY_SHOOT_FULL);
233 logic_module_state = LM_FULL_PRESS ;
234 break ;
235 default :
236 break ;
237 }
238 break ;
239 case REMOTE_RELEASE :
240 switch ( switch_type)
241 {
242 case SW_ONE_PRESS :
243 if( action_stack_is_finished(usb_remote_stack_name) )
244 {
245 logic_module_state = LM_RELEASE ;
246 }
247 break ;
248 case SW_TWO_PRESS :
249 case SW_RICOH_CA1 :
250 kbd_key_release(KEY_SHOOT_HALF);
251 logic_module_state = LM_RELEASE ;
252 break ;
253 default :
254 break ;
255 }
256 break ;
257 case REMOTE_HALF_PRESS :
258 break ;
259 default :
260 debug_error(INVALID_STATE) ;
261 break ;
262 }
263 break ;
264
265 case LM_FULL_PRESS :
266 switch ( virtual_remote_state )
267 {
268 case REMOTE_RELEASE :
269 switch ( switch_type)
270 {
271 case SW_ONE_PRESS :
272 if( action_stack_is_finished(usb_remote_stack_name) )
273 {
274 logic_module_state = LM_RELEASE ;
275 }
276 break ;
277 case SW_TWO_PRESS :
278 case SW_RICOH_CA1 :
279 usb_sync_wait_flag = 0;
280 logic_module_state = LM_RELEASE ;
281 kbd_key_release(KEY_SHOOT_FULL);
282 kbd_key_release(KEY_SHOOT_HALF);
283 break ;
284 default :
285 break ;
286 }
287 break ;
288 case REMOTE_HALF_PRESS :
289 case REMOTE_FULL_PRESS:
290 break ;
291 default :
292 debug_error(INVALID_STATE) ;
293 break ;
294 }
295 break ;
296 default :
297 debug_error(INVALID_STATE) ;
298 break ;
299 }
300 }
301
302 };
303
304 /*---------------------------------------------------------------------------------------------------
305 Control Module : Shoot Quick
306 - module to launch "shoot()" on leading edge of either virtual HALF_PRESS or FULL_PRESS
307 - does not support sync
308 ---------------------------------------------------------------------------------------------------*/
309
310 void usb_shoot_module_quick()
311 {
312 static AS_ID usb_remote_stack_name = 0;
313
314 switch( logic_module_state )
315 {
316 case LM_RESET :
317 logic_module_state = LM_RELEASE ;
318 break ;
319 case LM_RELEASE :
320 switch ( virtual_remote_state )
321 {
322 case REMOTE_RELEASE :
323 break ;
324 case REMOTE_HALF_PRESS :
325 case REMOTE_FULL_PRESS:
326 usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
327 logic_module_state = LM_FULL_PRESS ;
328 break ;
329 default :
330 debug_error(INVALID_STATE) ;
331 break ;
332 }
333 break ;
334
335 case LM_FULL_PRESS :
336 if (( virtual_remote_state == REMOTE_RELEASE ) && action_stack_is_finished(usb_remote_stack_name) )
337 {
338 logic_module_state = LM_RELEASE ;
339 }
340 break ;
341
342 default :
343 debug_error(INVALID_STATE) ;
344 break ;
345
346 }
347
348 }
349
350 /*---------------------------------------------------------------------------------------------------
351 Control Module : Shoot Burst
352 - module to launch "shoot()" continuously while virtual HALF_PRESSED is true
353 - refocus & exposure set on each shot - another mode could be added to lock those on first shot
354 - virtual FULL_PRESS is ignored
355 ---------------------------------------------------------------------------------------------------*/
356
357 void usb_shoot_module_burst()
358 {
359 static AS_ID usb_remote_stack_name = 0;
360
361 switch( logic_module_state )
362 {
363 case LM_RESET :
364 logic_module_state = LM_RELEASE ;
365 break ;
366 case LM_RELEASE :
367 switch ( virtual_remote_state )
368 {
369 case REMOTE_RELEASE :
370 break ;
371 case REMOTE_HALF_PRESS :
372 case REMOTE_FULL_PRESS:
373 usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
374 logic_module_state = LM_HALF_PRESS ;
375 break ;
376 default :
377 debug_error(INVALID_STATE) ;
378 break ;
379 }
380 break ;
381 case LM_HALF_PRESS :
382 if( action_stack_is_finished(usb_remote_stack_name) )
383 {
384 logic_module_state = LM_RELEASE ;
385 }
386 break ;
387 default :
388 debug_error(INVALID_STATE) ;
389 break ;
390 }
391
392 }
393
394 /*---------------------------------------------------------------------------------------------------
395 Control Module : Shoot Zoom
396 - module to allow zoom action to be synced between two camera
397 - works with Pulse Count input device
398 - 1 pulse = zoom in
399 - 2 pulses = zoom out
400 - 3 pulses = shoot
401 - 4 pulses = zoom full in
402 - 5 pulses = zoom full out
403 ---------------------------------------------------------------------------------------------------*/
404
405 void usb_zoom_step(int zdirection)
406 {
407 int zpos, zstep, newzpos ;
408 if (!camera_info.state.mode_play)
409 {
410 // currently used zoom_points values are 6 7 8 10 12 14 15 23 64 101 121 126 127 128 129 201
411 if (zoom_points <= 16 ) zstep = 1 ;
412 else if (zoom_points <= 32 ) zstep = 2 ;
413 else if (zoom_points <= 64 ) zstep = 6 ;
414 else if (zoom_points <= 110) zstep = 10 ;
415 else if (zoom_points <= 128) zstep = 12 ;
416 else zstep = 20 ;
417 zpos = shooting_get_zoom();
418 // if new pos less than half a step from end of range, go to end
419 if(zdirection>0)
420 {
421 if(zpos+zstep+zstep/2<zoom_points)
422 {
423 newzpos = zpos+zstep;
424 }
425 else
426 {
427 newzpos = zoom_points;
428 }
429 }
430 else
431 {
432 if(zpos-zstep-zstep/2>0)
433 {
434 newzpos = zpos-zstep;
435 }
436 else
437 {
438 newzpos = 0;
439 }
440 }
441 shooting_set_zoom(newzpos);
442 }
443 }
444
445 void usb_shoot_module_zoom()
446 {
447 static AS_ID usb_remote_stack_name = 0;
448
449 switch( logic_module_state )
450 {
451 case LM_RESET :
452 logic_module_state = LM_RELEASE ;
453 break ;
454 case LM_RELEASE :
455 switch( get_usb_power(LM_PULSE_COUNT) )
456 {
457 case ZOOM_STEP_OUT :
458 usb_zoom_step(1) ;
459 break ;
460 case ZOOM_STEP_IN :
461 usb_zoom_step(-1);
462 break ;
463 case ZOOM_SHOOT :
464 logic_module_state = LM_FULL_PRESS ;
465 usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
466 break ;
467 case ZOOM_FULL_OUT :
468 shooting_set_zoom(zoom_points) ;
469 break ;
470 case ZOOM_FULL_IN :
471 shooting_set_zoom(0) ;
472 break ;
473 default :
474 break ;
475 }
476 break ;
477 case LM_FULL_PRESS :
478 if( action_stack_is_finished(usb_remote_stack_name) )
479 {
480 logic_module_state = LM_RELEASE ;
481 }
482 break ;
483 default :
484 break ;
485 }
486 };
487
488 /*---------------------------------------------------------------------------------------------------
489 Control Module : Shoot Bracketing
490 - module to allow bracketing shots without using camera's timer or continuous modes
491 - focus & exposure on each half press - shoots on full press
492 - times out in 5 seconds after the last full press
493 ---------------------------------------------------------------------------------------------------*/
494 extern void bracketing_step() ;
495 extern void bracketing_reset() ;
496
497 void usb_bracketing_done()
498 {
499 bracketing_reset() ;
500 bracketing_timeout = 0 ;
501 }
502
503
504 void usb_shoot_module_bracketing()
505 {
506 int current_time ;
507
508 current_time = get_tick_count() ;
509
510 switch( logic_module_state )
511 {
512 case LM_RESET :
513 logic_module_state = LM_RELEASE ;
514 break ;
515 case LM_RELEASE :
516 if (( bracketing_timeout ) && ( current_time > bracketing_timeout ) ) usb_bracketing_done() ;
517 switch ( virtual_remote_state )
518 {
519 case REMOTE_RELEASE :
520 break ;
521 case REMOTE_HALF_PRESS :
522 case REMOTE_FULL_PRESS: // Note : need a half-press to setup bracketing step
523 kbd_key_press(KEY_SHOOT_HALF);
524 logic_module_state = LM_HALF_PRESS ;
525 break ;
526 default :
527 debug_error(INVALID_STATE) ;
528 break ;
529 }
530 break ;
531 case LM_HALF_PRESS :
532 switch ( virtual_remote_state )
533 {
534 case REMOTE_RELEASE :
535 kbd_key_release(KEY_SHOOT_HALF);
536 logic_module_state = LM_RELEASE ;
537 usb_bracketing_done() ;
538 break ;
539 case REMOTE_HALF_PRESS :
540 break ;
541 case REMOTE_FULL_PRESS:
542 if ( shooting_in_progress() )
543 {
544 kbd_key_press(KEY_SHOOT_FULL);
545 logic_module_state = LM_FULL_PRESS ;
546 bracketing_timeout = current_time + BRACKETING_TIMEOUT ;
547 }
548 break ;
549 default :
550 debug_error(INVALID_STATE) ;
551 break ;
552 }
553 break ;
554 case LM_FULL_PRESS :
555 switch ( virtual_remote_state )
556 {
557 case REMOTE_RELEASE :
558 kbd_key_release(KEY_SHOOT_FULL_ONLY);
559 kbd_key_release(KEY_SHOOT_HALF);
560 logic_module_state = LM_RELEASE ;
561 bracketing_step(SET_LATER) ;
562 break ;
563 case REMOTE_HALF_PRESS :
564 kbd_key_release(KEY_SHOOT_FULL_ONLY);
565 logic_module_state = LM_HALF_PRESS ;
566 bracketing_step(SET_LATER) ;
567 break ;
568 case REMOTE_FULL_PRESS:
569 break ;
570 default :
571 debug_error(INVALID_STATE) ;
572 break ;
573 }
574 break ;
575 default :
576 debug_error(INVALID_STATE) ;
577 break ;
578 }
579
580 }
581
582 /*---------------------------------------------------------------------------------------------------
583 Control Module : Video
584 - starts video (with sync if selected) on press, stops on next press
585 ---------------------------------------------------------------------------------------------------*/
586
587 void usb_video_module_normal()
588 {
589 int usb_video_button = (camera_info.cam_has_video_button) ? KEY_VIDEO : KEY_SHOOT_FULL;
590
591 switch( logic_module_state )
592 {
593 case LM_RESET :
594 logic_module_state = LM_RELEASE ;
595 break ;
596 case LM_RELEASE :
597 switch ( virtual_remote_state )
598 {
599 case REMOTE_RELEASE :
600 break ;
601 case REMOTE_HALF_PRESS :
602 case REMOTE_FULL_PRESS:
603 kbd_key_press(usb_video_button);
604 logic_module_state = LM_START_RECORD ;
605 break ;
606 default :
607 debug_error(INVALID_STATE) ;
608 break ;
609 }
610 break ;
611 case LM_START_RECORD:
612 switch ( virtual_remote_state )
613 {
614 case REMOTE_RELEASE :
615 logic_module_state = LM_RECORDING ;
616 kbd_key_release(usb_video_button);
617 break ;
618 case REMOTE_HALF_PRESS :
619 case REMOTE_FULL_PRESS:
620 break ;
621 default :
622 debug_error(INVALID_STATE) ;
623 break ;
624 }
625 break;
626 case LM_RECORDING :
627 switch ( virtual_remote_state )
628 {
629 case REMOTE_RELEASE :
630 break ;
631 case REMOTE_HALF_PRESS :
632 case REMOTE_FULL_PRESS:
633 kbd_key_press(usb_video_button);
634 logic_module_state = LM_STOP_RECORDING ;
635 break ;
636 default :
637 debug_error(INVALID_STATE) ;
638 break ;
639 }
640 break;
641 case LM_STOP_RECORDING :
642 switch ( virtual_remote_state )
643 {
644 case REMOTE_RELEASE :
645 logic_module_state = LM_RELEASE ;
646 kbd_key_release(usb_video_button);
647 break ;
648 case REMOTE_HALF_PRESS :
649 case REMOTE_FULL_PRESS:
650 break ;
651 default :
652 debug_error(INVALID_STATE) ;
653 break ;
654 }
655 break;
656 default :
657 debug_error(INVALID_STATE) ;
658 break ;
659 }
660
661 };
662
663
664 /*===================================================================================================
665
666 Control Module Jump Tables
667
668 ===================================================================================================*/
669
670 void usb_null_module(__attribute__ ((unused))int i) { } ; // module that does nothing - useful for unused entries in jump table
671
672
673 // play mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
674
675 void (*usb_module_play[NUM_USB_MODULES])() =
676 {
677 usb_null_module , // [ None]
678 usb_playback_module , // [ Normal]
679 usb_playback_module , // [ Quick]
680 usb_playback_module , // [ Burst]
681 usb_playback_module , // [Bracket]
682 usb_playback_module , // [ Zoom]
683 usb_playback_module , // [ Video]
684 usb_playback_module , // <- insert new playback module here - update NUM_USB_MODULES if necessary
685 usb_playback_module , // --
686 usb_null_module // --
687 };
688
689
690 // shooting mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
691
692 void (*usb_module_shoot[NUM_USB_MODULES])() =
693 {
694 usb_null_module , // [ None]
695 usb_shoot_module_normal , // [ Normal]
696 usb_shoot_module_quick , // [ Quick]
697 usb_shoot_module_burst , // [ Burst]
698 usb_shoot_module_bracketing , // [Bracket]
699 usb_shoot_module_zoom , // [ Zoom]
700 usb_video_module_normal , // [ Video] note : cameras with video button come through here when filming
701 usb_null_module, // <- insert new shoot module here - update NUM_USB_MODULES if necessary
702 usb_null_module, // --
703 usb_null_module // --
704 };
705
706
707 // video mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
708
709 void (*usb_module_video[NUM_USB_MODULES])() =
710 {
711 usb_null_module , // [ None]
712 usb_video_module_normal , // [ Normal]
713 usb_video_module_normal , // [ Quick]
714 usb_null_module , // [ Burst]
715 usb_null_module , // [Bracket]
716 usb_null_module , // [ Zoom]
717 usb_video_module_normal , // [ Video]
718 usb_null_module , // <- insert new video module here - update NUM_USB_MODULES if necessary
719 usb_null_module , // --
720 usb_null_module // --
721 };