JavaFX controller, implementing non-graphic events and background state machine

I started learning about JavaFX a short time ago and I am trying to switch from Swing to JavaFX. I ran into some logic implementation problem that I cannot think of a solution with JavaFX that I easily solved using Swing.

The application that I developed is huge, containing multiple already developed software modules, that interact with the graphics at some point. For example, in the application I have a smart card reader that, when a card is read on that reader and the operator is authenticating with a smart card, it displays on the graphic that a valid card is read, it display a green card icon and lets the operator enters his password. There are multiple drivers like the smart card reader and all of them generate events also with their status, are they working or not. In the current solution all modules communicate with central main software that can call functions for the Swing graphics.

The application starts with initializing a page, and when all of the devices are working and there is no error, I am showing the first page of the application. If any of them has an error, I am showing the error page. I designed some fxml and connect them with their own controller. In the controller of the initializing page in the method should look something like this:

@Override
public void initialize(URL url, ResourceBundle rb) {
    if(no_error){
        go to first page
    }else{
        go to out of order page
    }
}

The first thing that I want to implement is to wait, because some of the drivers and devices won't work instantly, for example wait for 10 cycles with timeout of 1 second on each of them.

@Override
public void initialize(URL url, ResourceBundle rb) {
    while (true) {
        if (no_error) {
            go to first page
        } else {
            if (timeout_expired) {
                go to out of order page
            } else {
                wait
                increase timeout
            }
        }
    }
}

I know that purpose of the initialize method is not for this and the above code is not a solution, I am looking more for a function like doInBackground from the AsyncTask.

Also, in this application in the controller, I want to implement events that are not graphic related like the reading of the smart card. How to connect the event from the driver for the smart card, when it reads card data to send that data to a function implemented in the controller like the one below?

public void controller_smart_card_read(SmartCard smart_card){
    //Check if valid card from DB
    //Display result
}

Also, in some scene I want to implement an inactivity event. If there are no events for a longer period of time (both graphical and from the devices), go back to the first page for example.

To summarize this, is there a way a controller is accessed and triggered from an independent software module, and is there a way to implement a doInBackground() function while scene and controller is up and running?

Create a background thread to do this functionality and use the Platform.runLater to update the UI.

For Example

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;

ScheduledExecutorService scheduledExecutorService;
ScheduledFuture<?>       scheduledCheck;

public void start(Stage base) {

  base.setOnCloseRequest(
  scheduledExecutorService.shutdownNow();

  );

  scheduledExecutorService = Executors.newScheduledThreadPool(1);

  Runnable doBackground = () -> {
    //Do background tasks i.e. check card reader
    if(devices_ready && successful_card_read)
      Platform.runLater(() -> {
        //Update Javafx UI
      });
  }
  //scheduleAtFixedRate(Runnable function, wait time before starting runnable, cycle time, timeunit) 
  //the below thread will wait 10 seconds, then execute the doBackground every 1 second
  scheduledCheck = scheduledExecutorService.scheduleAtFixedRate(doBackground,10,1, TimeUnit.SECONDS);
}