• Five open-source CPUs
• VexRiscv RV32IMAC+MMU @ 350MHz
• 4x PicoRV I/O Engine ("BIO") @ 700MHz
• 4MiB on-chip ROM ("RRAM")
• 2MiB on-chip SRAM
• Cryptographic accelerators, TRNG
• USB HS, camera, I2C, SPI, UART, etc.

• BIO: Bao-I/O protocol emulator
• Any protocol <25MHz toggle rate
• CAN
• LED strips
• USB full speed
• I2C, UART, SPI, etc...
• That weird air conditioner IR protocol...
• Open source and patent-free!
• Similar to Raspberry Pi PIO but open source

• See BIO-sim repository for more details
• https://github.com/baochip/bio-sim

• "Simplest Board"
• 2-layer PCB
• JLCPCB-compatible
• Not all I/O routed to pins
• Baochip-1x CSP package is too dense
• Subset of routable I/O available
• Includes local voltage regulators
• Source: https://github.com/baochip/dabao

• Written from the ground-up in Rust
• Source: https://github.com/betrusted-io/xous-core/

  
  									git clone --depth 1 https://github.com/betrusted-io/xous-core/
  									cd xous-core
  									git fetch --depth 1 origin tag v0.10.1
  								

• Requires Rust toolchain
  • If already installed, run "rustup update" to ensure it is recent
• Supports multiple targets, build for dabao with

									cargo xtask dabao dabao-console
								

• Or use the Baochip vscode plugin!

• https://marketplace.visualstudio.com/items?itemName=baochip.bao-vscode-ext

• Every process runs in an isolated, virtual memory space
• Messages must "bounce off" the kernel to be routed to its destination
• In this example:
• The "console" process sends a log message to "log" via the kernel
• The log receives the message
• It routes the log message to the USB interface
• (Not shown: it also routes it to the hardware serial interface)

• Only one process can own a peripheral
• First-come, first-serve ownership
• Access peripheral through message API
• This is why we have the "HAL" server: it "owns" most of the peripherals

							let srv = create_server(b"0123456789abcdef");
						

							while let Some(mut msg) = receive_message(srv) {
								// Handle message
							}
						

• Shell is located in "dabao-console"
• Shell has a REPL (Read-Eval-Print-Loop) which takes commands and dispatches them to "command modules"
• This is an example of the "ver" command module

impl<'a> ShellCmdApi<'a> for Ver {
    cmd_api!(ver);

    fn process(&mut self, args: String, env: &mut CommonEnv) ->
		Result<Option<String>, xous::Error> {
        use core::fmt::Write;
        let mut ret = String::new();
        let helpstring = "ver [xous]";

        let mut tokens = args.split(' ');

        if let Some(sub_cmd) = tokens.next() {
            match sub_cmd {
                "xous" => {
                    write!(ret, "Xous version: {}", env.ticktimer.get_version()).unwrap();
                    log::info!("VER.XOUS,{}", env.ticktimer.get_version());
                }
                _ => {
                    write!(ret, "{}", helpstring).unwrap();
                }
            }
        } else {
            write!(ret, "{}", helpstring).unwrap();
        }
        Ok(Some(ret))
    }
}
						

• Add a "blink" command to the "test.rs" module
• Insert the blink code in apps-dabao/dabao-console/src/cmds/test.rs around Line 24

    fn process(&mut self, args: String, _env: &mut CommonEnv) -> Result<Option<String>, xous::Error> {
        use core::fmt::Write;
        let mut ret = String::new();

        #[allow(unused_variables)]
        let helpstring = "test [proc] [freemem] [interrupts] [panic] [env]";

        let mut tokens = args.split(' ');

        if let Some(sub_cmd) = tokens.next() {
            match sub_cmd {
                "blink" => {
                    log::info!("Add blinky code here");
                }

						

• Create the "IoxHal" object
• Configure the port and direction
• PB4 allows us to put a simple LED between PB4 and the adjacent ground pin
• Create a loop:
• Set the pin to high
• Wait 1 second
• Set the pin to low
• Wait 1 second
• Build-flash-monitor

                "blink" => {
                    use std::time::Duration;

                    use bao1x_api::{IoGpio, IoxDir, IoxHal, IoxPort, IoxValue};
                    let iox = IoxHal::new();
                    iox.set_gpio_pin_dir(IoxPort::PB, 4, IoxDir::Output);
                    loop {
                        iox.set_gpio_pin_value(IoxPort::PB, 4, IoxValue::High);
                        std::thread::sleep(Duration::from_secs(1));
                        iox.set_gpio_pin_value(IoxPort::PB, 4, IoxValue::Low);
                        std::thread::sleep(Duration::from_secs(1));
                    }
                }