feifei.xu/arxml_sdk

Fork 0

T

feifei.xu dcf9fb590f 优化代码

2026-06-08 10:17:44 +08:00

.trae/documents

优化代码

2026-06-08 10:17:44 +08:00

src

优化代码

2026-06-08 10:17:44 +08:00

tests

上传初版SDK

2026-06-02 15:21:07 +08:00

.gitignore

Initial commit

2026-06-02 15:17:04 +08:00

LICENSE

Initial commit

2026-06-02 15:17:04 +08:00

README.md

更新SDK文档到README.md

2026-06-04 16:02:49 +08:00

spec.md

优化代码

2026-06-08 10:17:44 +08:00

README.md

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 → 依赖 core
utils → 依赖 core
tests → 依赖 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")

枚举类型

枚举值	说明
`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)
)

README.md Unescape Escape

arxml_sdk

目录

简介

特性

快速开始

环境要求

安装

最小示例

架构设计

整体架构图

模块职责

core 模块 - 核心基础设施层

types 模块 - 数据类型层

utils 模块 - 工具层

类型继承体系

依赖关系图

设计模式

1. 工厂函数模式

2. 组合模式

3. 序列化模式

4. 数据类模式

数据流

技术栈

核心模块 (core)

Base 类

属性

只读属性

方法

to_arxml(doc: Document) -> Element

公共函数

create_uuid() -> str

create_text_element(doc: Document, tag: str, text: str) -> Element

枚举类型

Category

Encoding

CalibrationAccess

SwCalibrationAccess

UpperSts / LowerSts

ConstraintSpecified

CompuContents

ComponentType

AtomicType

ImplementationCodeType

AccessPoint

PortDirection

Semantic

SectionType

Policy

数据类型模块 (types)

BaseType

构造函数属性

工厂函数

create_base_type(name: str, size: int, category: Optional[Category] = None, encoding: Optional[Encoding] = None, native_description: Optional[str] = None) -> BaseType

Unit

构造函数属性

工厂函数

create_unit(name: str, display: Optional[str] = None, factor: Optional[float] = None, offset: Optional[float] = None) -> Unit

DataConstraint

构造函数属性

工厂函数

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

CompuMethod

Linear 类

构造函数属性

工厂函数

TextTable 类

构造函数属性

工厂函数

CompuMethod 类

构造函数属性

方法

工厂函数

应用数据类型

ApplicationBooleanDataType

构造函数属性

工厂函数

ApplicationValueDataType

构造函数属性

工厂函数

README.md

`to_arxml(doc: Document) -> Element`

`create_uuid() -> str`

`create_text_element(doc: Document, tag: str, text: str) -> Element`

`create_base_type(name: str, size: int, category: Optional[Category] = None, encoding: Optional[Encoding] = None, native_description: Optional[str] = None) -> BaseType`

`create_unit(name: str, display: Optional[str] = None, factor: Optional[float] = None, offset: Optional[float] = None) -> Unit`

`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`

��法