//---------------------------------------------------------- // SFI EXCEPTION HANDLER //---------------------------------------------------------- void sfi_jmptbl_exception() { uint16_t val; uint8_t ledcnt; ker_led(LED_RED_ON); ker_led(LED_GREEN_OFF); ker_led(LED_YELLOW_OFF); val = 0xffff; ledcnt = 0; while (1){ #ifndef DISABLE_WDT watchdog_reset(); #endif if (val == 0){ switch (ledcnt){ case 0: ker_led(LED_RED_TOGGLE); ker_led(LED_GREEN_TOGGLE); break; case 1: ker_led(LED_GREEN_TOGGLE); ker_led(LED_YELLOW_TOGGLE); break; case 2: ker_led(LED_YELLOW_TOGGLE); ker_led(LED_RED_TOGGLE); break; default: break; } ledcnt++; if (ledcnt == 3) ledcnt = 0; } val--; } return; }
void watchdog_timer_device::device_reset() { // set up the watchdog timer; only start off enabled if explicitly configured m_enabled = (m_vblank_count != 0 || m_time != attotime::zero); watchdog_reset(); m_enabled = true; }
void sfi_exception(uint8_t errcode) { uint8_t clrdisp; uint16_t val; val = 0xffff; sfi_err_code_led_display(errcode); clrdisp = 0; while (1){ #ifndef DISABLE_WDT watchdog_reset(); #endif if (val == 0){ if (clrdisp){ sfi_err_code_led_display(errcode); clrdisp = 0; } else { sfi_err_code_led_display(0); clrdisp = 1; } } val--; } return; }
static void watchdog_internal_reset(running_machine &machine) { /* set up the watchdog timer; only start off enabled if explicitly configured */ watchdog_enabled = (machine.m_config.m_watchdog_vblank_count != 0 || machine.m_config.m_watchdog_time != attotime::zero); watchdog_reset(&machine); watchdog_enabled = TRUE; }
static void watchdog_internal_reset(running_machine *machine) { /* set up the watchdog timer; only start off enabled if explicitly configured */ watchdog_enabled = (machine->config->watchdog_vblank_count != 0 || attotime_compare(machine->config->watchdog_time, attotime_zero) != 0); watchdog_reset(machine); watchdog_enabled = TRUE; }
void run_electronics_test() { cli(); //Disable times and PWM, except for timer5, which controls the motor current PWM levels. TCCR1A = 0; TCCR2A = 0; TCCR3A = 0; TCCR4A = 0; uint8_t idx = 0; char command_buffer[32]; send_P(PSTR("TEST\r\n")); while(true) { watchdog_reset(); if (UCSR0A & _BV(RXC0)) { uint8_t recv = UDR0; if (recv == '\n' || recv == '\r') { command_buffer[idx] = 0; idx = 0; handleCommand(command_buffer); } else { command_buffer[idx++] = recv; } } } }
static WRITE16_HANDLER( unk880000_w ) { tecmosys_state *state = space->machine().driver_data<tecmosys_state>(); COMBINE_DATA(&state->m_880000regs[offset]); switch( offset ) { case 0x00/2: break; // global x scroll for sprites? case 0x02/2: break; // global y scroll for sprites case 0x08/2: state->m_spritelist = data & 0x3; // which of the 4 spritelists to use (buffering) break; case 0x22/2: watchdog_reset( space->machine() ); //logerror( "watchdog_w( %06x, %04x ) @ %06x\n", (offset * 2)+0x880000, data, cpu_get_pc(&space->device()) ); break; default: logerror( "unk880000_w( %06x, %04x ) @ %06x\n", (offset * 2)+0x880000, data, cpu_get_pc(&space->device()) ); break; } }
void bsp_reset( void) { watchdog_reset(); while (true) { /* Do nothing */ } }
//========================================================================================== // pmbus_write_rom_mode() // Erases the program integrity word in FLASH, then waits for watchdog timer to reset the // CPU. There is no return code or return from this function. //========================================================================================== int32 pmbus_write_rom_mode(void) { clear_integrity_word(); // Call a SWI to clear the integrity word. watchdog_reset(); // Wait for watchdog to expire and force CPU reset. return PMBUS_SUCCESS; // Note: This line is never reached. }
AM_RANGE(0xe800, 0xffff) AM_ROM ADDRESS_MAP_END static WRITE8_DEVICE_HANDLER( watchdog_w ) { watchdog_reset(device->machine()); }
static WRITE16_HANDLER(io_w) { switch(offset) { case 2: watchdog_reset(space->machine); break; default: logerror("IO W %x %x %x\n", offset, data, mem_mask); } }
void running_machine::watchdog_enable(bool enable) { // when re-enabled, we reset our state if (m_watchdog_enabled != enable) { m_watchdog_enabled = enable; watchdog_reset(); } }
void watchdog_enable(running_machine *machine, int enable) { /* when re-enabled, we reset our state */ if (watchdog_enabled != enable) { watchdog_enabled = enable; watchdog_reset(machine); } }
void idler() { /* Debug code. Look at P3.0 on an oscilloscope to * measure main loop period, to get an idea of max * latency for things serviced from here. */ P3_0 = !P3_0; watchdog_reset(); }
void watchdog_timer_device::watchdog_enable(bool enable) { // when re-enabled, we reset our state if (m_enabled != enable) { m_enabled = enable; watchdog_reset(); } }
/* disable watchdog time, mainly to save power */ void watchdog_disable(void) { wdt_disable(); } #else /* !WITH_WATCHDOG */ #define watchdog_start() ((void)0) #define watchdog_reset() ((void)0) #define watchdog_disable() ((void)0) #endif /* WITH_WATCHDOG */ #ifdef HAS_LCD static void print_idle(void) { uint8_t station_id[STATION_ID_BYTES]; eeprom_read_station_id(station_id); lcd_puts(0, "Base Station"); lcd_print_hex(1, station_id, sizeof(station_id)); } #else /* !HAS_LCD */ #define print_idle() #endif /* HAS_LCD */ static void sleep_until_melody_completes(void) { set_sleep_mode(SLEEP_MODE_IDLE); // In this tight loop we are guaranteed one last interrupt // after is_melody_playing() returns false while (is_melody_playing()) { sleep_mode(); watchdog_reset(); } }
static void sleep_after_timeout(void) { watchdog_reset(); rcs956_rf_off(); // Active sleep if blinking, deep sleep otherwise. for (uint8_t i = 0; i < SLEEP_COUNT_CLK_DOWN(SLEEP_AFTER_TIMEOUT); i++) { sleep_until_timer(SLEEP_MODE_PWR_SAVE, true); } }
void driver_tick(void) { watchdog_reset(); #ifdef CONFIG_HW_UART hw_uart_tick(); #endif #ifdef CONFIG_USBDEV usbdev_tick(); #endif console_tick(); led_tick(tick_get()); }
static WRITE32_HANDLER( gunbustr_input_w ) { gunbustr_state *state = space->machine().driver_data<gunbustr_state>(); #if 0 { char t[64]; COMBINE_DATA(&state->m_mem[offset]); sprintf(t,"%08x %08x",state->m_mem[0],state->m_mem[1]); popmessage(t); } #endif switch (offset) { case 0x00: { if (ACCESSING_BITS_24_31) /* $400000 is watchdog */ { watchdog_reset(space->machine()); } if (ACCESSING_BITS_0_7) { eeprom_device *eeprom = space->machine().device<eeprom_device>("eeprom"); eeprom->set_clock_line((data & 0x20) ? ASSERT_LINE : CLEAR_LINE); eeprom->write_bit(data & 0x40); eeprom->set_cs_line((data & 0x10) ? CLEAR_LINE : ASSERT_LINE); return; } return; } case 0x01: { if (ACCESSING_BITS_24_31) { /* game does not write a separate counter for coin 2! It should disable both coins when 9 credits reached see code $1d8a-f6... but for some reason it's not */ coin_lockout_w(space->machine(), 0, data & 0x01000000); coin_lockout_w(space->machine(), 1, data & 0x02000000); coin_counter_w(space->machine(), 0, data & 0x04000000); coin_counter_w(space->machine(), 1, data & 0x04000000); state->m_coin_word = (data >> 16) &0xffff; } //logerror("CPU #0 PC %06x: write input %06x\n",cpu_get_pc(&space->device()),offset); } } }
static WRITE32_HANDLER( superchs_input_w ) { superchs_state *state = space->machine().driver_data<superchs_state>(); #if 0 { char t[64]; COMBINE_DATA(&state->m_mem[offset]); sprintf(t,"%08x %08x",state->m_mem[0],state->m_mem[1]); //popmessage(t); } #endif switch (offset) { case 0x00: { if (ACCESSING_BITS_24_31) /* $300000 is watchdog */ { watchdog_reset(space->machine()); } if (ACCESSING_BITS_0_7) { eeprom_device *eeprom = space->machine().device<eeprom_device>("eeprom"); eeprom->set_clock_line((data & 0x20) ? ASSERT_LINE : CLEAR_LINE); eeprom->write_bit(data & 0x40); eeprom->set_cs_line((data & 0x10) ? CLEAR_LINE : ASSERT_LINE); return; } return; } /* there are 'vibration' control bits somewhere! */ case 0x01: { if (ACCESSING_BITS_24_31) { coin_lockout_w(space->machine(), 0,~data & 0x01000000); coin_lockout_w(space->machine(), 1,~data & 0x02000000); coin_counter_w(space->machine(), 0, data & 0x04000000); coin_counter_w(space->machine(), 1, data & 0x08000000); state->m_coin_word=(data >> 16) &0xffff; } } } }
void watchdog_set(int timeout) { static struct sunxi_wdog *const wdog = &((struct sunxi_timer_reg *)SUNXI_TIMER_BASE)->wdog; /* Set timeout, reset & enable */ if (timeout >= 0) { writel(WDT_MODE_TIMEOUT(timeout) | WDT_MODE_RESET_EN | WDT_MODE_EN, &wdog->mode); } else { writel(0, &wdog->mode); } watchdog_reset(); }
void WDT_Prescaler_Change(void) { //__disable_interrupt(); cli(); watchdog_reset(); /* Start timed equence */ WDTCSR |= (1<<WDCE) | (1<<WDE); // PREDEFINED TIMEOUT HERE!!!... /* Set new prescaler(time-out) value = 64K cycles (~0.5 s) */ WDTCSR = (1<<WDE) | (1<<WDP2) | (1<<WDP0); //__enable_interrupt(); sei(); }
void WDT_off() { //__disable_interrupt(); cli(); watchdog_reset(); /* Clear WDRF in MCUSR */ MCUSR &= ~(1<<WDRF); /* Write logical one to WDCE and WDE */ /* Keep old prescaler setting to prevent unintentional time-out */ WDTCSR |= (1<<WDCE) | (1<<WDE); /* Turn off WDT */ WDTCSR = 0x00; //__enable_interrupt(); sei(); }
void running_machine::soft_reset(void *ptr, INT32 param) { logerror("Soft reset\n"); // temporarily in the reset phase m_current_phase = MACHINE_PHASE_RESET; // set up the watchdog timer; only start off enabled if explicitly configured m_watchdog_enabled = (config().m_watchdog_vblank_count != 0 || config().m_watchdog_time != attotime::zero); watchdog_reset(); m_watchdog_enabled = true; // call all registered reset callbacks call_notifiers(MACHINE_NOTIFY_RESET); // now we're running m_current_phase = MACHINE_PHASE_RUNNING; }
static void watchdog_event_handler(struct tevent_context *ev, struct tevent_timer *te, struct timeval current_time, void *private_data) { /* first thing reset the watchdog ticks */ watchdog_reset(); /* then set a new watchodg event */ watchdog_ctx.te = tevent_add_timer(ev, ev, tevent_timeval_current_ofs(watchdog_ctx.interval.tv_sec, 0), watchdog_event_handler, NULL); /* if the function fails the watchdog will kill the * process soon enough, so we just warn */ if (!watchdog_ctx.te) { DEBUG(SSSDBG_FATAL_FAILURE, "Failed to create a watchdog timer event!\n"); } }
int main(void) { init(); BOOL motors_stopped = FALSE; send_welcome(); while (1) { if (motors_stopped) { led_on ( STOP_LED ); led_off ( GO_LED ); } else { led_on( GO_LED ); led_off( STOP_LED ); } read_buttons(); if (stop_button_pressed) { motors_stopped = TRUE; stop_motors(); } if (prog_button_pressed) { motors_stopped = FALSE; resume_motors(); } encoder_timeslice(); limit_switch_timeslice(); motor_timeslice_10ms(); serial_timeslice(); // handle incoming messages (if avail) watchdog_reset(); //delay(one_second/10); } return (0); }
uint8_t hw_i2c_read_bit(void) { uint8_t bit; cpu_disable_int(); delay_T2(); sda_hi(); scl_hi(); // wait for slave (clock stretching) do { delay_T2(); watchdog_reset(); // FIXME, add timeout } while ((SCL_IN & _BV(SCL)) == 0); bit = SDA_IN & _BV(SDA) ? 1 : 0; delay_T2(); scl_low(); cpu_enable_int(); return bit; }
/* Use SSL. Must be entirely different since the return * type is a pointer to an SSL structure. */ BIO * urlinstStartSSLTransfer(struct iurlinfo * ui, char * filename, char *extraHeaders, int silentErrors, int flags, char *nextServer) { extern void watchdog_reset(); int tries = 1; int rc; int errorcode = -1; int sleepmin = KS_RETRY_MIN; char *returnedHeaders; BIO *sbio = 0; logMessage(INFO, "ROCKS:transferring https://%s/%s\nHeaders:%s\n", ui->address, filename, extraHeaders); /* Add 'public' path element if we dont have a cert. */ if (!haveCertificate()) addPublic(&filename); while ((errorcode < 0) && (tries < 10)) { sbio = httpsGetFileDesc(ui->address, -1, filename, extraHeaders, &errorcode, &returnedHeaders); if (errorcode == 0) { char *ptr; char trackers[256]; char pkgservers[256]; if ((ptr = strstr(returnedHeaders, "X-Avalanche-Trackers:")) != NULL) { sscanf(ptr, "X-Avalanche-Trackers: %256s", trackers); } else { if (nextServer != NULL) { snprintf(trackers, sizeof(trackers) - 1, "%s", nextServer); } else { strcpy(trackers, "127.0.0.1"); } } if ((ptr = strstr(returnedHeaders, "X-Avalanche-Pkg-Servers:")) != NULL) { sscanf(ptr, "X-Avalanche-Pkg-Servers: %256s", pkgservers); } else { if (nextServer != NULL) { snprintf(pkgservers, sizeof(pkgservers) - 1, "%s", nextServer); } else { strcpy(pkgservers, "127.0.0.1"); } } writeAvalancheInfo(trackers, pkgservers); } else if (errorcode == FTPERR_FAILED_DATA_CONNECT) { /* * read the retry value from the return message */ char *ptr; int sleeptime = 0; if ((ptr = strstr(returnedHeaders, "Retry-After:")) != NULL) { sscanf(ptr, "Retry-After: %d", &sleeptime); } if (sleeptime <= 0) { /* * Backoff a random interval between * KS_RETRY_MIN and KS_RETRY_MAX */ sleeptime = sleepmin + ((KS_RETRY_MAX - sleepmin) * (rand()/(float)RAND_MAX)); } winStatus(55, 3, _("Server Busy"), _("I will retry " "for a ks file after a %d sec sleep..."), sleeptime, 0); /* * this must be in a loop, as the alarm associated * with the watchdog timer is sending a signal which * interrupts the sleep(). */ while ((sleeptime = sleep(sleeptime)) != 0) { ; } newtPopWindow(); tries = 1; /* Don't let the watchdog fire if the kickstart server is reporting busy */ watchdog_reset(); continue; } else if (errorcode == FTPERR_REFUSED) { /* * always accept the parent credentials */ forceParentAuth(); continue; } logMessage(INFO, "ROCKS:urlinstStartSSLTransfer:attempt (%d)", tries); sleep(1); ++tries; } if (errorcode < 0) { logMessage(ERROR, "ROCKS:urlinstStartSSLTransfer:Failed"); rc = 0; /* Go through the public door automatically, but only * if we have not tried it already. */ if (errorcode == FTPERR_SERVER_SECURITY && !addPublic(&filename)) { rc = 1; } else { rc = newtWinChoice(_("GET File Error"), _("Retry"), _("Cancel"), _("Could not get file:\n\nhttps://%s/%s\n\n%s"), ui->address, filename, ftpStrerror(errorcode, URL_METHOD_HTTP)); } if (rc==1) /* Retry */ return urlinstStartSSLTransfer(ui, filename, extraHeaders, silentErrors, flags, nextServer); else /* Cancel */ return NULL; } if (!FL_CMDLINE(flags)) winStatus(70, 3, _("Retrieving"), "%s %.*s...", _("Retrieving"), 60, filename); return sbio; }
void FatFs_task(void) { portTickType xDelayPeriod = (portTickType)500 / portTICK_RATE_MS; sub_net_init(); while(1) { vTaskDelay(xDelayPeriod); if(sd_status == 1) // parse hex file, and read it to RAM { f_mount(0, &fs); // scan_files("0:/"); f_open(&file, "0:/64K.hex", FA_OPEN_ALWAYS | FA_READ | FA_WRITE); read_ptr = 0; // file_size = f_size(&file); // printd("\r\nfile_size = %lu", file_size); file_end_flag = FALSE; memset(hex_ram_0, 0xff, HEX_BANK_SIZE); memset(hex_ram_1, 0xff, HEX_BANK_SIZE); max_data_length = 0; max_package = 0; while(1) { if(FR_OK == f_lseek(&file, read_ptr)) { if((FR_OK == f_read(&file, read_buf, READ_SIZE, &br)) && (br != 0)) { read_buf[br] = '\0'; if(getstr = strtok(read_buf, token)) { do { if(parse(getstr, hex_buf, &hex_bytes, &valid_length) == TRUE) { if(hexline.type == 0) { uint8 i; for(i = 0; i < hex_bytes; i++) { if(hexline.length < HEX_BANK_SIZE) { hex_ram_0[hexline.address + i] = hex_buf[i]; } else { hex_ram_1[hexline.address + i - HEX_BANK_SIZE] = hex_buf[i]; } } } else if(hexline.type == 1) { file_end_flag = TRUE; break; } else { } read_ptr += valid_length; if(max_data_length < (hexline.address + hexline.length)) { max_data_length = hexline.address + hexline.length; } } } while(getstr = strtok(NULL, token)); } // printd("\r\nread_ptr = %lu", read_ptr); } else { printd("\r\nf_read() failed.."); } } else { printd("\r\nf_lseek() failed.."); } if(file_end_flag == TRUE) { max_package = (max_data_length >> 7); if(max_data_length & 0x0000007f) max_package++; break; } watchdog_reset(); vTaskDelay(5); } f_close(&file); sd_status = 2; }
int main(void) { disable_unused_circuits(); _delay_ms(50); #ifdef HAS_CHARGER reset_on_power_change(); #endif /* HAS_CHARGER */ /* Shut off right away if battery is very low. Do not power on NFC module */ adc_init(); (void)read_voltage(); // Read one more time in case first reading is corrupted uint8_t voltage = read_voltage(); adc_disable(); if (is_battery_dead(voltage)) { //beep_n_times_and_wait(4); //sleep_forever(); } lcd_init(); print_idle(); // Initialize and self-test module_power_up(); led_on(); #ifdef WITH_TARGET // We may have come out of target power down mode //(void)pasori_wake_up(); #endif while (!rcs956_reset()) {}; if (!eeprom_has_station_info()) { beep_n_times_and_wait(3); sleep_forever(); } if (is_on_external_power()) { play_song_and_wait(melody_start_up_external, sizeof(melody_start_up_external) / sizeof(struct note)); } else { play_song_and_wait(melody_start_up_battery, sizeof(melody_start_up_battery) / sizeof(struct note)); } led_off(); initiator_set_defaults(); watchdog_start(); for (;;) { watchdog_reset(); // initiator exits after polling times out (false) or URL is pushed (true) if (initiator(PUSH_URL_LABEL)) { lcd_puts(0, "PUSH SLEEP"); play_url_push_success_song_and_wait(); } #ifdef WITH_TARGET uint8_t loop; // Loop here to not skip watchdog timer for (loop = 0; loop < TARGET_MODE_RETRY; loop++) { watchdog_reset(); (void)rcs956_reset(); enum target_res res = target(PUSH_URL_LABEL_ENGLISH); if (res == TGT_COMPLETE) { led_off(); play_url_push_success_song_and_wait(); break; } else if (res == TGT_TIMEOUT || res == TGT_ERROR) { break; } // loop on TGT_RETRY } led_off(); (void)rcs956_reset(); low_battery_check(); #else /* !WITH_TARGET */ // Check battery level while RF field is still on low_battery_check(); sleep_after_timeout(); #endif /* WITH_TARGET */ // Reconfigure Felica module if communication timed out, // e.g. due to temporary disconnect. if (protocol_errno == TIMEOUT) { initiator_set_defaults(); eeprom_increment_usart_fail(); } protocol_errno = SUCCESS; } /* NOT REACHABLE */ return 0; }