54 KiB
54 KiB
arxml_sdk
AUTOSAR ARXML 配置生成 SDK，提供用于创建 AUTOSAR 标准 ARXML 文件的 Python 接口。
版本: 2.0.1
目录
简介
arxml_sdk 是一个用于生成 AUTOSAR ARXML 配置文件的 Python SDK。它提供了完整的 AUTOSAR 数据类型建模能力，包括：
- 基础数据类型（SW-BASE-TYPE）
- 应用数据类型和实现数据类型
- 数据约束和计算方法
- 软件组件和端口定义
- 接口定义（发送-接收、客户端-服务端等）
- SWC 内部行为（Runnable、Event）
特性
- 纯 Python 实现，零外部依赖
- 符合 AUTOSAR R4.4 标准
- 工厂函数模式简化对象创建
- 组合模式支持动态构建
- 所有类型均支持
to_arxml()序列化
快速开始
环境要求
- Python 3.8+
安装
将 src 目录添加到 Python 路径即可使用：
import sys
sys.path.insert(0, '/path/to/arxml_sdk/src')
或直接使用相对导入：
from src import create_arxml_document, write_arxml
最小示例
from src import (
create_arxml_document, write_arxml, create_package,
create_base_type, Category, Encoding
)
doc = create_arxml_document()
base_type = create_base_type("UInt8", size=8, encoding=Encoding.TWO_COMPONENT)
package = create_package("MyPackage", elements=[base_type])
package_element = package.to_arxml(doc)
doc.documentElement.appendChild(package_element)
write_arxml(doc, "minimal.arxml")
架构设计
整体架构图
arxml_sdk/
├── src/ # 源代码
│ ├── __init__.py # 包入口，导出全部公共API
│ ├── core/ # 核心基础设施层
│ │ ├── __init__.py
│ │ ├── base.py # Base 基类
│ │ ├── constants.py # ARXML 标签常量
│ │ └── enums.py # AUTOSAR 枚举类型
│ ├── types/ # 数据类型层
│ │ ├── __init__.py
│ │ ├── base_type.py # 基础数据类型
│ │ ├── unit.py # 单位类型
│ │ ├── data_constraint.py # 数据约束
│ │ ├── compu_method.py # 计算方法
│ │ ├── application_types.py # 应用数据类型
│ │ ├── implementation_types.py # 实现数据类型
│ │ ├── sw_addr_method.py # 软件地址方法
│ │ ├── data_mapping.py # 数据类型映射
│ │ ├── sw_component_type.py # 软件组件类型
│ │ ├── interface.py # 接口定义
│ │ ├── package.py # 包管理
│ │ └── swc_internal_behavior.py # SWC内部行为
│ └── utils/ # 工具层
│ ├── __init__.py
│ └── arxml_writer.py # ARXML文档写入
└── tests/ # 测试
模块职责
core 模块 - 核心基础设施层
提供 SDK 运行所需的基础组件，不依赖其他业务模块。
| 文件 | 职责 | 关键类/函数 |
|---|---|---|
| base.py | 定义所有类型的基础类 | Base (dataclass), create_uuid(), create_text_element() |
| constants.py | ARXML 标签常量统一管理 | 约140个XML标签常量定义 |
| enums.py | AUTOSAR 枚举类型定义 | Category, Encoding, PortDirection 等12个枚举 |
Base 类核心属性：
| 属性 | 类型 | 说明 |
|---|---|---|
| name | str | 元素名称 |
| id | Optional[int] | 元素标识符 |
| parent | Optional[Base] | 父元素引用 |
| description | Optional[str] | 元素描述 |
| package_path | str | 完整包路径 (如 /Pkg1/Pkg2/Name) |
Base 类核心方法：
| 方法 | 说明 |
|---|---|
| to_arxml(doc) | 抽象方法，将对象序列化为 ARXML DOM 元素 |
| class_name | 属性，获取类型名称 |
| parent_id | 属性，获取父类 ID |
types 模块 - 数据类型层
实现 AUTOSAR 数据模型的各个类型，依赖 core 模块。
| 文件 | 职责 | 主要类 |
|---|---|---|
| base_type.py | 基础数据类型 (SW-BASE-TYPE) | BaseType |
| unit.py | 数据单位 | Unit |
| data_constraint.py | 数据约束范围 | DataConstraint |
| compu_method.py | 计算方法 (线性转换/文本表) | Linear, TextTable, CompuMethod |
| application_types.py | 应用层数据类型 | ApplicationBooleanDataType, ApplicationValueDataType, ApplicationStructureDataType, ApplicationArrayDataType |
| implementation_types.py | 实现层数据类型 | ImplementationValueDataType, ImplementationStructureDataType, ImplementationArrayDataType |
| sw_addr_method.py | 软件地址方法 | SwAddrMethod |
| data_mapping.py | 应用-实现类型映射 | DataTypeMapping, DataTypeMappingSet |
| sw_component_type.py | 软件组件类型和端口 | ApplicationSwComponentType, RPortPrototype, PPortPrototype, PRPortPrototype |
| interface.py | 接口定义 | SenderReceiverInterface, ClientServerInterface, ModeSwitchInterface |
| package.py | AUTOSAR 包 | Package |
| swc_internal_behavior.py | SWC 内部行为 | RunnableEntity, TimingEvent, InitEvent, SwcInternalBehavior |
utils 模块 - 工具层
提供 ARXML 文档创建和写入功能。
| 文件 | 职责 | 关键函数 |
|---|---|---|
| arxml_writer.py | ARXML 文档创建和写入 | create_arxml_document(), write_arxml(), write_arxml_pretty() |
类型继承体系
Base (core.base)
├── BaseType (types.base_type)
├── Unit (types.unit)
├── DataConstraint (types.data_constraint)
├── CompuMethod (types.compu_method)
│ ├── Linear
│ └── TextTable
├── ApplicationDataType (types.application_types)
│ ├── ApplicationBooleanDataType
│ ├── ApplicationValueDataType
│ ├── ApplicationStructureDataType
│ │ └── StructureElement (内部类)
│ └── ApplicationArrayDataType
│ └── ArrayElement (内部类)
├── ImplementationDataType (types.implementation_types)
│ ├── ImplementationValueDataType
│ ├── ImplementationStructureDataType
│ │ └── StructureElement (内部类)
│ └── ImplementationArrayDataType
│ └── ArrayElement (内部类)
├── SwAddrMethod (types.sw_addr_method)
├── DataTypeMapping (types.data_mapping)
│ └── DataTypeMappingSet
├── SwComponentType (types.sw_component_type)
│ ├── AtomicComponentType
│ │ └── ApplicationSwComponentType
│ └── CompositionSwComponentType
├── PortPrototype (types.sw_component_type)
│ ├── RPortPrototype
│ ├── PPortPrototype
│ └── PRPortPrototype
├── Interface (types.interface)
│ ├── SenderReceiverInterface
│ │ └── DataElement (内部类)
│ ├── ClientServerInterface
│ │ ├── Operation (内部类)
│ │ └── Argument (内部类)
│ ├── ModeSwitchInterface
│ ├── ParameterInterface
│ ├── TriggerInterface
│ └── NvDataInterface
├── Package (types.package)
└── SwcInternalBehavior (types.swc_internal_behavior)
├── RunnableEntity
└── EventType (Union)
├── InitEvent
├── TimingEvent
├── OperationInvokedEvent
└── DataReceivedEvent
依赖关系图
┌─────────────────────────────────────┐
│ arxml_sdk (src/__init__.py) │
│ 导出全部 193 个公共 API 符号 │
└─────────────────────────────────────┘
│
┌───────────────────────────┼───────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ core 模块 │ │ types 模块 │ │ utils 模块 │
│ (基础设施层) │ │ (业务逻辑层) │ │ (工具层) │
├─────────────────┤ ├─────────────────┤ ├─────────────────┤
│ Base 基类 │ │ 数据类型类 │ │ ARXML文档创建 │
│ 常量定义 │◄─────►│ 组件类型类 │ │ ARXML文件写入 │
│ 枚举定义 │ │ 接口定义类 │ │ │
│ UUID/文本工具 │ │ 包管理类 │ │ │
└─────────────────┘ │ 内部行为类 │ └─────────────────┘
└─────────────────┘
│
▼
┌─────────────────┐
│ tests 模块 │
│ (测试层) │
├─────────────────┤
│ 单元测试 │
│ 集成测试 │
└─────────────────┘
依赖约束：
core→ 无依赖（最底层）types→ 依赖coreutils→ 依赖coretests→ 依赖src所有模块
设计模式
1. 工厂函数模式
所有类型都配有 create_xxx() 工厂函数，简化对象创建：
# 使用工厂函数
uint8 = create_base_type("UInt8", size=8)
# 替代直接实例化（如果存在构造函数）
uint8 = BaseType(name="UInt8", size=8)
2. 组合模式
通过 add_xxx() 方法支持动态添加子元素：
component = ApplicationSwComponentType(name="Sensor")
component.add_port(PPortPrototype(name="DataPort"))
3. 序列化模式
所有类型都实现 to_arxml(doc) 方法，将自身序列化为 ARXML DOM 元素：
element = component.to_arxml(doc)
4. 数据类模式
使用 @dataclass 简化数据类定义：
@dataclass
class BaseType:
name: str
size: int
category: Optional[Category] = None
encoding: Optional[Encoding] = None
数据流
用户代码
│
▼
创建对象 (工厂函数)
│
├──► BaseType, ApplicationDataType, SwComponentType 等
│
▼
序列化 (to_arxml)
│
├──► XML DOM Element
│
▼
写入文件 (arxml_writer)
│
▼
.arxml 文件
技术栈
| 方面 | 详情 |
|---|---|
| 编程语言 | Python 3 |
| 标准库 | uuid, xml.dom.minidom, dataclasses, typing, enum |
| 测试框架 | pytest |
| 目标格式 | AUTOSAR ARXML (R4.4 schema) |
| 版本 | 2.0.1 |
核心模块 (core)
Base 类
所有类型的基类，提供通用的属性和方法。
文件位置： src/core/base.py
from src.core.base import Base
属性
| 属性名 | 类型 | 说明 |
|---|---|---|
name |
str | 元素名称 |
id |
Optional[int] | 元素标识符 |
parent |
Optional[Base] | 父元素引用 |
description |
Optional[str] | 元素描述 |
只读属性
| 属性名 | 类型 | 说明 |
|---|---|---|
class_name |
str | 获取类型名称 (如 "ApplicationValueDataType") |
parent_id |
Optional[int] | 获取父类的 id |
package_path |
str | 获取完整包路径 (如 "/Package/SubPackage/Name") |
方法
to_arxml(doc: Document) -> Element
将对象序列化为 ARXML DOM 元素。必须被子类重写。
参数：
doc: XML Document 对象
返回：
- ARXML DOM Element
公共函数
create_uuid() -> str
生成一个 UUID 字符串。
from src.core.base import create_uuid
uuid = create_uuid() # e.g., "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
create_text_element(doc: Document, tag: str, text: str) -> Element
创建带有文本内容的 XML 元素。
参数：
doc: XML Document 对象tag: XML 标签名text: 元素文本内容
返回：
- XML Element
示例：
from src.core.base import create_text_element
from src.utils import create_arxml_document
doc = create_arxml_document()
element = create_text_element(doc, "SHORT-NAME", "MyElement")
枚举类型
Category
数据类型分类枚举。
文件位置： src/core/enums.py
from src import Category
| 枚举值 | 说明 |
|---|---|
FIXED_LENGTH |
固定长度 |
IDENTICAL |
相同 |
TEXT_TABLE |
文本表 |
LINEAR |
线性 |
BOOLEAN |
布尔 |
VALUE |
值类型 |
STRUCTURE |
结构体 |
ARRAY |
数组 |
SCALE_LINEAR |
缩放线性 |
RECORD |
记录 |
UNION |
联合 |
DATA_REFERENCE |
数据引用 |
TYPE_REFERENCE |
类型引用 |
Encoding
数据编码格式枚举。
from src import Encoding
| 枚举值 | 说明 |
|---|---|
ONE_COMPONENT |
单组件 |
TWO_COMPONENT |
双组件 |
BCD_P |
BCD Plus |
BCD_UP |
BCD Up |
IEEE754 |
IEEE754 浮点数 |
ISO_8859_1 |
ISO-8859-1 编码 |
UTF_8 |
UTF-8 编码 |
UCS_2 |
UCS-2 编码 |
NONE |
无编码 |
VOID |
Void |
BOOLEAN |
布尔 |
UTF_16 |
UTF-16 编码 |
CalibrationAccess
校准访问权限枚举。
from src import CalibrationAccess
| 枚举值 | 说明 |
|---|---|
READ_ONLY |
只读 |
NOT_ACCESSIBLE |
不可访问 |
READ_WRITE |
读写 |
NOT_SPECIFIED |
未指定 |
SwCalibrationAccess
校准访问权限枚举（向后兼容版本）。
from src import SwCalibrationAccess
| 枚举值 | 说明 |
|---|---|
ReadOnly |
只读 |
NotAccessible |
不可访问 |
ReadWrite |
读写 |
NotSpecified |
未指定 |
UpperSts / LowerSts
上下限区间状态枚举。
from src import UpperSts, LowerSts
| 枚举值 | 说明 |
|---|---|
CLOSED |
闭区间 |
OPEN |
开区间 |
ConstraintSpecified
约束指定类型枚举。
from src import ConstraintSpecified
| 枚举值 | 说明 |
|---|---|
PHYSICAL |
物理值约束 |
INTERNAL |
内部值约束 |
CompuContents
转换内容方向枚举。
from src import CompuContents
| 枚举值 | 说明 |
|---|---|
USE_INTERNAL_TO_PHYSICAL |
使用内部到物理的转换 |
USE_PHYSICAL_TO_INTERNAL |
使用物理到内部的转换 |
ComponentType
组件类型枚举。
from src import ComponentType
| 枚举值 | 说明 |
|---|---|
COMPOSITION |
组合组件 |
ATOMIC |
原子组件 |
AtomicType
原子组件类型枚举。
from src import AtomicType
| 枚举值 | 说明 |
|---|---|
APPLICATION |
应用组件 |
SENSOR_ACTUATOR |
传感器/执行器组件 |
HARDWARE_ABSTRACTION |
硬件抽象组件 |
COMPLEX_DRIVER |
复杂驱动组件 |
SERVICE_PROXY |
服务代理组件 |
ImplementationCodeType
实现代码类型枚举。
from src import ImplementationCodeType
| 枚举值 | 说明 |
|---|---|
SOURCE_CODE |
源代码 |
OBJECT_CODE |
目标代码 |
AccessPoint
访问点枚举。
from src import AccessPoint
| 枚举值 | 说明 |
|---|---|
READ |
读取 |
WRITE |
写入 |
PortDirection
端口方向枚举。
from src import PortDirection
| 枚举值 | 说明 |
|---|---|
IN |
输入端口 |
OUT |
输出端口 |
Semantic
数组大小语义枚举。
from src import Semantic
| 枚举值 | 说明 |
|---|---|
FIXED |
固定大小 |
VARIABLE |
可变大小 |
SectionType
段类型枚举。
from src import SectionType
| 枚举值 | 说明 |
|---|---|
CODE |
代码段 |
DATA |
数据段 |
CONST |
常量段 |
Policy
数据策略枚举。
from src import Policy
| 枚举值 | 说明 |
|---|---|
STANDARD |
标准策略 |
EXTENDED |
扩展策略 |
数据类型模块 (types)
BaseType
基础数据类型，表示最底层的原生类型定义。
文件位置： src/types/base_type.py
from src import BaseType, create_base_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
size |
int | 是 | 位大小 (如 8, 16, 32) |
category |
Optional[Category] | 否 | 分类类型 |
encoding |
Optional[Encoding] | 否 | 编码格式 |
native_description |
Optional[str] | 否 | 原生描述 |
工厂函数
create_base_type(name: str, size: int, category: Optional[Category] = None, encoding: Optional[Encoding] = None, native_description: Optional[str] = None) -> BaseType
创建 BaseType 实例的工厂函数。
示例：
# 创建 8 位无符号整数类型
uint8 = create_base_type(
name="UInt8",
size=8,
category=Category.FIXED_LENGTH,
encoding=Encoding.TWO_COMPONENT
)
Unit
数据单位，用于物理量的表示。
文件位置： src/types/unit.py
from src import Unit, create_unit
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 单位名称 |
display |
Optional[str] | 否 | 显示名称 |
factor |
Optional[float] | 否 | 因子 |
offset |
Optional[float] | 否 | 偏移量 |
工厂函数
create_unit(name: str, display: Optional[str] = None, factor: Optional[float] = None, offset: Optional[float] = None) -> Unit
创建 Unit 实例的工厂函数。
示例：
unit = create_unit(
name="km_per_hour",
display="km/h",
factor=1.0,
offset=0.0
)
DataConstraint
数据约束，定义有效值范围。
文件位置： src/types/data_constraint.py
from src import DataConstraint, create_data_constraint
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 约束名称 |
unit |
Optional[Unit] | 否 | 关联的单位 |
lower |
Optional[float] | 否 | 下限值 |
upper |
Optional[float] | 否 | 上限值 |
lower_sts |
Optional[LowerSts] | 否 | 下限状态 (CLOSED/OPEN) |
upper_sts |
Optional[UpperSts] | 否 | 上限状态 (CLOSED/OPEN) |
constraint_specified |
Optional[ConstraintSpecified] | 否 | 约束类型 |
工厂函数
create_data_constraint(name: str, lower: Optional[float] = None, upper: Optional[float] = None, unit: Optional[Unit] = None, lower_sts: Optional[LowerSts] = None, upper_sts: Optional[UpperSts] = None, constraint_specified: Optional[ConstraintSpecified] = None) -> DataConstraint
创建 DataConstraint 实例的工厂函数。
示例：
constraint = create_data_constraint(
name="SpeedConstraint",
lower=0,
upper=250,
lower_sts=LowerSts.CLOSED,
upper_sts=UpperSts.OPEN
)
CompuMethod
计算方法，定义内部值与物理值之间的转换关系。
文件位置： src/types/compu_method.py
from src import CompuMethod, Linear, TextTable, create_linear, create_text_table, create_compu_method
Linear 类
线性转换方法。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
factor |
float | 是 | 缩放因子 |
offset |
float | 是 | 偏移量 |
转换公式：physical = factor * internal + offset
工厂函数
create_linear(factor: float, offset: float) -> Linear
TextTable 类
文本表转换方法。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
vt |
str | 是 | 文本值 |
lower |
Optional[int] | 否 | 下限 |
upper |
Optional[int] | 否 | 上限 |
lower_sts |
Optional[LowerSts] | 否 | 下限状态 |
upper_sts |
Optional[UpperSts] | 否 | 上限状态 |
工厂函数
create_text_table(vt: str, lower: Optional[int] = None, upper: Optional[int] = None, lower_sts: Optional[LowerSts] = None, upper_sts: Optional[UpperSts] = None) -> TextTable
CompuMethod 类
完整的计算方法。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 方法名称 |
unit |
Optional[Unit] | 否 | 单位 |
linear |
Optional[Linear] | 否 | 线性转换 |
text_tables |
Optional[List[TextTable]] | 否 | 文本表列表 |
category |
Optional[Category] | 否 | 分类 |
compu_contents |
Optional[CompuContents] | 否 | 转换内容方向 |
方法
| 方法 | 说明 |
|---|---|
get_text_table(vt: str) -> Optional[TextTable] |
根据文本值查找文本表 |
add_text_table(text_table: TextTable) |
添加文本表 |
工厂函数
create_compu_method(name: str, unit: Optional[Unit] = None, linear: Optional[Linear] = None, text_tables: Optional[List[TextTable]] = None, category: Optional[Category] = None, compu_contents: Optional[CompuContents] = None) -> CompuMethod
示例：
# 创建带线性转换的计算方法
linear = create_linear(factor=0.01, offset=0)
compu = create_compu_method(
name="SpeedConversion",
linear=linear,
category=Category.LINEAR
)
# 创建带文本表的计算方法
table = create_text_table(vt="OK", lower=0, upper=0)
compu = create_compu_method(
name="StatusConversion",
text_tables=[table],
category=Category.TEXT_TABLE
)
应用数据类型
ApplicationBooleanDataType
布尔类型应用数据。
文件位置： src/types/application_types.py
from src import ApplicationBooleanDataType, create_boolean_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
compu_method |
Optional[CompuMethod] | 否 | 计算方法 |
data_constraint |
Optional[DataConstraint] | 否 | 数据约束 |
工厂函数
create_boolean_type(name: str, compu_method: Optional[CompuMethod] = None, data_constraint: Optional[DataConstraint] = None) -> ApplicationBooleanDataType
ApplicationValueDataType
标量值类型应用数据。
from src import ApplicationValueDataType, create_value_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
unit |
Optional[Unit] | 否 | 单位 |
compu_method |
Optional[CompuMethod] | 否 | 计算方法 |
data_constraint |
Optional[DataConstraint] | 否 | 数据约束 |
工厂函数
create_value_type(name: str, unit: Optional[Unit] = None, compu_method: Optional[CompuMethod] = None, data_constraint: Optional[DataConstraint] = None) -> ApplicationValueDataType
ApplicationStructureDataType
结构体类型应用数据。
from src import ApplicationStructureDataType, create_structure_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
structure_elements |
Optional[List[StructureElement]] | 否 | 结构体成员列表 |
嵌套类：StructureElement
结构体成员元素。
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 成员名称 |
data_type |
Base | 是 | 数据类型 |
offset |
Optional[int] | 否 | 位偏移 |
方法
| 方法 | 说明 |
|---|---|
get_element(name: str) -> Optional[StructureElement] |
查找成员 |
add_element(element: StructureElement) |
添加成员 |
工厂函数
create_structure_type(name: str, elements: Optional[List[ApplicationStructureDataType.StructureElement]] = None) -> ApplicationStructureDataType
ApplicationArrayDataType
数组类型应用数据。
from src import ApplicationArrayDataType, create_array_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
element |
Optional[ArrayElement] | 否 | 数组元素 |
嵌套类：ArrayElement
数组元素配置。
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
length |
int | 是 | 数组长度 |
data_type |
Base | 是 | 元素数据类型 |
array_size_semantics |
Optional[Semantic] | 否 | 大小语义 |
工厂函数
create_array_type(name: str, element: Optional[ApplicationArrayDataType.ArrayElement] = None) -> ApplicationArrayDataType
实现数据类型
ImplementationValueDataType
实现层标量值类型。
文件位置： src/types/implementation_types.py
from src import ImplementationValueDataType, create_impl_value_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
base_type |
Optional[BaseType] | 否 | 基础类型 |
compu_method |
Optional[CompuMethod] | 否 | 计算方法 |
data_constraint |
Optional[DataConstraint] | 否 | 数据约束 |
工厂函数
create_impl_value_type(name: str, base_type: Optional[BaseType] = None, compu_method: Optional[CompuMethod] = None, data_constraint: Optional[DataConstraint] = None) -> ImplementationValueDataType
ImplementationStructureDataType
实现层结构体类型。
from src import ImplementationStructureDataType, create_impl_structure_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
structure_elements |
Optional[List[StructureElement]] | 否 | 结构体成员列表 |
嵌套类：StructureElement
与 ApplicationStructureDataType.StructureElement 结构相同。
工厂函数
create_impl_structure_type(name: str, elements: Optional[List[ImplementationStructureDataType.StructureElement]] = None) -> ImplementationStructureDataType
ImplementationArrayDataType
实现层数组类型。
from src import ImplementationArrayDataType, create_impl_array_type
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 类型名称 |
element |
Optional[ArrayElement] | 否 | 数组元素 |
嵌套类：ArrayElement
与 ApplicationArrayDataType.ArrayElement 结构相同。
工厂函数
create_impl_array_type(name: str, element: Optional[ImplementationArrayDataType.ArrayElement] = None) -> ImplementationArrayDataType
SwAddrMethod
软件地址方法，定义代码/数据的内存段。
文件位置： src/types/sw_addr_method.py
from src import SwAddrMethod, create_sw_addr_method, SectionType
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 方法名称 |
section_type |
Optional[SectionType] | 否 | 段类型 (CODE/DATA/CONST) |
工厂函数
create_sw_addr_method(name: str, section_type: Optional[SectionType] = None) -> SwAddrMethod
示例：
# 代码段地址方法
code_method = create_sw_addr_method("CODE", section_type=SectionType.CODE)
# 数据段地址方法
data_method = create_sw_addr_method("DATA", section_type=SectionType.DATA)
数据类型映射
DataTypeMapping
应用类型到实现类型的映射。
文件位置： src/types/data_mapping.py
from src import DataTypeMapping, create_data_type_mapping
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 映射名称 |
application_data_type |
Base | 是 | 应用数据类型 |
implementation_data_type |
Base | 是 | 实现数据类型 |
工厂函数
create_data_type_mapping(name: str, application_data_type: Base, implementation_data_type: Base) -> DataTypeMapping
DataTypeMappingSet
数据类型映射集合。
from src import DataTypeMappingSet, create_data_type_mapping_set
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 集合名称 |
data_type_mappings |
Optional[List[DataTypeMapping]] | 否 | 映射列表 |
���法
| 方法 | 说明 |
|---|---|
get_mapping(name: str) -> Optional[DataTypeMapping] |
查找映射 |
add_mapping(mapping: DataTypeMapping) |
添加映射 |
工厂函数
create_data_type_mapping_set(name: str, mappings: Optional[List[DataTypeMapping]] = None) -> DataTypeMappingSet
接口
Interface
接口基类。
文件位置： src/types/interface.py
from src import Interface
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 接口名称 |
is_service |
bool | 否 | 是否为服务接口 (默认 False) |
SenderReceiverInterface
发送-接收接口，用于数据信号传递。
from src import SenderReceiverInterface, create_sender_receiver_interface, Policy, CalibrationAccess
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 接口名称 |
data_element |
Optional[SenderReceiverInterface.DataElement] | 否 | 数据元素 |
is_service |
bool | 否 | 是否为服务接口 |
嵌套类：DataElement
数据元素定义。
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 元素名称 |
sw_addr_method |
Optional[SwAddrMethod] | 否 | 地址方法 |
data_constraint |
Optional[DataConstraint] | 否 | 数据约束 |
data_type |
Base | 是 | 数据类型 |
policy |
Optional[Policy] | 否 | 数据策略 |
calibration_access |
Optional[CalibrationAccess] | 否 | 校准访问权限 |
工厂函数
create_sender_receiver_interface(name: str, data_element: Optional[SenderReceiverInterface.DataElement] = None, is_service: bool = False) -> SenderReceiverInterface
ClientServerInterface
客户端-服务端接口，用于服务调用。
from src import ClientServerInterface
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 接口名称 |
operations |
Optional[List[Operation]] | 否 | 操作列表 |
is_service |
bool | 否 | 是否为服务接口 |
嵌套类：Operation
服务操作定义。
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 操作名称 |
is_server |
bool | 否 | 是否为服务端 |
arguments |
Optional[List[Argument]] | 否 | 参数列表 |
嵌套类：Argument
操作参数定义。
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 参数名称 |
direction |
PortDirection | 是 | 参数方向 (IN/OUT) |
data_type |
Base | 是 | 参数数据类型 |
方法
| 方法 | 说明 |
|---|---|
get_operation(name: str) -> Optional[Operation] |
查找操作 |
add_operation(operation: Operation) |
添加操作 |
软件组件类型
SwComponentType
软件组件类型基类。
文件位置： src/types/sw_component_type.py
from src import SwComponentType, ComponentType
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 组件名称 |
component_type |
Optional[ComponentType] | 否 | 组件类型 |
ApplicationSwComponentType
应用软件组件类型。
from src import ApplicationSwComponentType
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 组件名称 |
supports_multiple_instantiation |
bool | 否 | 是否支持多实例化 |
atomic_type |
Optional[AtomicType] | 否 | 原子类型 |
implementation_code_type |
Optional[ImplementationCodeType] | 否 | 实现代码类型 |
ports |
Optional[List[PortPrototype]] | 否 | 端口列表 |
internal_behavior |
Optional[SwcInternalBehavior] | 否 | 内部行为 |
方法
| 方法 | 说明 |
|---|---|
get_port(name: str) -> Optional[PortPrototype] |
查找端口 |
add_port(port: PortPrototype) |
添加端口 |
PortPrototype
端口原型基类。
from src import PortPrototype, PortDirection
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 端口名称 |
interface |
Optional[Interface] | 否 | 关联接口 |
RPortPrototype
接收端口 (Required Port)。
from src import RPortPrototype
继承自 PortPrototype，用于从其他组件接收数据。
PPortPrototype
发送端口 (Provided Port)。
from src import PPortPrototype
继承自 PortPrototype，用于向其他组件发送数据。
PRPortPrototype
双向端口 (Provided Required Port)。
from src import PRPortPrototype
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 端口名称 |
interface |
Optional[Interface] | 否 | 提供接口 |
required_interface |
Optional[Interface] | 否 | 需求接口 |
Package
AUTOSAR 包，用于组织和管理元素。
文件位置： src/types/package.py
from src import Package, create_package
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 包名称 |
elements |
Optional[List[Base]] | 否 | 包内元素列表 |
方法
| 方法 | 说明 |
|---|---|
get_element(name: str) -> Optional[Base] |
查找元素 |
add_element(element: Base) |
添加元素 (支持覆盖同名元素) |
工厂函数
create_package(name: str, elements: Optional[List[Base]] = None) -> Package
示例：
# 创建包并添加元素
pkg = create_package("SensorPkg", elements=[
base_type,
impl_type,
interface,
component
])
SwcInternalBehavior
软件组件内部行为。
文件位置： src/types/swc_internal_behavior.py
from src import SwcInternalBehavior, RunnableEntity, create_runnable_entity, create_timing_event, create_init_event
VariableAccess
变量访问定义。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 访问名称 |
port_prototype_ref |
Optional[str] | 否 | 端口原型引用 |
target_data_prototype_ref |
Optional[str] | 否 | 目标数据原型引用 |
RunnableEntity
可运行实体 (Runnable)。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | Runnable 名称 |
minimum_start_interval |
Optional[float] | 否 | 最小启动间隔 (秒) |
can_be_invoked_concurrently |
bool | 否 | 是否可并发调用 |
data_receive_points |
Optional[List[VariableAccess]] | 否 | 数据接收点 |
data_send_points |
Optional[List[VariableAccess]] | 否 | 数据发送点 |
variable_accesses |
Optional[List[VariableAccess]] | 否 | 变量访问列表 |
symbol |
Optional[str] | 否 | 符号 (函数名) |
sw_addr_method_ref |
Optional[SwAddrMethod] | 否 | 地址方法引用 |
方法
| 方法 | 说明 |
|---|---|
add_data_receive_point(access: VariableAccess) |
添加数据接收点 |
add_data_send_point(access: VariableAccess) |
添加数据发送点 |
add_variable_access(access: VariableAccess) |
添加变量访问 |
工厂函数
create_runnable_entity(name: str, symbol: Optional[str] = None, minimum_start_interval: Optional[float] = None) -> RunnableEntity
事件类型
InitEvent
初始化事件。
from src import InitEvent
event = InitEvent(name="Init", runnable_ref="MyRunnable")
TimingEvent
定时事件。
from src import TimingEvent, create_timing_event
event = create_timing_event(name="Timing_10ms", period=0.01)
构造函数属性：
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 事件名称 |
period |
float | 是 | 周期 (秒) |
OperationInvokedEvent
操作调用事件。
from src import OperationInvokedEvent, create_operation_invoked_event
event = create_operation_invoked_event(name="OpInvoke", operation_ref="MyOperation")
DataReceivedEvent
数据接收事件。
from src import DataReceivedEvent, create_data_received_event
event = create_data_received_event(name="DataRx", data_element_ref="MyDataElement", period=0.01)
SwcInternalBehavior
软件组件内部行为容器。
构造函数属性
| 属性名 | 类型 | 必填 | 说明 |
|---|---|---|---|
name |
str | 是 | 行为名称 |
runnable_entities |
Optional[List[RunnableEntity]] | 否 | Runnable 列表 |
events |
Optional[List[Union[InitEvent, TimingEvent, OperationInvokedEvent, DataReceivedEvent]]] | 否 | 事件列表 |
symbol |
Optional[str] | 否 | 符号前缀 |
方法
| 方法 | 说明 |
|---|---|
get_runnable(name: str) -> Optional[RunnableEntity] |
查找 Runnable |
add_runnable(runnable: RunnableEntity) |
添加 Runnable |
get_event(name: str) -> Optional[Event] |
查找事件 |
add_event(event: Event) |
添加事件 |
工厂函数
create_swc_internal_behavior(name: str, runnable_entities: Optional[List[RunnableEntity]] = None, events: Optional[List[Event]] = None) -> SwcInternalBehavior
工具模块 (utils)
create_arxml_document() -> Document
创建标准 ARXML 文档，包含 AUTOSAR 命名空间。
文件位置： src/utils/arxml_writer.py
from src import create_arxml_document
doc = create_arxml_document()
返回：
- xml.dom.minidom.Document 对象
write_arxml(doc: Document, filepath: str, encoding: str = 'utf-8') -> None
将 Document 写入文件 (紧凑格式)。
from src import create_arxml_document, write_arxml
doc = create_arxml_document()
# ... 添加内容 ...
write_arxml(doc, "output.arxml")
write_arxml_pretty(doc: Document, filepath: str, encoding: str = 'utf-8') -> None
将 Document 写入文件 (格式化输出)。
from src import create_arxml_document, write_arxml_pretty
doc = create_arxml_document()
# ... 添加内容 ...
write_arxml_pretty(doc, "output_formatted.arxml")
get_ar_packages_element(doc: Document) -> Element
获取 AR-PACKAGES 根元素。
from src import get_ar_packages_element
doc = create_arxml_document()
packages = get_ar_packages_element(doc)
add_package_to_document(doc: Document, package_element: Element) -> None
将 Package 元素添加到文档。
from src import add_package_to_document
pkg_element = package.to_arxml(doc)
add_package_to_document(doc, pkg_element)
使用指南
基础类型创建
创建基本整数类型
from src import create_base_type, Category, Encoding
uint8 = create_base_type("UInt8", size=8, encoding=Encoding.TWO_COMPONENT)
uint16 = create_base_type("UInt16", size=16, encoding=Encoding.TWO_COMPONENT)
sint8 = create_base_type("Sint8", size=8, encoding=Encoding.TWO_COMPONENT)
float32 = create_base_type("Float32", size=32, encoding=Encoding.IEEE754)
创建带文本表的类型
from src import (
create_base_type, create_unit, create_data_constraint,
create_linear, create_text_table, create_compu_method,
Category, LowerSts, UpperSts
)
unit = create_unit("km/h", display="km/h", factor=1.0, offset=0.0)
constraint = create_data_constraint(
"SpeedConstraint",
lower=0, upper=250,
lower_sts=LowerSts.CLOSED,
upper_sts=UpperSts.OPEN
)
linear = create_linear(factor=0.01, offset=0)
compu = create_compu_method(
"SpeedConversion",
unit=unit,
linear=linear,
category=Category.LINEAR
)
value_type = create_value_type(
"Speed",
unit=unit,
compu_method=compu,
data_constraint=constraint
)
应用数据类型
布尔类型
from src import create_boolean_type, create_compu_method, create_linear, Category
bool_compu = create_compu_method(
"BoolConversion",
linear=create_linear(factor=1, offset=0),
category=Category.BOOLEAN
)
bool_type = create_boolean_type("ErrorFlag", compu_method=bool_compu)
值类型
from src import create_value_type, create_unit, create_linear, create_compu_method, Category
unit = create_unit("deg", display="°C")
linear = create_linear(factor=0.1, offset=-40)
compu = create_compu_method("Temperature", unit=unit, linear=linear, category=Category.LINEAR)
temp_type = create_value_type("Temperature", unit=unit, compu_method=compu)
结构体类型
from src import (
ApplicationStructureDataType, create_value_type,
create_unit, create_linear, create_compu_method
)
unit = create_unit("V")
linear = create_linear(factor=0.001, offset=0)
compu = create_compu_method("Voltage", unit=unit, linear=linear, category=Category.LINEAR)
voltage_type = create_value_type("Voltage", unit=unit, compu_method=compu)
current_type = create_value_type("Current", unit=unit, compu_method=compu)
structure = ApplicationStructureDataType(name="PowerData")
structure.add_element(
ApplicationStructureDataType.StructureElement(name="voltage", data_type=voltage_type, offset=0)
)
structure.add_element(
ApplicationStructureDataType.StructureElement(name="current", data_type=current_type, offset=32)
)
数组类型
from src import ApplicationArrayDataType, create_value_type, create_unit, Semantic
element_type = create_value_type("SensorValue", unit=create_unit("counts"))
array_type = ApplicationArrayDataType(name="SensorData")
array_type.element = ApplicationArrayDataType.ArrayElement(
length=10,
data_type=element_type,
array_size_semantics=Semantic.FIXED
)
实现数据类型
值类型
from src import create_impl_value_type, create_base_type, create_value_type, Encoding
base_type = create_base_type("UInt16", size=16, encoding=Encoding.TWO_COMPONENT)
app_type = create_value_type("AppCounter")
impl_type = create_impl_value_type("ImplCounter", base_type=base_type)
结构体类型
from src import ImplementationStructureDataType, create_impl_value_type, create_base_type, Encoding
base_u8 = create_base_type("UInt8", size=8, encoding=Encoding.TWO_COMPONENT)
base_u16 = create_base_type("UInt16", size=16, encoding=Encoding.TWO_COMPONENT)
impl_u8 = create_impl_value_type("ImplUInt8", base_type=base_u8)
impl_u16 = create_impl_value_type("ImplUInt16", base_type=base_u16)
struct_type = ImplementationStructureDataType(name="ImplStatus")
struct_type.add_element(
ImplementationStructureDataType.StructureElement(name="status", data_type=impl_u8, offset=0)
)
struct_type.add_element(
ImplementationStructureDataType.StructureElement(name="value", data_type=impl_u16, offset=8)
)
数组类型
from src import ImplementationArrayDataType, create_impl_value_type, create_base_type, Semantic, Encoding
base = create_base_type("UInt32", size=32, encoding=Encoding.TWO_COMPONENT)
element_type = create_impl_value_type("ImplUInt32", base_type=base)
impl_array = ImplementationArrayDataType(name="ImplBuffer")
impl_array.element = ImplementationArrayDataType.ArrayElement(
length=16,
data_type=element_type,
array_size_semantics=Semantic.FIXED
)
数据类型映射
from src import (
DataTypeMapping, DataTypeMappingSet,
create_value_type, create_impl_value_type, create_base_type, Encoding
)
base = create_base_type("UInt8", size=8, encoding=Encoding.TWO_COMPONENT)
app_type = create_value_type("AppStatus")
impl_type = create_impl_value_type("ImplStatus", base_type=base)
mapping = DataTypeMapping(
name="StatusMapping",
application_data_type=app_type,
implementation_data_type=impl_type
)
mapping_set = DataTypeMappingSet(name="DefaultMappings")
mapping_set.add_mapping(mapping)
接口定义
发送-接收接口
from src import (
SenderReceiverInterface, create_sender_receiver_interface,
create_value_type, create_unit, Policy, CalibrationAccess
)
unit = create_unit("km/h")
data_element = SenderReceiverInterface.DataElement(
name="Speed",
data_type=create_value_type("Speed", unit=unit),
policy=Policy.STANDARD,
calibration_access=CalibrationAccess.READ_ONLY
)
interface = create_sender_receiver_interface("SpeedInterface", data_element=data_element)
客户端-服务端接口
from src import (
ClientServerInterface, create_value_type, create_unit,
PortDirection
)
unit = create_unit("counts")
operation = ClientServerInterface.Operation(
name="Initialize",
is_server=True,
arguments=[
ClientServerInterface.Argument(
name="config",
direction=PortDirection.IN,
data_type=create_value_type("Config", unit=unit)
)
]
)
cs_interface = ClientServerInterface(name="ControlInterface")
cs_interface.add_operation(operation)
软件组件
创建组件
from src import (
ApplicationSwComponentType, PPortPrototype, RPortPrototype,
SenderReceiverInterface, create_sender_receiver_interface,
AtomicType, ComponentType
)
interface = create_sender_receiver_interface("DataInterface")
port = PPortPrototype(name="DataPort", interface=interface)
component = ApplicationSwComponentType(
name="SensorComponent",
supports_multiple_instantiation=False,
atomic_type=AtomicType.APPLICATION
)
component.add_port(port)
创建组合组件
from src import SwComponentType, ComponentType, AtomicComponentType, CompositionSwComponentType
child1 = ApplicationSwComponentType(name="Child1")
child2 = ApplicationSwComponentType(name="Child2")
composition = CompositionSwComponentType(name="Composition")
composition._component_type = ComponentType.COMPOSITION
内部行为
创建 Runnable 和事件
from src import (
SwcInternalBehavior, RunnableEntity, TimingEvent, InitEvent,
VariableAccess, create_swc_internal_behavior, create_runnable_entity,
create_timing_event, create_init_event, create_data_received_event
)
runnable = create_runnable_entity(
name="UpdateMeasurement",
symbol="UpdateMeasurement",
minimum_start_interval=0.01
)
runnable.add_variable_access(
VariableAccess(name="SpeedAccess", port_prototype_ref="SpeedPort")
)
timing_event = create_timing_event(name="Timing_10ms", period=0.01)
init_event = InitEvent(name="Init", runnable_ref="UpdateMeasurement")
data_rx_event = create_data_received_event(
name="DataReady",
data_element_ref="ReadyFlag",
period=0.05
)
behavior = create_swc_internal_behavior(
name="SensorBehavior",
runnable_entities=[runnable],
events=[timing_event, init_event, data_rx_event]
)
component = ApplicationSwComponentType(name="Sensor")
component.internal_behavior = behavior
打包与导出
基本导出流程
from src import (
create_arxml_document, write_arxml, create_package,
get_ar_packages_element, add_package_to_document,
create_base_type, create_value_type, create_unit
)
doc = create_arxml_document()
packages_element = get_ar_packages_element(doc)
base_type = create_base_type("UInt8", size=8)
app_type = create_value_type("AppData")
package = create_package("MyPkg", elements=[base_type, app_type])
package_element = package.to_arxml(doc)
add_package_to_document(doc, package_element)
write_arxml(doc, "output.arxml")
格式化输出
from src import write_arxml_pretty
write_arxml_pretty(doc, "output_formatted.arxml")
完整示例
以下示例创建一个完整的 AUTOSAR 软件组件配置：
from src import (
create_arxml_document, write_arxml_pretty, create_package,
get_ar_packages_element, add_package_to_document,
create_base_type, create_unit, create_linear, create_compu_method,
create_value_type, create_impl_value_type,
create_sender_receiver_interface, SenderReceiverInterface,
ApplicationSwComponentType, PPortPrototype, RPortPrototype,
SwcInternalBehavior, RunnableEntity, TimingEvent, InitEvent,
Category, Encoding, AtomicType, Policy, CalibrationAccess,
create_sw_addr_method, SectionType, DataTypeMappingSet, DataTypeMapping
)
doc = create_arxml_document()
base_uint8 = create_base_type("UInt8", size=8, encoding=Encoding.TWO_COMPONENT)
base_uint16 = create_base_type("UInt16", size=16, encoding=Encoding.TWO_COMPONENT)
kmh_unit = create_unit("kmh", display="km/h", factor=1.0, offset=0.0)
speed_linear = create_linear(factor=0.01, offset=0)
speed_compu = create_compu_method("SpeedCompu", unit=kmh_unit, linear=speed_linear, category=Category.LINEAR)
app_speed = create_value_type("AppSpeed", unit=kmh_unit, compu_method=speed_compu)
impl_speed = create_impl_value_type("ImplSpeed", base_type=base_uint16)
mapping = DataTypeMapping(
name="SpeedMapping",
application_data_type=app_speed,
implementation_data_type=impl_speed
)
mapping_set = DataTypeMappingSet(name="SpeedMappingSet")
mapping_set.add_mapping(mapping)
data_element = SenderReceiverInterface.DataElement(
name="SpeedData",
data_type=app_speed,
policy=Policy.STANDARD,
calibration_access=CalibrationAccess.READ_WRITE
)
speed_interface = create_sender_receiver_interface("SpeedInterface", data_element=data_element)
code_method = create_sw_addr_method("CODE", section_type=SectionType.CODE)
runnable = RunnableEntity(
name="UpdateSpeed",
symbol="UpdateSpeed",
minimum_start_interval=0.01,
can_be_invoked_concurrently=False
)
runnable.add_variable_access(
VariableAccess(name="SpeedAccess", port_prototype_ref="SpeedPort")
)
timing = TimingEvent(name="Timing_10ms", period=0.01)
init = InitEvent(name="Init", runnable_ref="UpdateSpeed")
behavior = SwcInternalBehavior(
name="SpeedSensorBehavior",
runnable_entities=[runnable],
events=[timing, init],
symbol="SpeedSensor"
)
port = PPortPrototype(name="SpeedPort", interface=speed_interface)
component = ApplicationSwComponentType(
name="SpeedSensorComponent",
supports_multiple_instantiation=False,
atomic_type=AtomicType.APPLICATION,
internal_behavior=behavior
)
component.add_port(port)
package = create_package("SpeedSensorPkg", elements=[
base_uint8,
base_uint16,
kmh_unit,
app_speed,
impl_speed,
mapping_set,
speed_interface,
code_method,
component
])
package_element = package.to_arxml(doc)
add_package_to_document(doc, package_element)
write_arxml_pretty(doc, "SpeedSensor.arxml")
print("Generated: SpeedSensor.arxml")
API 参考
索引
- Base - 所有类型的基类
- Category - 数据分类枚举
- create_uuid - UUID 生成
- create_arxml_document - 文档创建
- write_arxml - 文件写入
- create_package - 包创建
- create_base_type - 基础类型创建
- create_value_type - 值类型创建
- create_sender_receiver_interface - 接口创建
- ApplicationSwComponentType - 组件类型
- create_swc_internal_behavior - 内部行为创建
常见问题
Q: 如何创建多个端口？
interface1 = create_sender_receiver_interface("DataInterface")
interface2 = create_sender_receiver_interface("StatusInterface")
component = ApplicationSwComponentType(name="MyComponent")
component.add_port(PPortPrototype(name="DataPort", interface=interface1))
component.add_port(RPortPrototype(name="StatusPort", interface=interface2))
Q: 如何添加多个 Runnable？
behavior = SwcInternalBehavior(name="Behavior")
runnable1 = create_runnable_entity(name="InitRunnable", symbol="Init")
runnable2 = create_runnable_entity(name="MainRunnable", symbol="Main", minimum_start_interval=0.01)
behavior.add_runnable(runnable1)
behavior.add_runnable(runnable2)
component = ApplicationSwComponentType(name="MyComponent")
component.internal_behavior = behavior
Q: 如何创建嵌套结构体？
inner_type = create_value_type("InnerValue")
inner_struct = ApplicationStructureDataType(name="InnerStruct")
inner_struct.add_element(
ApplicationStructureDataType.StructureElement(name="value", data_type=inner_type)
)
outer_struct = ApplicationStructureDataType(name="OuterStruct")
outer_struct.add_element(
ApplicationStructureDataType.StructureElement(name="inner", data_type=inner_struct)
)