nesso 0.0.1

Rust SDK facade for Arduino Nesso N1 on ESP32-C6.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

# nesso-rs

`nesso-rs` is a Rust-native SDK for the Arduino Nesso N1, an ESP32-C6 based
device with display, touch, IMU, Wi-Fi, audio, and battery/power-management
hardware.

The public crate is [`nesso`](https://crates.io/crates/nesso). The repository is
a Cargo workspace so lower-level hardware crates can also be used directly when
an application needs finer control.

## Status

This project is an early hardware-validated SDK foundation.

Version `0.0.1` targets only the Arduino Nesso N1. It intentionally does not
provide a generic board abstraction layer, an M5Stack compatibility layer, or
support for other ESP32-C6 boards.

Validated examples currently cover:

- ST7789P3 display initialization and text rendering
- FT6336U touch reads
- BMI270 IMU live axis reads
- Passive buzzer tone output
- BQ27220/AW32001 battery and charger status reads
- ESP32-C6 Wi-Fi scan using `esp-radio`
- Board information display

## Installation

Add the public facade crate:

```toml
[dependencies]
nesso = "0.0.1"
```

Advanced users may depend on subsystem crates directly:

```toml
[dependencies]
nesso-display = "0.0.1"
nesso-imu = "0.0.1"
nesso-wifi = "0.0.1"
```

## Workspace Crates

- `nesso`: public facade crate and re-exports for the SDK.
- `nesso-n1`: Nesso N1 board constants, GPIOs, I2C addresses, and
  board-specific setup helpers.
- `nesso-display`: ST7789P3 display driver with `embedded-graphics`
  integration.
- `nesso-touch`: FT6336U touch controller support.
- `nesso-input`: button event state machine helpers.
- `nesso-imu`: BMI270 initialization, config upload, and sensor reads.
- `nesso-audio`: passive buzzer output and blocking tone generation.
- `nesso-power`: BQ27220 fuel gauge and AW32001 charger status support.
- `nesso-wifi`: ESP32-C6 Wi-Fi scan support using `esp-radio` and `esp-rtos`.
- `nesso-storage`: heapless settings storage primitives.

## Example

The BSP owns the fixed Nesso N1 wiring. Applications initialize the ESP-HAL
peripherals once, then ask the BSP for ready-to-use board resources.

```rust,ignore
#![no_std]
#![no_main]

use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor};
use embedded_hal::delay::DelayNs;
use esp_hal::{clock::CpuClock, delay::Delay, main};
use nesso::bsp::NessoN1Board;

#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);
    let mut delay = Delay::new();
    let mut display = NessoN1Board::new(peripherals).into_display().unwrap();

    display.clear(Rgb565::BLACK).unwrap();
    display
        .print_centered("Hello from nesso-rs", 120, Rgb565::WHITE)
        .unwrap();

    loop {
        delay.delay_ms(1000);
    }
}
```

See `examples/` for hardware-focused examples.

## Build

Install Rust with the target specified in `rust-toolchain.toml`, then run:

```bash
cargo metadata --no-deps --format-version 1
cargo fmt --check --all
cargo clippy --workspace --all-targets -- -D warnings
cargo check --workspace
cargo build --workspace
cargo build --workspace --release
```

## Flashing Examples

Build and flash an example with `espflash`:

```bash
cargo build -p hello_world --release
espflash flash --chip esp32c6 -p /dev/cu.usbmodem1101 \
  target/riscv32imac-unknown-none-elf/release/hello_world
```

Change the serial port for your host.

## Documentation

Hardware and architecture notes are kept in `docs/`:

- `docs/hardware.md`
- `docs/architecture.md`
- `docs/m5gfx-analysis.md`
- `docs/gap-analysis.md`
- `docs/roadmap.md`

## Release Process

Releases are published from GitHub Releases.

1. Update the workspace version in `Cargo.toml`.
2. Merge through a pull request to `main`.
3. Create and push a tag matching the version, for example `v0.0.1`.
4. Publish a GitHub Release for that tag.

The release workflow validates the workspace, publishes internal crates first,
then publishes the public `nesso` crate to crates.io.

The workflow requires a repository secret named `CARGO_REGISTRY_TOKEN`.

## License

Licensed under the MIT License. See the `LICENSE` file.