static void m2i_rename(path_t *path, cbmdirent_t *dent, uint8_t *newname) { uint16_t offset; uint8_t *ptr; set_busy_led(1); /* Locate entry in the M2I file */ offset = dent->pvt.m2i.offset; if (load_entry(path->part, offset)) { update_leds(); return; } /* Re-load the entry because load_entry modifies it */ /* Assume this never fails because load_entry was successful */ image_read(path->part, offset, ops_scratch, M2I_ENTRY_LEN); /* Copy the new filename */ ptr = ops_scratch + M2I_CBMNAME_OFFSET; memset(ptr, ' ', CBM_NAME_LENGTH); while (*newname) *ptr++ = *newname++; /* Write new entry */ image_write(path->part, offset, ops_scratch, M2I_ENTRY_LEN, 1); update_leds(); }
/** * mark_buffer_clean - mark a buffer as clean * @buf: pointer to the buffer * * This function marks the given buffer as clean, tracks * this in active_buffers and turns off the dirty LED if required. */ void mark_buffer_clean(buffer_t *buf) { if (buf->dirty) { buf->dirty = 0; active_buffers -= 16; update_leds(); } }
void main(void) { //WDTCTL = WDTPW + WDTHOLD; // use 1MHz calibrated values DCOCTL = CALDCO_1MHZ; BCSCTL1 = CALBC1_1MHZ; // wdt set as interval //WDTCTL = WDTPW + WDTTMSEL + WDTIS1; // wdt interrupt // IE1 |= WDTIE; // enable global interrupts using intrinsic //__enable_interrupt(); // initialize pins for SPI init(); led_mode = CHASE; colorwipe(clear); // clear led strip //delayMillis(1000); while (1) { //demos(); //check switches check_switches(); //update LEDs update_leds(); } }
void fs_emu_video_after_update() { fs_emu_video_buffer_unlock(); int64_t t = fs_emu_monotonic_time(); if (fs_emu_cursor_is_visible_to() > 0) { if (fs_emu_cursor_is_visible_to() < fs_emu_monotonic_time()) { //fs_log("%lld\n", fs_emu_monotonic_time()); fs_emu_show_cursor(0); } } update_leds(t); update_video_stats_system_video(); if (g_fs_emu_benchmark_start_time) { static int64_t last_report = 0; if (t - last_report > 5000000) { double ttime = ((t - g_fs_emu_benchmark_start_time) / 1000000.0); double sys_fps = g_fs_emu_total_sys_frames / ttime; double emu_fps = g_fs_emu_total_emu_frames / ttime; //fs_log("average fps sys: %0.1f emu: %0.1f\n", sys_fps, emu_fps); printf("average fps sys: %0.1f emu: %0.1f\n", sys_fps, emu_fps); last_report = t; } } }
static void cmd_handler (void) { /* Handle commands and filenames */ if (ieee_data.ieeeflags & COMMAND_RECVD) { # ifdef HAVE_HOTPLUG /* This seems to be a nice point to handle card changes */ if (disk_state != DISK_OK) { set_busy_led(1); /* If the disk was changed the buffer contents are useless */ if (disk_state == DISK_CHANGED || disk_state == DISK_REMOVED) { free_multiple_buffers(FMB_ALL); change_init(); filesystem_init(0); } else { /* Disk state indicated an error, try to recover by initialising */ filesystem_init(1); } update_leds(); } # endif if (ieee_data.secondary_address == 0x0f) { parse_doscommand(); /* Command channel */ } else { datacrc = 0xffff; /* Filename in command buffer */ file_open(ieee_data.secondary_address); } command_length = 0; ieee_data.ieeeflags &= (uint8_t) ~COMMAND_RECVD; } /* COMMAND_RECVD */ /* We're done, clean up unused buffers */ free_multiple_buffers(FMB_UNSTICKY); d64_bam_commit(); }
void on_20ms_event() { pf_on_20_ms_event(); telemetry::filter_pos(); do_heartbeat(); update_leds(); }
/** * mark_buffer_dirty - mark a buffer as dirty * @buf: pointer to the buffer * * This function marks the given buffer as dirty, tracks * this in active_buffers and turns on the dirty LED. */ void mark_buffer_dirty(buffer_t *buf) { if (!buf->dirty) { buf->dirty = 1; active_buffers += 16; update_leds(); } }
int main(void) { init(); while(1) { update_leds(); } return 0; }
void setup() { ps.begin(57600); ps.setPacketHandler(&on_packet_received); FastLED.addLeds<WS2811, DATA_PIN, GRB>(leds, NUM_LEDS); update_leds(); }
//Keyboard main function //Handles all keyboard related tasks void keyboard_main( ) { //Update LEDs if USB in use (bluetooth uses different method) if(!bluefruit_configured()) update_leds(keyboard_leds); uint8_t needs_debounce = 0; // For determining if matrix needs debouncing uint16_t matrix_changed = 0; matrix_scan(); // Now that we have scanned the matrix, determine if any actions need to be done for (uint8_t row = 0; row < NUMROWS; row++) { //Check to see if switches in this row has changed if ((matrix_changed = matrix_rows[row] ^ matrix_last[row])) { //At least one switch has changed in this row needs_debounce = 1; //We need to debounce for (int col = 0; col < NUMCOLS; col++) { //Find out which columns have changed and act if(matrix_changed & ((uint16_t)1<< col)) { //This switch has changed, do whatever the switch was programmed to do if(matrix_rows[row] & ((uint16_t)1<< col)) { //Keydown event key_execute(get_keycode(row,col),KEY_IS_DOWN); //phex(get_keycode(row,col).type); //print(":"); //phex(get_keycode(row,col).code); //print(" key is down\n"); } else { //Keyup event key_execute(get_keycode(row,col),KEY_IS_UP); //phex(get_keycode(row,col).type); //print(":"); //phex(get_keycode(row,col).code); //print(" key is up\n"); } } } matrix_last[row] = matrix_rows[row]; //Row has been dealt with } else { //Nothing has changed, do nothing? } } //Allow switch state to stabilize if an edge is detected. if (needs_debounce) _delay_us(DEBOUNCE_TIME); }
static void update_disk_led() { #ifdef SHOW_DISK_LED static int last_led_status = 0; if (led_status != last_led_status) { update_leds(); last_led_status = led_status; } #endif }
int main(void) { usb_init(); while(!usb_configured()); CPU_PRESCALE(0); MCUCR |= 0x80; MCUCR |= 0x80; // Init keyboard struct pin input_pins[3] = INPUT_PINS; struct pin output_pins[3] = OUTPUT_PINS; for(int i=0; i<3; i++) { *input_pins[i].ddr = *input_pins[i].ddr & ~input_pins[i].bits; *input_pins[i].port = *input_pins[i].port | input_pins[i].bits; *output_pins[i].ddr = *output_pins[i].ddr | output_pins[i].bits; *output_pins[i].port = *output_pins[i].port & ~output_pins[i].bits; } sei(); // Start looping for(;;) { // usb_keyboard_press(KEY_A+name[i], 0); bool test = false; for(uint8_t r = 0, k = 0; r < NUMBER_OF_ROWS; r++) { ROW_PORT = (ROW_PORT & ~ROW_MASK) | row_bits[r]; _delay_us(1); // pull row r; for(uint8_t c = 0; c < NUMBER_OF_COLUMNS; c++, k++) { if( (*column_pins[c].pin & column_pins[c].bit) == 0 ) { // probe column c; usb_keyboard_press(alp_index[r], 0); usb_keyboard_press(num_index[c], 0); usb_keyboard_press(KEY_SPACE, 0); test = true; } } } if(test) usb_keyboard_press(KEY_ENTER, 0); leds = mask - leds; update_leds(leds); _delay_ms(500); } }
void key_init(void) { int i; for (i=0;i<256;i++) keypush[i]=0; /*none key is pressed*/ extended_key_follows=FALSE; update_leds(); raw_key_r=0;raw_key=0; new_key_handler.pm_offset = (int) key_handler; new_key_handler.pm_selector = _go32_my_cs(); _go32_dpmi_get_protected_mode_interrupt_vector(0x9, &old_key_handler); _go32_dpmi_allocate_iret_wrapper(&new_key_handler); _go32_dpmi_set_protected_mode_interrupt_vector(0x9, &new_key_handler); keyboard_handler_replaced = TRUE; }
/** * free_buffer - deallocate a buffer * @buffer: pointer to the buffer structure to mark as free * * This function deallocates the given buffer. If the pointer is NULL, * the buffer is already freed or the buffer is assigned to secondary * address 15 nothing will happen. This function will also update the * two LEDs according to the remaining number of open and writable * buffers. */ void free_buffer(buffer_t *buffer) { if (buffer == NULL) return; if (buffer->secondary == 15) return; if (!buffer->allocated) return; buffer->allocated = 0; if (buffer->dirty) active_buffers -= 16; if (buffer->secondary < BUFFER_SEC_SYSTEM) active_buffers--; update_leds(); }
void update_modifier(struct wskbd_internal *id, u_int type, int toggle, int mask) { if (toggle) { if (type == WSCONS_EVENT_KEY_DOWN) id->t_modifiers ^= mask; } else { if (type == WSCONS_EVENT_KEY_DOWN) id->t_modifiers |= mask; else id->t_modifiers &= ~mask; } if (mask & MOD_ANYLED) update_leds(id); }
static uint8_t eefs_delete(path_t *path, cbmdirent_t *dent) { eefs_error_t res; set_dirty_led(1); repad_filename(dent->name); res = eepromfs_delete(dent->name); translate_error(res); update_leds(); /* check result, can only be not_found or ok */ if (res == EEFS_ERROR_OK) return 1; else return 0; }
int main(void) { CPU_PRESCALE(0); MCUCR |= 0x80; MCUCR |= 0x80; usb_init(); while(!usb_configured()); keyboard_init(); for(uint8_t t=0; t<6; t++) { for(uint8_t r = 0; r < NUMBER_OF_ROWS; r++) { pull_row(r); _delay_us(16); sprintf(tmp_str, "row %02d: ", r); print_S(tmp_str); _delay_ms(5); for(uint8_t c = 0; c < NUMBER_OF_COLUMNS; c++) { bool b = probe_column(c); if(!b) { print_S("0"); } else print_S("1"); } release_rows(); print_S(" "); for(uint8_t c = 0; c < NUMBER_OF_COLUMNS; c++) { bool b = probe_column(c); if(b) { print_S("1"); } else print_S("0"); } print_S("\n"); leds = mask-leds; update_leds(leds); _delay_ms(200); } } EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; TIMSK0 = 0; TIMSK1 = 0; UCSR1B = 0; DDRB = 0; DDRC = 0; DDRD = 0; PORTB = 0; PORTC = 0; PORTD = 0; asm volatile("jmp 0x7000"); }
/* * Put the system to sleep after turning all lights off. */ static void slumber(void) { // disable timer interrupt TIMSK &= ~(1 << OCIE1A); // make sure we are not interrupted anymore _delay_ms(10); // enable PCINT0 PCMSK |= (1<<PCINT0); GIMSK |= (1<<PCIE); // invalidate clock clock.state = INVALID; // turn off the lights update_leds(); set_sleep_mode(SLEEP_MODE_PWR_DOWN); sei(); sleep_mode(); // restore interrupt configuration and reset clock GIMSK &= ~(1<<PCIE); TIMSK |= 1 << OCIE1A; }
main() { // initialize the controller initsystem(); sock_init(); http_init(); tcp_reserveport(80); // set the initial state of the LED's strcpy(led_LED0,"ledon.gif"); ledOut(LED0, ON); strcpy(led_LED1,"ledon.gif"); ledOut(LED1, ON); strcpy(led_LED2,"ledon.gif"); ledOut(LED2, ON); strcpy(led_LED3,"ledon.gif"); ledOut(LED3, ON); // process WEB page requests and update the LED's while (1) { update_leds(); http_handler(); } }
void main() { // initialize the controller brdInit(); sock_init(); http_init(); tcp_reserveport(80); // set the initial state of the LED's strcpy(led_DS4,"ledon.gif"); ledOut(DS4, ON); strcpy(led_DS5,"ledon.gif"); ledOut(DS5, ON); strcpy(led_DS6,"ledoff.gif"); ledOut(DS6, OFF); strcpy(led_DS7,"ledon.gif"); ledOut(DS7, ON); strcpy(led_DS8,"ledon.gif"); ledOut(DS8, ON); // process WEB page requests and update the LED's while (1) { update_leds(); http_handler(); } }
void* eread(void* pv) { int k,i,fd; fd=*((int*)pv); char buf[64]; char* ps[2]={"off","on"}; while(1) { k=read(fd,buf,64); printf("k=%d\n",k); if(k<0) { perror("read"); exit(2); } if(k==0) { printf("no data from aoa\n"); } if(buf[0]==0x41) update_leds(buf[1]-1,buf[2]); if(buf[0]==0x42) update_trigger(buf[1]-1,buf[2]); //if(buf[0]==0x43) update_seek(buf[1]); } }
void run_led_driver() { prep_leds(); switch(led_state) { case led_off: break; case led_start: turn_on(REDLED); break; case led_setup_start: turn_on(REDLED); blink_slow(YELLOWLED); blink_slow(GREENLED1); blink_slow(GREENLED2); break; case led_setup_slave_assoc: turn_on(REDLED); blink_slow(YELLOWLED); turn_on(GREENLED1); blink_slow(GREENLED2); break; case led_setup_slave_found_master: turn_on(REDLED); blink_slow(YELLOWLED); turn_on(GREENLED1); turn_on(GREENLED2); break; case led_setup_master_assoc: turn_on(REDLED); blink_fast(YELLOWLED); turn_on(GREENLED1); turn_on(GREENLED2); break; case led_main_start: turn_on(REDLED); blink_slow(YELLOWLED); blink_slow_sliding(GREENLED1); blink_slow_alternating(GREENLED2); break; case led_main_assoc: turn_on(REDLED); turn_on(YELLOWLED); blink_slow_alternating(GREENLED1); break; case led_main_connected: turn_on(REDLED); turn_on(YELLOWLED); turn_on(GREENLED1); blink_slow(GREENLED2); break; case led_error: blink_slow(REDLED + YELLOWLED + GREENLED1); break; } update_leds(); }
void ieee_mainloop(void) { int16_t cmd = 0; set_error(ERROR_DOSVERSION); ieee_data.bus_state = BUS_IDLE; ieee_data.device_state = DEVICE_IDLE; for(;;) { switch(ieee_data.bus_state) { case BUS_SLEEP: /* BUS_SLEEP */ set_atn_irq(0); ieee_bus_idle(); set_error(ERROR_OK); set_busy_led(0); uart_puts_P(PSTR("ieee.c/sleep ")); set_dirty_led(1); /* Wait until the sleep key is used again */ while (!key_pressed(KEY_SLEEP)) system_sleep(); reset_key(KEY_SLEEP); set_atn_irq(1); update_leds(); ieee_data.bus_state = BUS_IDLE; break; case BUS_IDLE: /* BUS_IDLE */ ieee_bus_idle(); while(IEEE_ATN) { ; /* wait for ATN */ if (key_pressed(KEY_NEXT | KEY_PREV | KEY_HOME)) { change_disk(); } else if (key_pressed(KEY_SLEEP)) { reset_key(KEY_SLEEP); ieee_data.bus_state = BUS_SLEEP; break; } else if (display_found && key_pressed(KEY_DISPLAY)) { display_service(); reset_key(KEY_DISPLAY); } system_sleep(); } if (ieee_data.bus_state != BUS_SLEEP) ieee_data.bus_state = BUS_FOUNDATN; break; case BUS_FOUNDATN: /* BUS_FOUNDATN */ ieee_data.bus_state = BUS_ATNPROCESS; cmd = ieee_getc(); break; case BUS_ATNPROCESS: /* BUS_ATNPROCESS */ if(cmd < 0) { uart_putc('c'); ieee_data.bus_state = BUS_IDLE; break; } else cmd &= 0xFF; uart_puts_p("ATN "); uart_puthex(cmd); uart_putcrlf(); if (cmd == 0x3f) { /* UNLISTEN */ if(ieee_data.device_state == DEVICE_LISTEN) { ieee_data.device_state = DEVICE_IDLE; uart_puts_p("UNLISTEN\r\n"); } ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == 0x5f) { /* UNTALK */ if(ieee_data.device_state == DEVICE_TALK) { ieee_data.device_state = DEVICE_IDLE; uart_puts_p("UNTALK\r\n"); } ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == (0x40 + device_address)) { /* TALK */ uart_puts_p("TALK "); uart_puthex(device_address); uart_putcrlf(); ieee_data.device_state = DEVICE_TALK; /* disk drives never talk immediatly after TALK, so stay idle and wait for a secondary address given by 0x60-0x6f DATA */ ieee_data.bus_state = BUS_IDLE; break; } else if (cmd == (0x20 + device_address)) { /* LISTEN */ ieee_data.device_state = DEVICE_LISTEN; uart_puts_p("LISTEN "); uart_puthex(device_address); uart_putcrlf(); ieee_data.bus_state = BUS_IDLE; break; } else if ((cmd & 0xf0) == 0x60) { /* DATA */ /* 8250LP sends data while ATN is still active, so wait for bus controller to release ATN or we will misinterpret data as a command */ while(!IEEE_ATN); if(ieee_data.device_state == DEVICE_LISTEN) { cmd = ieee_listen_handler(cmd); cmd_handler(); break; } else if (ieee_data.device_state == DEVICE_TALK) { ieee_data.secondary_address = cmd & 0x0f; uart_puts_p("DATA T "); uart_puthex(ieee_data.secondary_address); uart_putcrlf(); if(ieee_talk_handler() == TIMEOUT_ABORT) { ieee_data.device_state = DEVICE_IDLE; } ieee_data.bus_state = BUS_IDLE; break; } else { ieee_data.bus_state = BUS_IDLE; break; } } else if (ieee_data.device_state == DEVICE_IDLE) { ieee_data.bus_state = BUS_IDLE; break; /* ----- if we reach this, we're LISTENer or TALKer ----- */ } else if ((cmd & 0xf0) == 0xe0) { /* CLOSE */ ieee_data.secondary_address = cmd & 0x0f; uart_puts_p("CLOSE "); uart_puthex(ieee_data.secondary_address); uart_putcrlf(); /* Close all buffers if sec. 15 is closed */ if(ieee_data.secondary_address == 15) { free_multiple_buffers(FMB_USER_CLEAN); } else { /* Close a single buffer */ buffer_t *buf; buf = find_buffer (ieee_data.secondary_address); if (buf != NULL) { buf->cleanup(buf); free_buffer(buf); } } ieee_data.bus_state = BUS_IDLE; break; } else if ((cmd & 0xf0) == 0xf0) { /* OPEN */ cmd = ieee_listen_handler(cmd); cmd_handler(); break; } else { /* Command for other device or unknown command */ ieee_data.bus_state = BUS_IDLE; } break; } /* switch */ } /* for() */ }
void key_handler(void) { asm("cli; pusha"); raw_key_r = inportb(0x60); if (extended_key_follows==2) { extended_key_follows=1; /*extended_key_follows==2 is used for PAUSE*/ raw_key_r=0; } else { /*now find the extended scancode of pressed key */ if (extended_key_follows) { key_leave=raw_key_r&0x80; raw_key_r=(raw_key_r & 0x7f) + 0x80; extended_key_follows=0; } else { key_leave=raw_key_r&0x80; switch (raw_key_r) { case 0xe1: extended_key_follows=2; /*start of pause sequence*/ raw_key_r=0; break; case 0xe0: extended_key_follows=1; raw_key_r=0; break; default: raw_key_r=raw_key_r & 0x7f; } } /*key-joystick*/ keypush[raw_key_r]=!key_leave; #ifdef KEYBOARD_EXCLUSIVE k_test=keyforget[raw_key_r] && joy_keyboard; #else k_test=keyforget[raw_key_r]; #endif /*forget scancodes used by keysticks*/ if (joy_keyboard && !ui_is_active && keyforget[raw_key_r]) raw_key_r=0; switch (raw_key_r) { case 0xaa: /*ignore 0xe0 0xaa sent by gray arrows*/ raw_key_r=0; key_leave=0; break; case 0x2a: SHIFT_LEFT = !key_leave; break; case 0x36: SHIFT_RIGHT = !key_leave; break; case 0x38: alt_key = !key_leave; /*ALT KEY*/ if (!alt_key) alt_function = -1; /* no alt function */ break; case 0x1d: case 0x9d: control = !key_leave; break; case 0x41: /*F7*/ if (!key_leave) { joy_keyboard=!joy_keyboard; update_leds(); #ifdef KEYBOARD_EXCLUSIVE if (!joy_keyboard) { /* return all keyboard joysticks to default state */ if (joytypes[0]>=joy_keyset0 && joytypes[0]<=joy_keyset3) { stick0=STICK_CENTRE; trig0=1; } if (joytypes[1]>=joy_keyset0 && joytypes[1]<=joy_keyset3) { stick1=STICK_CENTRE; trig1=1; } if (joytypes[2]>=joy_keyset0 && joytypes[2]<=joy_keyset3) { stick2=STICK_CENTRE; trig2=1; } if (joytypes[3]>=joy_keyset0 && joytypes[3]<=joy_keyset3) { stick3=STICK_CENTRE; trig3=1; } } else { k_test=1; /*force updatate of all keyboard joysticks*/ } #endif } raw_key_r=0; break; case 0x3c: if (!key_leave) key_consol &= ~CONSOL_OPTION; /* OPTION key ON */ else key_consol |= CONSOL_OPTION; /* OPTION key OFF */ break; case 0x3d: if (!key_leave) key_consol &= ~CONSOL_SELECT; /* SELECT key ON */ else key_consol |= CONSOL_SELECT; /* SELECT key OFF */ break; case 0x3e: if (!key_leave) key_consol &= ~CONSOL_START; /* START key ON */ else key_consol |= CONSOL_START; /* START key OFF */ break; } if (k_test) /*keystick key was pressed*/ { for (ki=0;ki<4;ki++) if (keyset_used[ki]) { kstick=STICK_CENTRE; if (keypush[keysets[ki][1]] || keypush[keysets[ki][4]] || keypush[keysets[ki][6]]) kstick&=0xfb; /*left*/ if (keypush[keysets[ki][3]] || keypush[keysets[ki][5]] || keypush[keysets[ki][8]]) kstick&=0xf7; /*right*/ if (keypush[keysets[ki][1]] || keypush[keysets[ki][2]] || keypush[keysets[ki][3]]) kstick&=0xfd; /*down*/ if (keypush[keysets[ki][6]] || keypush[keysets[ki][7]] || keypush[keysets[ki][8]]) kstick&=0xfe; /*up*/ ktrig=keypush[keysets[ki][0]]>0 ? 0:1; if (joytypes[0]==(joy_keyset0+ki)) { stick0=kstick;trig0=ktrig; } else if (joytypes[1]==(joy_keyset0+ki)) { stick1=kstick;trig1=ktrig; } else if (joytypes[2]==(joy_keyset0+ki)) { stick2=kstick;trig2=ktrig; } else if (joytypes[3]==(joy_keyset0+ki)) { stick3=kstick;trig3=ktrig; } } } key_shift = SHIFT_LEFT | SHIFT_RIGHT; raw_key_r=(key_leave?0x200:0)|raw_key_r; if (raw_key_r==0x200) raw_key_r=0; if (raw_key==last_raw_key && raw_key_r!=0) {raw_key=raw_key_r;raw_key_r=0;} } outportb(0x20, 0x20); asm("popa; sti"); }
/* Note: scancodes are a bit changed: raw_key & 0x7f = standard scancode raw_key & 0x80 = 1 if key was preceeded with 0xe0 (like the gray arrows) raw_key & 0x200 = 1 if key was depressed Robert Golias */ int Atari_Keyboard(void) { int i; int keycode; int shift_mask; last_raw_key=raw_key; /* * Trigger and Joystick handling should * be moved into the Keyboard Interrupt Routine - done for keyboard-emulated joysticks */ if (joy_in) { read_joystick(js0_centre_x, js0_centre_y); /* read real PC joystick */ if (joytypes[0]==joy_analog) { stick0=astick; trig0=atrig; } if (joytypes[1]==joy_analog) { stick1=astick; trig1=atrig; } if (joytypes[2]==joy_analog) { stick2=astick; trig2=atrig; } if (joytypes[3]==joy_analog) { stick3=astick; trig3=atrig; } } /* read LPT joysticks */ for (i=0;i<4;i++) if (joytypes[i]>=joy_lpt1 && joytypes[i]<=joy_lpt3) read_LPTjoy(lptport[i],i); /* * This needs a bit of tidying up - array lookup */ /* Atari5200 stuff */ if (machine_type == MACHINE_5200 && !ui_is_active) { switch (raw_key) { case 0x3b: keycode = AKEY_UI; break; case 0x3f: /* F5 */ keycode = AKEY_COLDSTART; /* 5200 has no warmstart */ break; case 0x44: /* F10 */ if (!norepkey) { keycode = key_shift ? AKEY_SCREENSHOT_INTERLACE : AKEY_SCREENSHOT; norepkey=TRUE; }else keycode = AKEY_NONE; break; case 0x43: keycode = AKEY_EXIT; break; case 0x02: keycode = 0x3f; break; case 0x03: keycode = 0x3d; break; case 0x04: keycode = 0x3b; break; case 0x0D: keycode = 0x23; /* = = * */ break; case 0x05: keycode = 0x37; break; case 0x06: keycode = 0x35; break; case 0x07: keycode = 0x33; break; case 0x08: keycode = 0x2f; break; case 0x09: keycode = 0x2d; break; case 0x0C: keycode = 0x27; /* - = * */ break; case 0x0a: keycode = 0x2b; break; case 0x0b: keycode = 0x25; break; case 0x3e: /* 1f : */ keycode = 0x39; /* start */ break; case 0x19: keycode = 0x31; /* pause */ break; case 0x13: keycode = 0x29; /* reset */ break; case 0x42: /* F8 */ if (!norepkey) { keycode = Atari_Exit(1) ? AKEY_NONE : AKEY_EXIT; /* invoke monitor */ norepkey = TRUE; } else keycode = AKEY_NONE; break; default: keycode = AKEY_NONE; norepkey = FALSE; break; } if (raw_key_r!=0) {raw_key=raw_key_r;raw_key_r=0;} return keycode; } /* preinitialize of keycode */ shift_mask = key_shift ? 0x40 : 0; keycode = shift_mask | (control ? 0x80 : 0); switch (raw_key) { case 0x3b: /* F1 */ if (control) { PC_keyboard = TRUE; /* PC keyboard mode (default) */ keycode = AKEY_NONE; update_leds(); } else if (key_shift) { PC_keyboard = FALSE; /* Atari keyboard mode */ keycode = AKEY_NONE; update_leds(); } else keycode = AKEY_UI; break; case 0xCF: /* gray END*/ if (!norepkey) { keycode = AKEY_BREAK; norepkey = TRUE; } else keycode = AKEY_NONE; break; case 0x44: /* F10 */ if (!norepkey) { keycode = key_shift ? AKEY_SCREENSHOT_INTERLACE : AKEY_SCREENSHOT; norepkey = TRUE; } else keycode = AKEY_NONE; break; case 0x3f: /* F5 */ keycode = key_shift ? AKEY_COLDSTART : AKEY_WARMSTART; break; case 0x40: /* F6 */ if (machine_type != MACHINE_XLXE) keycode = AKEY_PIL; else keycode = AKEY_HELP; break; case 0x42: /* F8 */ if (!norepkey && !ui_is_active) { keycode = Atari_Exit(1) ? AKEY_NONE : AKEY_EXIT; /* invoke monitor */ norepkey = TRUE; } else keycode = AKEY_NONE; break; case 0x43: /* F9 */ keycode = AKEY_EXIT; break; case 0x57: /* F11 */ keycode = AKEY_NONE; for(i = 0; i < 4; i++) { if (++joy_autofire[i] > 2) joy_autofire[i] = 0; } raw_key = 0; /* aviod continuous change */ break; case 0x01: keycode |= AKEY_ESCAPE; break; case 0xD0: case 0x50: if (PC_keyboard) keycode = AKEY_DOWN; else { keycode |= AKEY_EQUAL; keycode ^= shift_mask; } break; case 0xCB: case 0x4b: if (PC_keyboard) keycode = AKEY_LEFT; else { keycode |= AKEY_PLUS; keycode ^= shift_mask; } break; case 0xCD: case 0x4d: if (PC_keyboard) keycode = AKEY_RIGHT; else { keycode |= AKEY_ASTERISK; keycode ^= shift_mask; } break; case 0xC8: case 0x48: if (PC_keyboard) keycode = AKEY_UP; else { keycode |= AKEY_MINUS; keycode ^= shift_mask; } break; case 0x29: /* "`" key on top-left */ keycode |= AKEY_ATARI; /* Atari key (inverse video) */ break; case 0x3a: keycode |= AKEY_CAPSTOGGLE; /* Caps key */ break; case 0x02: keycode |= AKEY_1; /* 1 */ break; case 0x03: if (!PC_keyboard) keycode |= AKEY_2; else if (key_shift) keycode = AKEY_AT; else keycode |= AKEY_2; /* 2,@ */ break; case 0x04: keycode |= AKEY_3; /* 3 */ break; case 0x05: keycode |= AKEY_4; /* 4 */ break; case 0x06: keycode |= AKEY_5; /* 5 */ break; case 0x07: if (!PC_keyboard) keycode |= AKEY_6; else if (key_shift) keycode = AKEY_CIRCUMFLEX; /* 6,^ */ else keycode |= AKEY_6; break; case 0x08: if (!PC_keyboard) keycode |= AKEY_7; else if (key_shift) keycode = AKEY_AMPERSAND; /* 7,& */ else keycode |= AKEY_7; break; case 0x09: if (!PC_keyboard) keycode |= AKEY_8; else if (key_shift) keycode = AKEY_ASTERISK; /* 8,* */ else keycode |= AKEY_8; break; case 0x0a: if (!PC_keyboard) keycode |= AKEY_9; else if (key_shift) keycode = AKEY_PARENLEFT; else keycode |= AKEY_9; /* 9,( */ break; case 0x0b: if (!PC_keyboard) keycode |= AKEY_0; else if (key_shift) keycode = AKEY_PARENRIGHT; /* 0,) */ else keycode |= AKEY_0; break; case 0x0c: if (!PC_keyboard) keycode |= AKEY_LESS; else if (key_shift) keycode = AKEY_UNDERSCORE; else keycode |= AKEY_MINUS; break; case 0x0d: if (!PC_keyboard) keycode |= AKEY_GREATER; else if (key_shift) keycode = AKEY_PLUS; else keycode |= AKEY_EQUAL; break; case 0x0e: keycode |= AKEY_BACKSPACE; break; case 0x0f: keycode |= AKEY_TAB; break; case 0x10: keycode |= AKEY_q; break; case 0x11: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_SOUND_RECORDING; /* ALT+W .. Select system */ } else keycode |= AKEY_w; break; case 0x12: keycode |= AKEY_e; break; case 0x13: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_RUN; /* ALT+R .. Run file */ } else keycode |= AKEY_r; break; case 0x14: keycode |= AKEY_t; break; case 0x15: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_SYSTEM; /* ALT+Y .. Select system */ } else keycode |= AKEY_y; break; case 0x16: keycode |= AKEY_u; break; case 0x17: keycode |= AKEY_i; break; case 0x18: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_SOUND; /* ALT+O .. mono/stereo sound */ } else keycode |= AKEY_o; break; case 0x19: keycode |= AKEY_p; break; case 0x1a: if (!PC_keyboard) keycode |= AKEY_MINUS; else if (control | key_shift) keycode |= AKEY_UP; else keycode = AKEY_BRACKETLEFT; break; case 0x1b: if (!PC_keyboard) keycode |= AKEY_EQUAL; else if (control | key_shift) keycode |= AKEY_DOWN; else keycode = AKEY_BRACKETRIGHT; break; case 0x9c: case 0x1c: keycode |= AKEY_RETURN; break; case 0x1e: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_ABOUT; /* ALT+A .. About */ } else keycode |= AKEY_a; break; case 0x1f: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_SAVESTATE; /* ALT+S .. Save state */ } else keycode |= AKEY_s; break; case 0x20: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_DISK; /* ALT+D .. Disk management */ } else keycode |= AKEY_d; break; case 0x21: keycode |= AKEY_f; break; case 0x22: keycode |= AKEY_g; break; case 0x23: keycode |= AKEY_h; break; case 0x24: keycode |= AKEY_j; break; case 0x25: keycode |= AKEY_k; break; case 0x26: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_LOADSTATE; /* ALT+L .. Load state */ } else keycode |= AKEY_l; break; case 0x27: keycode |= AKEY_SEMICOLON; break; case 0x28: if (!PC_keyboard) keycode |= AKEY_PLUS; else if (key_shift) keycode = AKEY_DBLQUOTE; else keycode = AKEY_QUOTE; break; case 0x2b: /* PC key "\,|" */ case 0x56: /* PC key "\,|" */ if (!PC_keyboard) keycode |= AKEY_ASTERISK; else if (key_shift) keycode = AKEY_BAR; else keycode |= AKEY_BACKSLASH; break; case 0x2c: keycode |= AKEY_z; break; case 0x2d: keycode |= AKEY_x; break; case 0x2e: if (alt_key) { keycode = AKEY_UI; alt_function = MENU_CARTRIDGE; /* ALT+C .. Cartridge management */ } else keycode |= AKEY_c; break; case 0x2f: keycode |= AKEY_v; break; case 0x30: keycode |= AKEY_b; break; case 0x31: keycode |= AKEY_n; break; case 0x32: keycode |= AKEY_m; break; case 0x33: if (!PC_keyboard) keycode |= AKEY_COMMA; else if (key_shift && !control) keycode = AKEY_LESS; else keycode |= AKEY_COMMA; break; case 0x34: if (!PC_keyboard) keycode |= AKEY_FULLSTOP; else if (key_shift && !control) keycode = AKEY_GREATER; else keycode |= AKEY_FULLSTOP; break; case 0x35: keycode |= AKEY_SLASH; break; case 0x39: keycode |= AKEY_SPACE; break; case 0xc7: /* HOME key */ keycode |= 118; /* clear screen */ break; case 0xd2: /* INSERT key */ if (key_shift) keycode = AKEY_INSERT_LINE; else keycode = AKEY_INSERT_CHAR; break; case 0xd3: /* DELETE key */ if (key_shift) keycode = AKEY_DELETE_LINE; else keycode = AKEY_DELETE_CHAR; break; default: keycode = AKEY_NONE; norepkey = FALSE; break; } if (raw_key_r!=0) {raw_key=raw_key_r;raw_key_r=0;} return keycode; }
int main(void) { uint8_t button; mode_t mode = MODE_OFF; mode_t next_mode = MODE_OFF; uint8_t up_time = 0; uint8_t down_time = 0; uint8_t time = 0; init_hardware(); leds[GREEN_LED].state = LED_OFF; leds[GREEN_LED].on_time = 31; leds[GREEN_LED].off_time = 31; leds[RED_LED].state = LED_HIZ; while (1) { button = poll_button(); if (button & 2) { if (down_time < 255) { down_time++; } up_time = 0; } else { if (up_time < 255) { up_time++; } down_time = 0; } if (time < 255) { time++; } // Button pressed if (button == 1) { if (mode != MODE_OFF && up_time >= 62) { next_mode = MODE_OFF; } else if (mode < MODE_CYCLE_END) { next_mode = mode + 1; if (next_mode == MODE_CYCLE_END) { next_mode = MODE_OFF; } } else { next_mode = MODE_OFF; } } // Button held if (down_time >= 37) { switch (mode) { case MODE_CYCLE_LEVEL1: next_mode = MODE_HOLD_BLINKY; break; case MODE_CYCLE_LEVEL2: next_mode = MODE_PERSIST_BLINKY; break; default: break; } } // Button released if (button == 2 && mode > MODE_PERSIST_END) { next_mode = MODE_OFF; } if (poll_temp() >= OVERTEMP) { if (mode > MODE_CYCLE_LEVEL2) { next_mode = MODE_CYCLE_LEVEL2; } else if (next_mode > MODE_CYCLE_LEVEL2) { next_mode = MODE_OFF; } } if (next_mode != mode) { mode = next_mode; set_power(mode); switch (mode) { case MODE_OFF: set_light(0); break; case MODE_CYCLE_LEVEL1: set_light(50); break; case MODE_CYCLE_LEVEL2: set_light(250); break; case MODE_CYCLE_LEVEL3: set_light(1000); break; case MODE_CYCLE_LEVEL4: set_light(1500); break; case MODE_CYCLE_LEVEL5: set_light(2000); break; case MODE_PERSIST_BLINKY: case MODE_HOLD_BLINKY: time = 0; set_light(2000); break; default: mode = MODE_OFF; break; } } switch (mode) { case MODE_PERSIST_BLINKY: case MODE_HOLD_BLINKY: if (time >= 24) { set_light(2000); time = 0; } else if (time >= 8) { set_light(0); } break; default: break; } switch (poll_charger()) { case CHARGE_SHUTDOWN: leds[GREEN_LED].state = LED_OFF; break; case CHARGE_CHARGING: leds[GREEN_LED].state |= LED_FLASH; break; case CHARGE_FINISHED: leds[GREEN_LED].state = LED_ON; break; } update_leds(); sleep(); } return 0; }
static READ8_HANDLER( supercon_port3_r ) { supercon_state *state = space->machine().driver_data<supercon_state>(); int i; UINT8 key_data=0; static const char *const status_lines[8] = { "STATUS_1", "STATUS_2", "STATUS_3", "STATUS_4", "STATUS_5", "STATUS_6", "STATUS_7", "STATUS_8" }; LOG(("Read from %04x \n",0x1E00)); /* remove last bit (only if it was not already set) */ if ( state->m_data_1F00 & LED_LINE_AH ) { if (state->m_last_LED_value != state->m_LED_AH) state->m_LED_AH=state->m_LED_AH & ~state->m_data_1E00; } else if ( state->m_data_1F00 & LED_LINE_ST) { if (state->m_last_LED_value != state->m_LED_ST) state->m_LED_ST=state->m_LED_ST & ~state->m_data_1E00; } else if ( state->m_data_1F00 & LED_LINE_18 ) { if (state->m_last_LED_value != state->m_LED_18) state->m_LED_18=state->m_LED_18 & ~state->m_data_1E00; } LOG(("LED_18 from %02x \n",state->m_LED_18)); LOG(("LED_AH from %02x \n",state->m_LED_AH)); LOG(("LED_ST from %02x \n",state->m_LED_ST)); if (state->m_led_update) /*No LED Update if Port 1C00,1D00 was read */ update_leds(state); state->m_remove_led_flag=TRUE; state->m_led_update=TRUE; state->m_LED_18=0; state->m_LED_AH=0; state->m_LED_ST=0; /* Start */ if (!state->m_emu_started) return 0xbf; else state->m_timer_update_irq->adjust( attotime::zero, 0, attotime::from_hz(598) ); //HACK adjust timer after start ??? /* Buttons */ i=get_first_bit(state->m_data_1E00); if (i==NOT_VALID) return 0xff; key_data=input_port_read(space->machine(), status_lines[i]); if (key_data != 0xc0) { LOG(("%s, key_data: %02x \n",status_lines[i],key_data)); /* Button: New Game -> initialize board */ if (i==0 && key_data==0x80) { set_board(state); set_pieces(state); state->m_emu_started=FALSE; } /* Button: Clear Board -> remove all pieces */ if (i==3 && key_data==0x80) clear_pieces(state); if (key_data != 0xff ) return key_data; } return 0xc0; }
static void unicast_sent(struct unicast_conn *c, int status, int num_tx){ update_leds(); }
static void broadcast_sent(struct broadcast_conn *c, int status, int num_tx) { update_leds(); }
int main (void) { double t; int i, word, x, y; const TWordPos *w; TRGB color, *p; /* Initialize GPIO (sets up clock) */ GPIOInit (); /* Set LED port pin to output */ GPIOSetDir (LED_PORT, LED_PIN0, 1); GPIOSetValue (LED_PORT, LED_PIN0, LED_OFF); /* Init Power Management Routines */ pmu_init (); /* setup SPI chipselect pin */ spi_init (); spi_init_pin (SPI_CS_RGB); /* transmit image */ t = 0; word = 0; while(1) { /* set background to red */ memset(g_data, g_cie[0x00], sizeof(g_data)); for(y=0; y<LED_Y; y++) for(x=0; x<LED_X; x++) { g_data[y][x].r = g_cie[0x16]; g_data[y][x].g = g_cie[0x0B]; } /* get next word */ i = g_sentence[word/DELAY]; word++; if(word>=(WORD_COUNT*DELAY)) word=0; if(i>=0) { w = &g_words[i]; for(i=0; i<w->length; i++) { /* word coordinates */ x = w->x + i; y = w->y; /* update color */ color.r = (sin( x*0.1+cos(y*0.1+t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2; color.g = (cos(-y*0.2-sin(x*0.3-t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2; color.b = (cos( x*0.5-cos(y*0.4+t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2; p = &g_data[y][x]; p->r = g_cie[color.r]; p->g = g_cie[color.g]; p->b = g_cie[color.b]; } } /* send data */ update_leds(); pmu_wait_ms(1); t+=0.01; } }