Just as before, let's add some helper type aliases.

// a shorthand, to not have to type this out every time we need it
pub type InputStateType = Mutex<CriticalSectionRawMutex, InputState>;
pub type InputStateRef = &'static InputStateType;

Then in our main function right before we spawn our input_handler, we initialize our struct, and retrieve a static reference to it:

// init input state, so we know that from now on input state will always be valid
static INPUT_STATE: StaticCell<InputStateType> = StaticCell::new();
let input_static_ref: InputStateRef = INPUT_STATE.init(Mutex::new(InputState::default()));

The next step will now be to pass this freshly created reference to the corresponding tasks. This includes sharing the reference and populating it with correct data in input_handler, and reading the state in draw_task. At the end, you should have something like the following in draw_task:

// Later we will initialize the game state here
loop {
    // make sure that the mutex guard for input state is dropped
    // as soon as possible after we have copied the state.
    let input_state = { *input_state.lock().await };
    // Update here the game
    {
        let mut fb = back_buffer.lock().await;
        let fb = &mut *fb; // unpack guard

        // start drawing calls
        unwrap!(fb.fill_solid(&fb.bounding_box(), Rgb565::BLACK));
        // Draw here the game

        signal.signal(()); // signal to driver that draw has been called
    } // Guard is dropped here
    led.set_low();
    yield_now().await;
}

And the following input_handler:

#[embassy_executor::task]
async fn input_handler(
    btns: (AnyPin, AnyPin, AnyPin, AnyPin),
    input_state: InputStateRef,
    led: AnyPin, // We optionally add here a pin, such that we can more easily debug things
) {
    // Initialize all the buttons
    let mut btn1 = Input::new(btns.0, Pull::Up);
    let mut btn2 = Input::new(btns.1, Pull::Up);
    let mut btn3 = Input::new(btns.2, Pull::Up);
    let mut btn4 = Input::new(btns.3, Pull::Up);

    let mut led = Output::new(led, Level::Low, OutputDrive::Standard);

    loop {
        // Wait until we see a button change
        select4(
            btn1.wait_for_any_edge(),
            btn2.wait_for_any_edge(),
            btn3.wait_for_any_edge(),
            btn4.wait_for_any_edge(),
        )
        .await;

        // Create an updated state
        led.set_high();
        let state = InputState {
            btn1: btn1.is_low(),
            btn2: btn2.is_low(),
            btn3: btn3.is_low(),
            btn4: btn4.is_low(),
        };
        {
            // Send the update to the other tasks
            *input_state.lock().await = state; // keep lock as small as possible
        } // drop immediatly

        // Log something, such that we know what is happening
        info!(
            "Detected input change 1: {}, 2: {}, 3: {}, 4: {}",
            state.btn1, state.btn2, state.btn3, state.btn4,
        );
        led.set_low();
    }
}

Next is actually implementing the game of Pong. We will start by creating a struct for the players:

pub struct Player {
    position: Point, // the current position of the player
}

impl Player {
    /// p is the initial point to spawn the player on
    pub fn new(p: Point) -> Self {
        Self { position: p }
    }

    // make sure that the player can only move on the screen
    // the max height is 128 pixels
    pub fn move_up(&mut self) {
        todo!()
    }

    // make sure that the player can only move on the screen
    // the min height is 0 pixels
    pub fn move_down(&mut self) {
        todo!()
    }
}

To make it easier for us to later do the collision detection, while leveraging embedded_graphics, we will implement some interesting traits that keep track off how big the player is (already provided), and how to draw the player on screen (target):

// Drawable is something that can be drawn onto the screen
impl Drawable for Player {
    type Color = Rgb565; // needed to be compatible with our screen

    type Output = (); // we will not need to return anything after drawing

    fn draw<D>(&self, target: &mut D) -> Result<Self::Output, D::Error>
    where
        D: DrawTarget<Color = Self::Color>,
    {
        // Make sure you use the same values as used in the Dimensions
        // trait implementation. Otherwise the collision detection will
        // be harder to correctly implement
        todo!("Look at how we have drawn a rectangle in the past")
    }
}

// Have a way to know what the bounding box of the player is
impl Dimensions for Player {
    fn bounding_box(&self) -> Rectangle {
        Rectangle {
            top_left: self.position,
            size: Size {
                width: 5, // these seem good values
                height: 30,
            },
        }
    }
}

Similarly for the ball, we are going to need to implement a few methods on the Pong struct.

pub struct Pong {
    pub position: Point, // current position
    pub velocity: Point, // to where we will update the position
}

impl Pong {
    pub fn new(p: Point) -> Self {
        Self {
            position: p,
            velocity: Point::new(3, 3),
        }
    }

    pub async fn update(&mut self) {
        todo!()
    }

    pub fn flip_horizontal(&mut self) {
        todo!()
    }

    pub fn flip_vertical(&mut self) {
        todo!()
    }
}

impl Drawable for Pong {
    type Color = Rgb565;

    type Output = ();

    fn draw<D>(&self, target: &mut D) -> Result<Self::Output, D::Error>
    where
        D: DrawTarget<Color = Self::Color>,
    {
        todo!("This time draw me as a circle -> take a look at the primitives section in the embedded_graphics documentation")
    }
}

impl Dimensions for Pong {
    fn bounding_box(&self) -> Rectangle {
        Rectangle {
            top_left: self.position,
            size: Size {
                width: 10, // seem good values
                height: 10,
            },
        }
    }
}

Now, you should complete the draw method as it does not yet draw the players and the ball as it should.

impl Drawable for GameState {
    type Color = Rgb565;

    type Output = ();

    fn draw<D>(&self, target: &mut D) -> Result<Self::Output, D::Error>
    where
        D: DrawTarget<Color = Self::Color>,
    {
        // ... more drawing code here ...

        // power of the abstractions of embedded_graphics -> draw the players and ball
        todo!("Draw player1, player2 and pong"); // REPLACE THIS
    }
}

Now all we still have to do is initialize our game state in the draw_task, update it every frame, and draw it to the framebuffer.

// draw_task
let mut game_state = todo!(); // NEW
loop {
    let input_state = { *input_state.lock().await };
    game_state.update(input_state).await; // NEW
    {
        let mut fb = back_buffer.lock().await;
        let fb = &mut *fb; // unpack guard

        // start drawing calls
        unwrap!(fb.fill_solid(&fb.bounding_box(), Rgb565::BLACK));
        unwrap!(game_state.draw(fb)); // NEW

    } // Guard is dropped here
    signal.signal(()); // signal to driver that draw has been called
    yield_now().await;
}

Ps. Is it getting a bit slow? Try to compile in release mode:

$ cargo run --release # and now wait until it compiles :p