rlvgl 0.1.7

A modular, idiomatic Rust reimplementation of the LVGL graphics library for embedded and simulator use.
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
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

//! Convert CubeMX `.ioc` files into board overlays.
//!
//! Uses the canonical STM32 MCU database to resolve alternate-function numbers
//! and emits a JSON object compatible with `boards/` overlays.

use crate::bsp::{af::AfProvider, ioc};
use anyhow::{Result, anyhow};
use rlvgl_chips_stm as stm;
use serde_json::{Map, Value};
use std::collections::HashMap;
use std::fs;
use std::io::Read;
use std::path::Path;

/// Convert a user CubeMX `.ioc` file into a board overlay JSON.
///
/// The MCU name is detected from the `.ioc` file. Alternate-function numbers
/// are resolved using the STM32 canonical database bundled with the
/// `rlvgl-chips-stm` crate.
#[allow(clippy::module_name_repetitions)]
pub fn from_ioc(
    ioc_path: &Path,
    board: &str,
    out_path: &Path,
    template: Option<&str>,
) -> Result<()> {
    let text = fs::read_to_string(ioc_path)?;
    let mcu = detect_mcu(&text)?;
    let af = load_mcu_af(&mcu)?;
    // CubeMX `.ioc` files prefix pin keys with `Pin.`; strip it so the
    // lightweight parser can match the signals.
    let cleaned = text.replace("Pin.", "");
    let ir = ioc::ioc_to_ir(&cleaned, &af, false)?;

    let mut pins = Map::new();
    for p in ir.pinctrl {
        let entry = pins
            .entry(p.pin.clone())
            .or_insert_with(|| Value::Object(Map::new()));
        if let Some(obj) = entry.as_object_mut() {
            obj.insert(p.func, Value::from(p.af));
        }
    }

    let mut obj = Map::new();
    obj.insert("board".to_string(), Value::from(board));
    obj.insert("chip".to_string(), Value::from(mcu));
    obj.insert("pins".to_string(), Value::Object(pins));
    if let Some(t) = template {
        obj.insert("template".to_string(), Value::from(t));
    }
    if let Some(parent) = out_path.parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(out_path, serde_json::to_string_pretty(&Value::Object(obj))?)?;
    Ok(())
}

fn detect_mcu(text: &str) -> Result<String> {
    text.lines()
        .find_map(|l| l.strip_prefix("Mcu.Name=").map(|s| s.to_string()))
        .ok_or_else(|| anyhow!("Mcu.Name not found in .ioc"))
}

fn load_mcu_af(mcu: &str) -> Result<McuAf> {
    let blob = stm::raw_db();
    let mut decoder = zstd::Decoder::new(&blob[..])?;
    let mut data = Vec::new();
    decoder.read_to_end(&mut data)?;
    let files = parse_raw_db(&data);
    let mcu_json = files
        .get("mcu.json")
        .ok_or_else(|| anyhow!("mcu.json missing from STM database"))?;
    let map: HashMap<String, Value> = serde_json::from_slice(mcu_json)?;
    let val = map
        .get(mcu)
        .ok_or_else(|| anyhow!("MCU '{}' not found in STM database", mcu))?;
    let mut pins = HashMap::new();
    if let Some(obj) = val.get("pins").and_then(|v| v.as_object()) {
        for (pin, entries) in obj {
            let mut funcs = HashMap::new();
            if let Some(arr) = entries.as_array() {
                for e in arr {
                    if let (Some(sig), Some(af)) = (
                        e.get("signal").and_then(|s| s.as_str()),
                        e.get("af").and_then(|a| a.as_u64()),
                    ) {
                        funcs.insert(sig.to_string(), af as u8);
                    }
                }
            }
            pins.insert(pin.clone(), funcs);
        }
    }
    Ok(McuAf { pins })
}

struct McuAf {
    pins: HashMap<String, HashMap<String, u8>>,
}

impl AfProvider for McuAf {
    fn lookup_af(&self, _mcu: &str, pin: &str, func: &str) -> Option<u8> {
        self.pins.get(pin).and_then(|m| m.get(func)).copied()
    }
}

fn parse_raw_db(blob: &[u8]) -> HashMap<String, Vec<u8>> {
    let text = core::str::from_utf8(blob).unwrap_or("");
    let mut files = HashMap::new();
    let mut lines = text.lines();
    while let Some(line) = lines.next() {
        if let Some(name) = line.strip_prefix('>') {
            let mut content = String::new();
            while let Some(l) = lines.next() {
                if l == "<" {
                    break;
                }
                if !content.is_empty() {
                    content.push('\n');
                }
                content.push_str(l);
            }
            files.insert(name.to_string(), content.into_bytes());
        }
    }
    files
}