README

mokomoking2501/profinet_master/alarm does not have a README file

#
AlarmAck

pub(all) struct AlarmAck {
dst_endpoint : Int
src_endpoint : Int
add_flags : Byte
send_seq_num : Int
ack_seq_num : Int
status : Int
} derive(Eq,
Debug
)

#
AlarmAck::from_notification

fn AlarmAck::from_notification(notif : AlarmNotification) -> AlarmAck

#
AlarmCRBlockReq

pub(all) struct AlarmCRBlockReq {
alarm_cr_type : Int
lt : Int
alarm_cr_properties : Int
rta_timeout_factor : Int
rta_retries : Int
local_alarm_reference : Int
max_alarm_data_length : Int
alarm_cr_tag_header_high : Int
alarm_cr_tag_header_low : Int
} derive(Eq,
Debug
)

AlarmCR block request — used during AR connect to negotiate alarm channels.

#
AlarmCRBlockReq::default

#
AlarmCRBlockRes

pub(all) struct AlarmCRBlockRes {
alarm_cr_type : Int
local_alarm_reference : Int
max_alarm_data_length : Int
} derive(Eq,
Debug
)

AlarmCR block response — returned by device after connect request.

#
AlarmNotification

pub(all) struct AlarmNotification {
dst_endpoint : Int
src_endpoint : Int
pdu_version : Int
pdu_type : Byte
add_flags : Byte
send_seq_num : Int
ack_seq_num : Int
alarm_data_length : Int
alarm_type : Int
api : Int
slot_number : Int
subslot_number : Int
module_ident_number : Int
submodule_ident_number : Int
} derive(Eq,
Debug
)

Alarm notification PDU — parsed from an alarm Ethernet frame payload.

#
AlarmResponderDecision

pub(all) struct AlarmResponderDecision {
phase_before : String
phase_after : String
notification_send_seq : Int
notification_ack_seq : Int
expected_send_seq : Int
next_expected_send_seq : Int
duplicate : Bool
in_sequence : Bool
ack_required : Bool
} derive(Eq,
Debug
)

#
AlarmResponderState

pub(all) struct AlarmResponderState {
phase : String
expected_send_seq : Int
last_send_seq : Int
pending_ack_seq : Int
notification_count : Int
duplicate_count : Int
out_of_sequence_count : Int
ack_sent_count : Int
ack_fail_count : Int
} derive(Eq,
Debug
)

#
AlarmResponderState::default

#
RtaError

pub(all) struct RtaError {
header : RtaPduHeader
pnio_status : Int
} derive(Eq,
Debug
)

#
RtaPduHeader

pub(all) struct RtaPduHeader {
dst_endpoint : Int
src_endpoint : Int
pdu_version : Int
pdu_type : Int
pdu_type_raw : Byte
add_flags : Byte
send_seq_num : Int
ack_seq_num : Int
var_part_len : Int
} derive(Eq,
Debug
)

#
alarm_lt

let alarm_lt : Int

Default LT (EtherType) for alarm frames.

#
alarm_pdu_type_ack

let alarm_pdu_type_ack : Byte

#
alarm_pdu_type_data

let alarm_pdu_type_data : Byte

#
alarm_pdu_type_err

let alarm_pdu_type_err : Byte

#
alarm_responder_on_ack_sent

fn alarm_responder_on_ack_sent(state : AlarmResponderState, sent : Int) -> AlarmResponderState

#
alarm_responder_on_notification

fn alarm_responder_on_notification(state : AlarmResponderState, notif : AlarmNotification) -> (AlarmResponderState, AlarmResponderDecision, AlarmAck)

#
alarm_sequence_next

fn alarm_sequence_next(seq : Int) -> Int

#
alarm_type_controlled_by_supervisor

let alarm_type_controlled_by_supervisor : Int

#
alarm_type_diagnosis

let alarm_type_diagnosis : Int

Alarm types (AlarmSpecifier high nibble).

#
alarm_type_label

fn alarm_type_label(alarm_type : Int) -> String

#
alarm_type_plug

let alarm_type_plug : Int

#
alarm_type_plug_wrong

let alarm_type_plug_wrong : Int

#
alarm_type_process

