pros-simulator 0.5.1

Run PROS robot code without the need for real VEX V5 hardware.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Legacy LCD Emulator API
//!
//! ## Reference
//!
//! * `lcd_clear`
//! * `lcd_clear_line`
//! * `lcd_initialize`
//! * `lcd_is_initialized` (not implemented)
//! * `lcd_print` (not implemented)
//! * `lcd_read_buttons` (not implemented)
//! * `lcd_register_btn0_cb`
//! * `lcd_register_btn1_cb`
//! * `lcd_register_btn2_cb`
//! * `lcd_set_text`
//! * `lcd_shutdown` (not implemented)
//! * `lcd_set_background_color` (not implemented)
//! * `lcd_set_text_color` (not implemented)

use wasmtime::{Caller, Linker};

use crate::host::{memory::SharedMemoryExt, Host, HostCtx, ResultExt};

pub fn configure_llemu_api(linker: &mut Linker<Host>) -> anyhow::Result<()> {
    linker.func_wrap0_async("env", "lcd_initialize", |caller: Caller<'_, Host>| {
        Box::new(async move {
            let res = caller.lcd_lock().await.initialize();
            Ok(u32::from(res.is_ok()))
        })
    })?;

    linker.func_wrap2_async(
        "env",
        "lcd_set_text",
        |mut caller: Caller<'_, Host>, line: i32, text_ptr: u32| {
            Box::new(async move {
                let text = caller.memory().read_c_str(text_ptr)?;
                let res = caller.lcd_lock().await.set_line(line, &text);
                Ok(u32::from(res.unwrap_or_errno(&mut caller).await))
            })
        },
    )?;

    linker.func_wrap1_async(
        "env",
        "lcd_clear_line",
        |mut caller: Caller<'_, Host>, line: i32| {
            Box::new(async move {
                let res = caller.lcd_lock().await.clear_line(line);
                Ok(u32::from(res.unwrap_or_errno(&mut caller).await))
            })
        },
    )?;

    linker.func_wrap0_async("env", "lcd_clear", |mut caller: Caller<'_, Host>| {
        Box::new(async move {
            let res = caller.lcd_lock().await.clear();
            Ok(u32::from(res.unwrap_or_errno(&mut caller).await))
        })
    })?;

    for lcd_button in 0..3 {
        linker.func_wrap1_async(
            "env",
            &format!("lcd_register_btn{lcd_button}_cb"),
            move |mut caller: Caller<'_, Host>, cb: u32| {
                Box::new(async move {
                    let res = {
                        caller
                            .lcd_lock()
                            .await
                            .set_btn_press_callback(lcd_button, cb)
                    };
                    Ok(u32::from(res.unwrap_or_errno(&mut caller).await))
                })
            },
        )?;
    }

    Ok(())
}