CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
usb_module.c-Dateireferenz
#include "camera_info.h"
#include "stdlib.h"
#include "clock.h"
#include "shooting.h"
#include "keyboard.h"
#include "conf.h"
#include "action_stack.h"
#include "usb_remote.h"
+ Include-Abhängigkeitsdiagramm für usb_module.c:

gehe zum Quellcode dieser Datei

Funktionen

void debug_error (int)
 
void usb_playback_module ()
 
void usb_shoot_module_normal ()
 
void usb_shoot_module_quick ()
 
void usb_shoot_module_burst ()
 
void usb_zoom_step (int zdirection)
 
void usb_shoot_module_zoom ()
 
void bracketing_step ()
 
void bracketing_reset ()
 
void usb_bracketing_done ()
 
void usb_shoot_module_bracketing ()
 
void usb_video_module_normal ()
 
void usb_null_module (int i)
 

Variablen

void(* usb_module_play [NUM_USB_MODULES])()
 
void(* usb_module_shoot [NUM_USB_MODULES])()
 
void(* usb_module_video [NUM_USB_MODULES])()
 

Dokumentation der Funktionen

void bracketing_reset ( )

Definiert in Zeile 1449 der Datei shooting.c.

void bracketing_step ( )
void debug_error ( int  )

Definiert in Zeile 76 der Datei usb_remote.c.

77 {
78 }
void usb_bracketing_done ( )

Definiert in Zeile 497 der Datei usb_module.c.

498 {
499  bracketing_reset() ;
500  bracketing_timeout = 0 ;
501 }
void usb_null_module ( int  i)

Definiert in Zeile 670 der Datei usb_module.c.

670 { } ; // module that does nothing - useful for unused entries in jump table
void usb_playback_module ( )

Definiert in Zeile 44 der Datei usb_module.c.

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 :
56  break ;
57  case LM_RELEASE :
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);
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);
86  }
87  break ;
88 
89  default :
90  break ;
91  }
92 }
void usb_shoot_module_bracketing ( )

Definiert in Zeile 504 der Datei usb_module.c.

505 {
506  int current_time ;
507 
508  current_time = get_tick_count() ;
509 
510  switch( logic_module_state )
511  {
512  case LM_RESET :
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
525  break ;
526  default :
528  break ;
529  }
530  break ;
531  case LM_HALF_PRESS :
532  switch ( virtual_remote_state )
533  {
534  case REMOTE_RELEASE :
538  break ;
539  case REMOTE_HALF_PRESS :
540  break ;
541  case REMOTE_FULL_PRESS:
542  if ( shooting_in_progress() )
543  {
546  bracketing_timeout = current_time + BRACKETING_TIMEOUT ;
547  }
548  break ;
549  default :
551  break ;
552  }
553  break ;
554  case LM_FULL_PRESS :
555  switch ( virtual_remote_state )
556  {
557  case REMOTE_RELEASE :
562  break ;
563  case REMOTE_HALF_PRESS :
567  break ;
568  case REMOTE_FULL_PRESS:
569  break ;
570  default :
572  break ;
573  }
574  break ;
575  default :
577  break ;
578  }
579 
580 }
void usb_shoot_module_burst ( )

Definiert in Zeile 357 der Datei usb_module.c.

358 {
359  static AS_ID usb_remote_stack_name = 0;
360 
361  switch( logic_module_state )
362  {
363  case LM_RESET :
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);
375  break ;
376  default :
378  break ;
379  }
380  break ;
381  case LM_HALF_PRESS :
382  if( action_stack_is_finished(usb_remote_stack_name) )
383  {
385  }
386  break ;
387  default :
389  break ;
390  }
391 
392 }
void usb_shoot_module_normal ( )