let alarm_type_process : Int

#
alarm_type_pull

let alarm_type_pull : Int

#
alarm_type_redundancy

let alarm_type_redundancy : Int

#
alarm_type_released

let alarm_type_released : Int

#
alarm_type_return_of_submodule

let alarm_type_return_of_submodule : Int

#
alarm_type_status

let alarm_type_status : Int

#
alarm_type_update

let alarm_type_update : Int

#
block_type_alarm_cr_req

let block_type_alarm_cr_req : Int

AlarmCR block type in connect request (0x0103 = 259).

#
block_type_alarm_cr_res

let block_type_alarm_cr_res : Int

AlarmCR block type in connect response (0x8103 = 33027).

#
default_alarm_cr_tag_header_high

let default_alarm_cr_tag_header_high : Int

Default AlarmCR tag header high (0xC000).

#
default_alarm_cr_tag_header_low

let default_alarm_cr_tag_header_low : Int

Default AlarmCR tag header low (0xA000).

#
default_max_alarm_data_length

let default_max_alarm_data_length : Int

Default maximum alarm data length.

#
default_rta_retries

let default_rta_retries : Int

Default RTA retries.

#
default_rta_timeout_factor

let default_rta_timeout_factor : Int

Default RTA timeout factor.

#
encode_alarm_ack

fn encode_alarm_ack(ack : AlarmAck) -> Bytes

Encode the RTA transport ACK body that follows the 2-byte FrameID.

#
encode_alarm_ack_frame

fn encode_alarm_ack_frame(destination :
MacAddress
, source :
MacAddress
, frame_id : Int, ack : AlarmAck, vlan_tci? : Int) -> Bytes

Encode a full Ethernet RTA transport ACK frame.

#
encode_alarm_cr_block_req

fn encode_alarm_cr_block_req(req : AlarmCRBlockReq) -> Bytes

Encode an AlarmCRBlockReq into bytes (block body, without block header).

#
format_alarm_ack

fn format_alarm_ack(ack : AlarmAck) -> String

#
format_alarm_notification

fn format_alarm_notification(notif : AlarmNotification) -> String

Format alarm notification as human-readable summary.

#
format_alarm_responder_decision

fn format_alarm_responder_decision(prefix : String, decision : AlarmResponderDecision) -> String

#
format_alarm_responder_state

fn format_alarm_responder_state(prefix : String, state : AlarmResponderState) -> String

#
format_rta_error

fn format_rta_error(err : RtaError) -> String

#
frame_id_alarm_high

let frame_id_alarm_high : Int

Frame ID for high-priority alarms (0xFC01).

#
frame_id_alarm_low

let frame_id_alarm_low : Int

Frame ID for low-priority alarms (0xFE01).

#
parse_alarm_cr_block_res

fn parse_alarm_cr_block_res(data : Bytes, offset : Int) -> AlarmCRBlockRes raise
FrameError

Parse an AlarmCRBlockRes from bytes (block body).

#
parse_alarm_notification

fn parse_alarm_notification(data : Bytes, offset : Int) -> AlarmNotification raise
FrameError

Parse an AlarmNotification from Ethernet frame payload. The payload starts after Ethernet header (14 bytes) + FrameID (2 bytes).

#
parse_rta_error

fn parse_rta_error(data : Bytes, offset : Int) -> RtaError raise
FrameError

#
parse_rta_pdu_header

fn parse_rta_pdu_header(data : Bytes, offset : Int) -> RtaPduHeader raise
FrameError

#
rta_pdu_type_ack

let rta_pdu_type_ack : Int

#
rta_pdu_type_data

let rta_pdu_type_data : Int

RTA PDU type values encoded in the low nibble of PDUType.

#
rta_pdu_type_err

let rta_pdu_type_err : Int

#
rta_pdu_type_label

fn rta_pdu_type_label(pdu_type : Int) -> String

#
rta_pdu_type_nack

let rta_pdu_type_nack : Int

#
rta_pdu_version_1

let rta_pdu_version_1 : Int

RTA PDU version 1 encoded in the high nibble of PDUType.

#
rta_pnio_status_hint

fn rta_pnio_status_hint(status : Int) -> String