libxr 0.2.2__tar.gz → 0.2.3__tar.gz

{libxr-0.2.2 → libxr-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libxr
-Version: 0.2.2
+Version: 0.2.3
 Summary: C++ code generator for LibXR-based embedded systems, supporting STM32 and modular robotics applications.
 Author-email: Xiao <2592509183@qq.com>
 Maintainer-email: Xiao <2592509183@qq.com>
@@ -233,9 +233,54 @@ usage: xr_gen_code_stm32 [-h] -i INPUT -o OUTPUT [--xrobot] [--libxr-config LIBX
   Main entry point with all initialization logic
 
 - `libxr_config.yaml`：  
-  运行时配置文件，可自定义缓冲区大小、队列等参数
+  运行时配置文件，可自定义缓冲区大小、队列等参数  
   Runtime config YAML, can be customized with buffer size, queue, etc.
 
+- `flash_map.hpp`：  
+  自动生成的 Flash 扇区表，供 Flash 抽象层使用  
+  Auto-generated flash sector layout for use with Flash abstraction layer
+
+---
+
+### `xr_stm32_flash`
+
+解析 STM32 型号，生成 Flash 扇区信息表（YAML 格式输出）。  
+Parses STM32 model name and generates flash layout info (YAML output).
+
+```bash
+usage: xr_stm32_flash <STM32_MODEL>
+```
+
+### 🧠 功能说明 (Functionality)
+
+- 根据 STM32 型号名称自动推导 Flash 大小  
+  Automatically infers flash size from the STM32 model string
+
+- 根据芯片系列（如 F1/F4/H7/U5 等）生成对应的扇区布局  
+  Generates sector layout depending on the chip series (e.g., F1/F4/H7/U5)
+
+- 输出包括每个扇区的地址、大小和索引  
+  Output includes address, size, and index of each sector
+
+### 📦 输出内容 (Outputs)
+
+- YAML 格式的 Flash 信息  
+  Flash info in YAML format:
+
+```yaml
+model: STM32F103C8
+flash_base: '0x08000000'
+flash_size_kb: 64
+sectors:
+- index: 0
+  address: '0x08000000'
+  size_kb: 1.0
+- index: 1
+  address: '0x08000400'
+  size_kb: 1.0
+  ...
+```
+
 ---
 
 ### `xr_stm32_it`

{libxr-0.2.2 → libxr-0.2.3}/README.md

@@ -205,9 +205,54 @@ usage: xr_gen_code_stm32 [-h] -i INPUT -o OUTPUT [--xrobot] [--libxr-config LIBX
   Main entry point with all initialization logic
 
 - `libxr_config.yaml`：  
-  运行时配置文件，可自定义缓冲区大小、队列等参数
+  运行时配置文件，可自定义缓冲区大小、队列等参数  
   Runtime config YAML, can be customized with buffer size, queue, etc.
 
+- `flash_map.hpp`：  
+  自动生成的 Flash 扇区表，供 Flash 抽象层使用  
+  Auto-generated flash sector layout for use with Flash abstraction layer
+
+---
+
+### `xr_stm32_flash`
+
+解析 STM32 型号，生成 Flash 扇区信息表（YAML 格式输出）。  
+Parses STM32 model name and generates flash layout info (YAML output).
+
+```bash
+usage: xr_stm32_flash <STM32_MODEL>
+```
+
+### 🧠 功能说明 (Functionality)
+
+- 根据 STM32 型号名称自动推导 Flash 大小  
+  Automatically infers flash size from the STM32 model string
+
+- 根据芯片系列（如 F1/F4/H7/U5 等）生成对应的扇区布局  
+  Generates sector layout depending on the chip series (e.g., F1/F4/H7/U5)
+
+- 输出包括每个扇区的地址、大小和索引  
+  Output includes address, size, and index of each sector
+
+### 📦 输出内容 (Outputs)
+
+- YAML 格式的 Flash 信息  
+  Flash info in YAML format:
+
+```yaml
+model: STM32F103C8
+flash_base: '0x08000000'
+flash_size_kb: 64
+sectors:
+- index: 0
+  address: '0x08000000'
+  size_kb: 1.0
+- index: 1
+  address: '0x08000400'
+  size_kb: 1.0
+  ...
+```
+
 ---
 
 ### `xr_stm32_it`

{libxr-0.2.2 → libxr-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "libxr"
-version = "0.2.2"
+version = "0.2.3"
 description = "C++ code generator for LibXR-based embedded systems, supporting STM32 and modular robotics applications."
 requires-python = ">=3.8"
 authors = [
@@ -46,6 +46,7 @@ xr_gen_code = "libxr.GeneratorCode:main"
 xr_stm32_it = "libxr.GeneratorSTM32IT:main"
 xr_stm32_cmake = "libxr.GeneratorSTM32CMake:main"
 xr_stm32_clang = "libxr.GeneratorSTM32CMakeClang:main"
+xr_stm32_flash = "libxr.STM32FlashGenerator:main"
 xr_cubemx_cfg = "libxr.ConfigCubemxProject:main"
 
 [tool.setuptools.packages.find]

{libxr-0.2.2 → libxr-0.2.3}/src/libxr/GeneratorCodeSTM32.py

@@ -348,8 +348,10 @@ def generate_dma_resources(project_data: dict) -> str:
                     "buffer_size",
                     DMA_DEFAULT_SIZES[p_type_base]["buffer"]
                 )
-
-                dma_code.append(f"static uint8_t {instance_lower}_buf[{buf_size}];")
+                if p_type_base in ["ADC"]:
+                    dma_code.append(f"static uint16_t {instance_lower}_buf[{int(buf_size/2)}];")
+                else:
+                    dma_code.append(f"static uint8_t {instance_lower}_buf[{buf_size}];")
 
     return "/* DMA Resources */\n" + "\n".join(dma_code) if dma_code else ""
 
@@ -472,7 +474,7 @@ class PeripheralFactory:
 def _generate_header_includes(use_xrobot: bool = False) -> str:
     """Generate essential header inclusions with optional XRobot components."""
     headers = [
-        '#include "app_main.h"',
+        '#include "app_main.h"\n',
         '#include "libxr.hpp"',
         '#include "main.h"',
         '#include "stm32_adc.hpp"',
@@ -485,13 +487,14 @@ def _generate_header_includes(use_xrobot: bool = False) -> str:
         '#include "stm32_spi.hpp"',
         '#include "stm32_timebase.hpp"',
         '#include "stm32_uart.hpp"',
-        '#include "stm32_usb.hpp"'
+        '#include "stm32_usb.hpp"',
+        '#include "flash_map.hpp"'
     ]
 
     if use_xrobot:
         headers.extend([
             '#include "app_framework.hpp"\n'
-            '#include "xrobot_main.hpp"'
+            '#include "xrobot_main.hpp"\n'
         ])
 
     return '\n'.join(headers) + '\n\nusing namespace LibXR;\n'
@@ -764,6 +767,70 @@ void app_main(void);
         logging.info(f"Generated header: {header_path}")
 
 
+def generate_flash_map_cpp(flash_info: dict) -> str:
+    """
+    Convert flash_info dictionary to a C++ constexpr struct array.
+
+    :param flash_info: Output from flash_info_to_dict
+
+    :return: C++ code as a string
+    """
+    lines = [
+        "#include \"stm32_flash.hpp\"",
+        "",
+        "constexpr LibXR::FlashSector FLASH_SECTORS[] = {",
+    ]
+
+    for s in flash_info["sectors"]:
+        index = s["index"]
+        address = int(s["address"], 16)
+        size_kb = int(s["size_kb"])
+        lines.append(f"  {{0x{address:08X}, 0x{(size_kb * 1024):08X}}},")
+
+    lines.append("};\n")
+    lines.append("constexpr size_t FLASH_SECTOR_NUMBER = sizeof(FLASH_SECTORS) / sizeof(LibXR::FlashSector);")
+    return "\n".join(lines)
+
+def inject_flash_layout(project_data: dict, output_dir: str) -> None:
+    """
+    Automatically generate FlashLayout from project_data['Mcu']['Type']
+    and inject it into libxr_settings. Also generates flash_map.hpp.
+
+    :param project_data: Project configuration containing MCU type
+
+    :param output_dir: Output directory for generated flash_map.hpp
+    """
+    try:
+        from libxr.STM32FlashGenerator import layout_flash, flash_info_to_dict
+        mcu_model = project_data.get("Mcu", {}).get("Type", "").strip()
+        if not mcu_model:
+            logging.warning("Cannot find MCU name, skipping FlashLayout generation")
+            return
+
+        flash_info = layout_flash(mcu_model)
+        flash_dict = flash_info_to_dict(flash_info)
+        libxr_settings["FlashLayout"] = flash_dict
+        logging.info(f"FlashLayout is generated and injected, MCU: {mcu_model}")
+
+        cpp_code = generate_flash_map_cpp(flash_dict)
+        if output_dir:
+            hpp_path = os.path.join(output_dir, "flash_map.hpp")
+            with open(hpp_path, "w", encoding="utf-8") as f:
+                f.write(f"""#pragma once
+// Auto-generated Flash Layout Map
+// MCU: {mcu_model}
+
+#include "main.h"
+
+""")
+                f.write(cpp_code)
+            logging.info(f"Flash layout map written to: {hpp_path}")
+    except ImportError as e:
+        logging.warning(f"Cannot import FlashLayout generator: {e}")
+    except Exception as e:
+        logging.warning(f"Cannot generate FlashLayout: {e}")
+
+
 def main():
     try:
         args = parse_arguments()
@@ -788,6 +855,8 @@ def main():
         with open(args.output, "w", encoding="utf-8") as f:
             f.write(output_code)
 
+        inject_flash_layout(project_data, output_dir)
+
         config_path = os.path.join(output_dir, "libxr_config.yaml")
 
         with open(config_path, "w", encoding="utf-8") as f:

libxr-0.2.3/src/libxr/STM32FlashGenerator.py

@@ -0,0 +1,185 @@
+import re
+from dataclasses import dataclass
+from typing import Optional, List
+import sys
+import traceback
+import yaml
+
+
+@dataclass
+class FlashSector:
+    """Flash memory sector information"""
+    index: int
+    address: int
+    size: int
+
+
+@dataclass
+class FlashInfo:
+    """Complete flash memory configuration"""
+    model: str
+    flash_base: int
+    flash_sectors: List[FlashSector]
+    flash_size_kb: Optional[int] = None
+
+
+FLASH_SIZE_CODES = {
+    '4': 16, '6': 32, '8': 64, 'B': 128, 'C': 256, 'D': 384,
+    'E': 512, 'F': 768, 'G': 1024, 'H': 1536, 'I': 2048,
+    'J': 3072, 'K': 4096, 'L': 6144, 'M': 8192, 'N': 12288,
+    'P': 16384, 'Q': 512, 'R': 640, 'S': 768, 'T': 1024, 'Z': 512,
+    '5': 512, '7': 2048, 'A': 1024, 'V': 1024, 'W': 512, 'X': 1024, 'Y': 2048,
+    '1': 256, '3': 8,
+}
+
+
+def get_flash_kb(model: str) -> int:
+    """Get flash size from STM32 model number (original logic preserved)"""
+    model = model.strip().upper()
+
+    # Original condition chain preserved
+    if model.startswith("STM32WL"):
+        if "X" in model:
+            return 1024
+        if any(code in model for code in ['55', '54', '53', '52']):
+            return 512
+        return 512
+    if model.startswith("STM32WBA"):
+        code = model[11]
+        return FLASH_SIZE_CODES.get(code, 512)
+    if model.startswith("STM32WB"):
+        if "7" in model:
+            return 2048
+        if "V" in model:
+            return 1024
+        return 512
+    if model.startswith("STM32U5"):
+        if "A" in model:
+            return 1024
+        code = model[10]
+        return FLASH_SIZE_CODES.get(code, None)
+
+    # Original fallback logic
+    try:
+        return FLASH_SIZE_CODES[model[10]]
+    except (KeyError, IndexError):
+        raise ValueError(f"Unrecognized capacity code for {model}")
+
+
+def layout_flash(model: str) -> FlashInfo:
+    """Flash layout generator (original logic fully preserved)"""
+    model = model.upper()
+    flash_kb = get_flash_kb(model)
+    flash_base = 0x08000000
+    layout = []
+
+    # Original condition chain
+    if "F1" in model:
+        page_size = 1024 if flash_kb <= 128 else 2048
+        layout = [((flash_kb * 1024) // page_size, page_size)]
+    elif "F2" in model or "F4" in model:
+        sector_sizes = [16, 16, 16, 16, 64] + [128] * 12
+        layout = []
+        remaining = flash_kb
+        for size in sector_sizes:
+            if remaining >= size:
+                layout.append((1, size * 1024))
+                remaining -= size
+            else:
+                break
+    elif "U5" in model:
+        layout = [(1, 128 * 1024)] * (flash_kb // 128)
+    elif any(x in model for x in ["WL", "L4", "G0", "G4", "C0", "U0"]):
+        layout = [((flash_kb * 1024) // 2048, 2048)]
+    elif "L0" in model:
+        layout = [((flash_kb * 1024) // 128, 128)]
+    elif "WB" in model:
+        layout = [((flash_kb * 1024) // 4096, 4096)]
+    elif "WBA" in model:
+        layout = [(1, 32 * 1024)] * (flash_kb // 32)
+    elif "H7" in model:
+        layout = [((flash_kb * 1024) // (128 * 1024), 128 * 1024)]
+    elif any(x in model for x in ["F7", "F3", "F0"]):
+        layout = [((flash_kb * 1024) // 2048, 2048)]
+    elif "L1" in model:
+        layout = [((flash_kb * 1024) // 256, 256)]
+    else:
+        layout = [((flash_kb * 1024) // 1024, 1024)]
+
+    # Original sector generation
+    sectors = []
+    addr = flash_base
+    for count, size in layout:
+        for _ in range(count):
+            sectors.append(FlashSector(
+                index=len(sectors),
+                address=addr,
+                size=size
+            ))
+            addr += size
+
+    return FlashInfo(
+        model=model,
+        flash_base=flash_base,
+        flash_sectors=sectors,
+        flash_size_kb=flash_kb
+    )
+
+
+def flash_info_to_dict(info: FlashInfo) -> dict:
+    """Original serialization logic preserved"""
+    return {
+        "model": info.model,
+        "flash_base": f"0x{info.flash_base:08X}",
+        "flash_size_kb": info.flash_size_kb,
+        "sectors": [
+            {"index": s.index, "address": f"0x{s.address:08X}", "size_kb": round(s.size / 1024, 3)}
+            for s in info.flash_sectors
+        ]
+    }
+
+
+def main():
+    """Command line interface for STM32 flash information tool"""
+
+    def validate_model(model: str) -> bool:
+        """Validate STM32 model number format"""
+        return (
+                '-' not in model and
+                model.upper().startswith("STM32") and
+                len(model) > 8
+        )
+
+    if len(sys.argv) != 2:
+        print("STM32 Flash Information Tool")
+        print("Usage:")
+        print(f"  xr_stm32_flash <STM32_MODEL>")
+        print("\nExamples:")
+        print(f"  xr_stm32_flash STM32F103C8T6")
+        print(f"  xr_stm32_flash STM32L476RG")
+        sys.exit(1)
+
+    model = sys.argv[1].strip().upper()
+
+    try:
+        if not validate_model(model):
+            raise ValueError(f"Invalid STM32 model format: {model}")
+
+        info = layout_flash(model)
+        print(yaml.safe_dump(
+            flash_info_to_dict(info),
+            sort_keys=False,
+            allow_unicode=True,
+            default_flow_style=False
+        ))
+
+    except Exception as e:
+        print(f"\nERROR: Failed to process model {model}")
+        print(f"Reason: {str(e)}")
+        print("\nStack trace:")
+        traceback.print_exc()
+        sys.exit(2)
+
+
+if __name__ == '__main__':
+    main()

{libxr-0.2.2 → libxr-0.2.3}/src/libxr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libxr
-Version: 0.2.2
+Version: 0.2.3
 Summary: C++ code generator for LibXR-based embedded systems, supporting STM32 and modular robotics applications.
 Author-email: Xiao <2592509183@qq.com>
 Maintainer-email: Xiao <2592509183@qq.com>
@@ -233,9 +233,54 @@ usage: xr_gen_code_stm32 [-h] -i INPUT -o OUTPUT [--xrobot] [--libxr-config LIBX
   Main entry point with all initialization logic
 
 - `libxr_config.yaml`：  
-  运行时配置文件，可自定义缓冲区大小、队列等参数
+  运行时配置文件，可自定义缓冲区大小、队列等参数  
   Runtime config YAML, can be customized with buffer size, queue, etc.
 
+- `flash_map.hpp`：  
+  自动生成的 Flash 扇区表，供 Flash 抽象层使用  
+  Auto-generated flash sector layout for use with Flash abstraction layer
+
+---
+
+### `xr_stm32_flash`
+
+解析 STM32 型号，生成 Flash 扇区信息表（YAML 格式输出）。  
+Parses STM32 model name and generates flash layout info (YAML output).
+
+```bash
+usage: xr_stm32_flash <STM32_MODEL>
+```
+
+### 🧠 功能说明 (Functionality)
+
+- 根据 STM32 型号名称自动推导 Flash 大小  
+  Automatically infers flash size from the STM32 model string
+
+- 根据芯片系列（如 F1/F4/H7/U5 等）生成对应的扇区布局  
+  Generates sector layout depending on the chip series (e.g., F1/F4/H7/U5)
+
+- 输出包括每个扇区的地址、大小和索引  
+  Output includes address, size, and index of each sector
+
+### 📦 输出内容 (Outputs)
+
+- YAML 格式的 Flash 信息  
+  Flash info in YAML format:
+
+```yaml
+model: STM32F103C8
+flash_base: '0x08000000'
+flash_size_kb: 64
+sectors:
+- index: 0
+  address: '0x08000000'
+  size_kb: 1.0
+- index: 1
+  address: '0x08000400'
+  size_kb: 1.0
+  ...
+```
+
 ---
 
 ### `xr_stm32_it`

{libxr-0.2.2 → libxr-0.2.3}/src/libxr.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/libxr/GeneratorSTM32CMakeClang.py
 src/libxr/GeneratorSTM32IT.py
 src/libxr/PeripheralAnalyzer.py
 src/libxr/PeripheralAnalyzerSTM32.py
+src/libxr/STM32FlashGenerator.py
 src/libxr/__init__.py
 src/libxr.egg-info/PKG-INFO
 src/libxr.egg-info/SOURCES.txt

{libxr-0.2.2 → libxr-0.2.3}/src/libxr.egg-info/entry_points.txt

@@ -6,4 +6,5 @@ xr_parse = libxr.PeripheralAnalyzer:main
 xr_parse_ioc = libxr.PeripheralAnalyzerSTM32:main
 xr_stm32_clang = libxr.GeneratorSTM32CMakeClang:main
 xr_stm32_cmake = libxr.GeneratorSTM32CMake:main
+xr_stm32_flash = libxr.STM32FlashGenerator:main
 xr_stm32_it = libxr.GeneratorSTM32IT:main