static void lock_and_outhole_monitor (void) { /* Wait for balls to settle/amode to start before emptying * locks/outhole */ task_sleep_sec (3); while (!in_live_game) { if (switch_poll (SW_LOCK_LOWER)) { device_request_kick (device_entry (DEVNO_LOCK)); } if (switch_poll (SW_OUTHOLE)) { sol_request (SOL_OUTHOLE); } if (!switch_poll (SW_AUTOFIRE2)) { callset_invoke (clear_autofire); } /* Wait for the balls to be cleared before starting again */ task_sleep_sec (3); } task_exit (); }
/** * Wait for a button to be pressed and released. */ extern inline void wait_for_button (const U8 swno) { /* TODO - why is this not done in native mode? */ #ifndef CONFIG_NO_ACCEPT #ifndef CONFIG_NATIVE while (!switch_poll (swno)) task_sleep (TIME_66MS); while (switch_poll (swno)) task_sleep (TIME_66MS); #endif #else task_sleep (TIME_500MS); #endif }
void io_task ( uint_32 initial_data ) { puts("*****************************\n"); puts("IO Task running\n"); io_init(); /* Run in 100ms loop to read buttons state */ while(1) { /* IO Task is running, wait for timeout */ _time_delay(100); switch_poll(); /* blink by LED1 to signalize io_task is running */ if(timeout == 0) { timeout = 1; ioctl(file_leds, GPIO_IOCTL_WRITE_LOG1, NULL); } else { timeout = 0; ioctl(file_leds, GPIO_IOCTL_WRITE_LOG0, NULL); } } }
CALLSET_ENTRY (plunger, sw_launch_button) { #ifdef INCLUDE_AUTOPLUNGER if (switch_poll (MACHINE_SHOOTER_SWITCH)) { sol_request_async (MACHINE_LAUNCH_SOLENOID); } #endif }
void debug_shell (void) { shell_cursor = 0; for (;;) { if (switch_poll (SW_ESCAPE)) { if (shell_cursor == shell_cmd) { } else { --shell_cursor; } shell_button_finish (); } else if (switch_poll (SW_UP)) { shell_cmd[shell_cursor]++; shell_button_finish (); } else if (switch_poll (SW_DOWN)) { shell_cmd[shell_cursor]--; shell_button_finish (); } else if (switch_poll (SW_ENTER)) { if (shell_ctx[shell_cursor].exec) { } else { shell_cursor++; } shell_button_finish (); } else { switch_periodic (); task_runs_long (); } } }
void print_header (void) { if (print_header_needed == FALSE) return; print_header_needed = FALSE; printer_pageno++; /** * Just before printing the page header, see if the PAUSE EVERY PAGE * setting is on. If so, the user must press Enter before the page * is written. This would be for printers that need paper manually fed * into them. */ if (printer_config.pause_every_page == YES) { dmd_alloc_low_clean (); font_render_string_center (&font_mono5, 64, 11, "PRESS ENTER"); font_render_string_center (&font_mono5, 64, 21, "FOR NEXT PAGE"); dmd_show_low (); while (!switch_poll (SW_ENTER)) task_sleep (TIME_66MS); while (switch_poll (SW_ENTER)) task_sleep (TIME_66MS); } /* Print the actual page header. * Note that we do not use sprintf() here, as that has been * seen to cause stack overflows. We opt for a much simpler * approach whereby the tilde character is substituted with * the real page number. This limits reports to 9 pages. * The proper solution would be to use fork a separate * task to work around the stack size limitation. */ print_string (printout_name); print_line_right ("PAGE ~"); print_nl (); }
void logic_sync_lamps(void) { logic_brake(switch_poll(SWITCH_BRAKE)); logic_lturn(switch_poll(SWITCH_LTURN)); logic_rturn(switch_poll(SWITCH_RTURN)); logic_headlamp(switch_poll(SWITCH_HEADLAMP)); logic_highbeam(switch_poll(SWITCH_HIGHBEAM)); logic_reverse(switch_poll(SWITCH_REVERSE)); }
/** * Debounce a button press, waiting for it to clear. */ U8 button_check (U8 sw) { volatile U16 x; if (!switch_poll (sw)) return 0; for (x=bpt_debounce_timer; x ; --x) { task_runs_long (); barrier (); } switch_periodic (); if (!switch_poll (sw)) { bpt_repeat_count = 0; bpt_debounce_timer = 0x1C00; return 1; } else { bpt_repeat_count++; if (bpt_repeat_count >= 32) { bpt_repeat_count = 32; bpt_debounce_timer = 0x80; return 8; } else if (bpt_repeat_count >= 4) { bpt_debounce_timer = 0x600; return 4; } else return 1; } }
/** * Do a DMD transition. * * Transitions are complicated because the old/new images may have * different color depths (mono or 4-color). Also, we can only map * two pages at a time, but there may be up to 4 different pages * involved. * * First, we check to see if both old and new images are mono. If so, * then the transition can be optimized slightly. * * For debugging transitions, define STEP_TRANSITION. The transition * will take place one frame at a time; use the launch button to * step through each frame. */ void dmd_do_transition (void) { const U8 new_dark_page = dmd_low_page; const U8 new_bright_page = dmd_high_page; dmd_trans_data_ptr = NULL; dmd_trans_data_ptr2 = NULL; page_push (TRANS_PAGE); if (dmd_transition->composite_init) { (*dmd_transition->composite_init) (); dmd_trans_data_ptr2 = dmd_trans_data_ptr; } while (dmd_in_transition) { #if defined(STEP_TRANSITION) && defined(MACHINE_LAUNCH_SWITCH) while (!switch_poll (MACHINE_LAUNCH_SWITCH)) task_sleep (TIME_33MS); task_sleep (TIME_100MS); while (switch_poll (MACHINE_LAUNCH_SWITCH)) task_sleep (TIME_33MS); #else task_sleep (dmd_transition->delay); #endif do { dmd_composite_page = dmd_alloc (); } while ((dmd_composite_page == (new_dark_page & ~1)) || (dmd_composite_page == (new_bright_page & ~1))); /* Handle the transition of the dark page first. * Use the lower composite pair page. */ pinio_dmd_window_set (PINIO_DMD_WINDOW_1, dmd_composite_page); dmd_do_transition_cycle (dmd_dark_page, new_dark_page); /* Handle the transition of the bright page. * Use the upper composite pair page (+1). */ { U8 *tmp_trans_data_ptr; tmp_trans_data_ptr = dmd_trans_data_ptr; dmd_trans_data_ptr = dmd_trans_data_ptr2; pinio_dmd_window_set (PINIO_DMD_WINDOW_1, dmd_composite_page+1); dmd_do_transition_cycle (dmd_bright_page, new_bright_page); dmd_trans_data_ptr2 = dmd_trans_data_ptr; dmd_trans_data_ptr = tmp_trans_data_ptr; } /* Make the composite pages visible */ dmd_dark_page = dmd_composite_page; dmd_bright_page = dmd_composite_page+1; } page_pop (); dmd_transition = NULL; }
/** Return TRUE if the given switch is ACTIVE. This takes into * account whether or not the switch is an opto. */ bool switch_poll_logical (const switchnum_t sw) { return switch_poll (sw) ^ switch_is_opto (sw); }