Definiert in Zeile 103 der Datei usb_module.c.

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 :
115  break ;
116  case LM_RELEASE :
117  switch ( virtual_remote_state )
118  {
119  case REMOTE_RELEASE :
120  break ;
121  case REMOTE_HALF_PRESS :
124  break ;
125  case REMOTE_FULL_PRESS:
129  break ;
130  default :
132  break ;
133  }
134  break ;
135 
136  case LM_HALF_PRESS :
137  switch ( virtual_remote_state )
138  {
139  case REMOTE_RELEASE :
142  break ;
143  case REMOTE_HALF_PRESS :
144  break ;
145  case REMOTE_FULL_PRESS:
148  break ;
149  default :
151  break ;
152  }
153  break ;
154 
155 
156  case LM_FULL_PRESS :
157  switch ( virtual_remote_state )
158  {
159  case REMOTE_RELEASE :
163  break ;
164  case REMOTE_HALF_PRESS:
167  break ;
168  case REMOTE_FULL_PRESS:
169  break ;
170  default :
172  break ;
173  }
174  break ;
175 
176  default :
178  break ;
179 
180  }
181  }
182  else // syncable remote mode
183  {
184  switch( logic_module_state )
185  {
186  case LM_RESET :
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;
200  break ;
201  case SW_TWO_PRESS :
202  case SW_RICOH_CA1 :
205  break ;
206  default :
207  break ;
208  }
209  break ;
210 
211  case REMOTE_RELEASE :
212  case REMOTE_FULL_PRESS:
213  break ;
214  default :
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 :
228  break ;
229  case SW_TWO_PRESS :
230  case SW_RICOH_CA1 :
231  usb_sync_wait_flag = 1;
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  {
246  }
247  break ;
248  case SW_TWO_PRESS :
249  case SW_RICOH_CA1 :
252  break ;
253  default :
254  break ;
255  }
256  break ;
257  case REMOTE_HALF_PRESS :
258  break ;
259  default :
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  {
275  }
276  break ;
277  case SW_TWO_PRESS :
278  case SW_RICOH_CA1 :
279  usb_sync_wait_flag = 0;
283  break ;
284  default :
285  break ;
286  }
287  break ;
288  case REMOTE_HALF_PRESS :
289  case REMOTE_FULL_PRESS:
290  break ;
291  default :
293  break ;
294  }
295  break ;
296  default :
298  break ;
299  }
300  }
301 
302 };
void usb_shoot_module_quick ( )

Definiert in Zeile 310 der Datei usb_module.c.

311 {
312  static AS_ID usb_remote_stack_name = 0;
313 
314  switch( logic_module_state )
315  {
316  case LM_RESET :
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);
328  break ;
329  default :
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  {
339  }
340  break ;
341 
342  default :
344  break ;
345 
346  }
347 
348 }
void usb_shoot_module_zoom ( )

Definiert in Zeile 445 der Datei usb_module.c.

446 {
447  static AS_ID usb_remote_stack_name = 0;
448 
449  switch( logic_module_state )
450  {
451  case LM_RESET :
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 :
465  usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
466  break ;
467  case ZOOM_FULL_OUT :
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  {
481  }
482  break ;
483  default :
484  break ;
485  }
486 };
void usb_video_module_normal ( )

Definiert in Zeile 587 der Datei usb_module.c.

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 :
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);
605  break ;
606  default :
608  break ;
609  }
610  break ;
611  case LM_START_RECORD:
612  switch ( virtual_remote_state )
613  {
614  case REMOTE_RELEASE :
616  kbd_key_release(usb_video_button);
617  break ;
618  case REMOTE_HALF_PRESS :
619  case REMOTE_FULL_PRESS:
620  break ;
621  default :
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);
635  break ;
636  default :
638  break ;
639  }
640  break;
641  case LM_STOP_RECORDING :
642  switch ( virtual_remote_state )
643  {
644  case REMOTE_RELEASE :
646  kbd_key_release(usb_video_button);
647  break ;
648  case REMOTE_HALF_PRESS :
649  case REMOTE_FULL_PRESS:
650  break ;
651  default :
653  break ;
654  }
655  break;
656  default :
658  break ;
659  }
660 
661 };
void usb_zoom_step ( int  zdirection)

Definiert in Zeile 405 der Datei usb_module.c.

406 {
407  int zpos, zstep, newzpos ;
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 }

Variablen-Dokumentation

void(* usb_module_video[NUM_USB_MODULES])()