Simulate the whole system, not just the chip.

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24

/* Flight controller: attitude loop at 400 Hz on the STM32F767. */
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include "attitude.h"
#include "imu.h"

#define LOOP_HZ 400

static const struct device *i2c = DEVICE_DT_GET(DT_NODELABEL(i2c1));

int main(void)
{
    struct imu_sample s;

    if (!device_is_ready(i2c)) {
        return -ENODEV;
    }

    while (1) {
        imu_read(i2c, &s);
        attitude_update(&s);
        k_sleep(K_USEC(1000000 / LOOP_HZ));
    }
}

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19

#include "imu.h"

#define MPU6050_ADDR  0x68
#define ACCEL_XOUT_H  0x3B

int imu_read(const struct device *i2c, struct imu_sample *s)
{
    uint8_t raw[14];
    int err = i2c_burst_read(i2c, MPU6050_ADDR, ACCEL_XOUT_H,
                 raw, sizeof(raw));

    if (err) {
        return err;
    }
    s->ax = (int16_t)(raw[0] << 8 | raw[1]);
    s->ay = (int16_t)(raw[2] << 8 | raw[3]);
    s->az = (int16_t)(raw[4] << 8 | raw[5]);
    return 0;
}

1. 1
2. 2
3. 3
4. 4
5. 5

CONFIG_I2C=y
CONFIG_SPI=y
CONFIG_SERIAL=y
CONFIG_GPIO=y
CONFIG_LOG=y

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24

// Safety monitor: raises FAULT if the flight controller goes quiet.
#include "pico/stdlib.h"

#define HEARTBEAT_PIN 15
#define FAULT_PIN     16
#define TIMEOUT_US    10000

int main(void)
{
    gpio_init(HEARTBEAT_PIN);
    gpio_init(FAULT_PIN);
    gpio_set_dir(FAULT_PIN, GPIO_OUT);

    uint64_t last = time_us_64();
    bool level = gpio_get(HEARTBEAT_PIN);

    while (true) {
        if (gpio_get(HEARTBEAT_PIN) != level) {
            level = !level;
            last = time_us_64();
        }
        gpio_put(FAULT_PIN, time_us_64() - last > TIMEOUT_US);
    }
}

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24

//! Telemetry: forwards flight state from UART to the ground link.
#![no_std]
#![no_main]

mod link;

use embassy_executor::Spawner;
use esp_hal::uart::{Config, Uart};

#[esp_hal_embassy::main]
async fn main(_spawner: Spawner) {
    let p = esp_hal::init(Default::default());
    let mut uart = Uart::new(p.UART1, Config::default())
        .unwrap()
        .with_rx(p.GPIO6)
        .with_tx(p.GPIO7)
        .into_async();
    let mut frame = [0u8; 32];

    loop {
        let n = uart.read_async(&mut frame).await.unwrap();
        link::send(&frame[..n]).await;
    }
}

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7

# Autonomous inspection drone

Three controllers on one airframe, simulated together:

- flight-controller: STM32F767, Zephyr
- safety-monitor: RP2350, pico-sdk
- telemetry: ESP32-C3, Rust + Embassy