• 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

• Imagine a RISC-V CPU...
• The lower 16 registers are "normal"
• The upper 16 registers are "hardware functions"
• Set/get GPIO, pin directions
• Event management
• Between-CPU communication & synchronization

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

• PDK vs RTL
• PDK (process design kit)
• Describes the physical transistors and wires
• Difficult to open-source because of foundry trade secrets
• Only older nodes (130nm, 180nm) are open PDK - others are closed (for now)
• RTL (Register Transfer Level)
• Hardware described in code
• Verilog, VHDL, etc.


• We can open source the RTL that we design
• We can choose open architectures for our CPUs
• We can start building the software today that will eventually run on the fully-open hardware stack!

Example of RTL

• Size of chip is set primarily by:
• Memory
• I/O perimeter
• Logic is like a "gas",
  it expands to fill the available space
• At a detail level, it can be quite sparse

• <2% die area
• 1x VexRiscv with MMU
• 4x PicoRV
• No extra cost to tape-out
• Logic is sparse
• Could fit more logic!
• No royalty

• "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
• Uses virtual memory (like your desktop OS) thanks to MMU
• Message passing between processes
• 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
								

• 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)

• 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));
                    }
                }