1 6.1 Ap lcation layer services on mult icast commu icat ion mode.. 1 6.2 Ap lcation layer services on bro d ast commu icat ion mode.. .17 6.3 Ap lcation layer services on p int -t o-p i
Terms and definitions
For the purposes of this part the terms and definitions given in EN 50090-1 and the following apply
3.1 1 application (in the sense of network application) a system with its associated transmission method which is supported by telecommunications cabling [EN 501 73-1 :2002, definition 3.1 2]
3.1 2 user application software functionality, the control algorithm that runs in one single device
Abbreviations
AD-converter Analog-to-Digital-converter
APDU Application layer Protocol Data Unit
APCI Application layer Protocol Control Information
ASAP Application layer Service Access Point
Acon Application layer confirmation con confirmation
HBES Class 1 refers to simple control and command
HBES Class 2 refers to Class 1 plus simple voice and stable picture transmission
HBES Class 3 refers to Class 2 plus complex video transfers ind indication
Rcon Remote confirmation req request res response
TPDU Transport layer Protocol Data Unit
TSAP Transport layer Service Access Point
4 Services of the application layer
Communication modes
The application layer offers a diverse range of services to application processes, enabling interoperability across different devices through various communication modes According to the transport layer, these communication modes include: a) point-to-multipoint, connection-less (multicast); b) point-to-domain, connection-less (broadcast); c) point-to-all-points, connection-less (system broadcast); d) point-to-point, connection-less; and e) point-to-point, connection-oriented.
The services provided at the application layer are determined by the specific communication mode in use It is important to note that an application layer service should only be utilized with the communication modes for which it is explicitly designed.
Certain services can operate in both point-to-point connection-oriented and point-to-point connection-less communication modes However, application layer services must always align with transport layer services based on the specific communication mode utilized.
Service primitives of the application layer
The transport layer primitives, including request (req), indication (ind), and confirmation (con), are essential for invoking each specified application layer service In the case of a remote confirmed service, the remote device must respond using the same transport layer primitives.
The transport layer confirmation primitive must solely consist of a confirmation from the transport layer instance, encompassing all request data along with a status indicating the success of the service transmission Additionally, the application layer will translate this transport layer confirmation primitive into a local application layer confirmation (Lcon).
Remote/Response User of AL
Figure 1 – Interaction of the application layer for services that are not remote confirmed
In a remote confirmed service, the remote device initiates the response (res) primitive, which the application layer translates into a transport layer request primitive The local application layer then receives the transport layer indication primitive and converts it into an application layer confirmation (Acon) Meanwhile, the remote application layer maps the transport layer confirmation from the remote device to a remote confirmation (Rcon).
NOTE In the following service specifications the local application layer confirmation and the remote confirmation (Rcon) are not always described
Remote/Response User of AL
A_Service.req A_Service.ind A_Service.Rcon A_Service.res
Figure 2 – Interaction of the application layer for services that are remote confirmed
5 Application layer Protocol Data Unit (APDU)
An example of an APDU that can be used is shown in Figure 3
Application layer Service Allowed communication mode(s)
AP CI data encompasses various types of connections, including multicast broadcast, point-to-all points connectionless, and point-to-point connectionless Additionally, it includes point-to-point connection-oriented methods.
1 0 1 1 0 0 0 1 0 0 A_UserMemoryBit_Write (not for future use) X
manufacturer specific area for USERMSG
Application layer Service Allowed communication mode(s)
AP CI AP CI da ta /A PC I da ta /A PC I da ta /A PC I da ta /A PC I da ta /A PC I da ta /A PC I da ta /A PC I da ta /A PC I
Multicast broadcasting enables efficient communication by allowing data to be sent from one source to multiple destinations simultaneously This connectionless point-to-point approach enhances network performance and reduces bandwidth usage, making it ideal for applications that require the distribution of information to multiple users without establishing a dedicated connection for each recipient.
1 1 1 1 0 0 0 0 0 0 A_Open_Routing_Table_Req (not for future use) X
1 1 1 1 0 0 0 0 0 1 A_Read_Routing_Table_Req (not for future use) X
1 1 1 1 0 0 0 0 1 0 A_Read_Routing_Table Res (not for future use) X
1 1 1 1 0 0 0 0 1 1 A_Write_Routing_Table_Req (not for future use) X
1 1 1 1 0 0 1 0 0 0 A_Read_Router_Memory_Res (not for future use) X
1 1 1 1 0 0 1 0 0 1 A_Read_Router_Memory_Res (not for future use) X
1 1 1 1 0 0 1 0 1 0 A_Write_Router_Memory_Req (not for future use) X
1 1 1 1 0 0 1 1 0 1 A_Read_Router_Status_Req (not for future use) X
1 1 1 1 0 0 1 1 1 0 A_Read_Router_Status_Res (not for future use) X
1 1 1 1 0 0 1 1 1 1 A_Write_Router_Status_Req (not for future use) X
1 1 1 1 0 1 0 0 0 0 A_MemoryBit_Write (not for future use) X
The APDU corresponds to the Transport layer Protocol Data Unit (TPDU), minus the transport control field The application control field, which is encoded and decoded by the application layer, includes the application layer service codes (APCI) Its length can be either 4 bits or 10 bits, as specified for each application layer service in Clause 6.
The application control field codes are detailed in Table 1, while the complete Protocol Data Unit (PDU) for each service primitive is provided in the respective service descriptions.
Not defined and not supported application layer services shall ignored by the application layer
Application layer services on multicast communication mode 1 1
A multicast communication mode links transport layer service access points (TSAP) to application layer service access points (ASAP) When a device transmits an A_GroupValue-Service, all devices within the group will receive the A_GroupValue_Service.
When the application layer of a device receives an A_GroupValue_Write-Service, it must map the included ASAP to a single TSAP and identify any other associations between ASAPs and the identified TSAP, subsequently notifying all associated ASAPs as outlined in section 6.1.3.
1 2 request on TSAP update on TSAP 1 transmit request via ASAP 1
Figure 4 – Mapping the ASAP to the TSAP (example)
When the application layer of a device receives an A_GroupValue_Read-Service, it must identify all ASAPs linked to the TSAP and notify each associated ASAP The user is required to generate only one read response, as detailed in section 6.1.2.
A_GroupValue_Read–Service with TSAP = 1 read ASAP 2 read enable read ASAP 1 read disable
ASAP 3 is not informed if a read response is already obtained transmit request response via ASAP 2
Figure 5 – Mapping a TSAP to an ASAP
When a transmission is requested through an ASAP, the application layer must utilize the corresponding TSAP, update all ASAPs linked to that TSAP, and create an A_Group-Service-Request.
1 2 write/response on TSAP 1 update on TSAP 1 transmit request write/response via ASAP 1 write/response ASAP 2
Figure 6 – Handling requests and responses
Application layer user TL Application layer user
A_GroupValue_Read.req T_Data_Group.req
T_Data_Group.ind A_GroupValue_Read-PDU
A_GroupValue_Read.Lcon T_Data_Group.con
A_GroupValue_Read-PDU A_GroupValue_Read.Acon T_Data_Group.ind
T_Data_Group.req A_GroupValue_Response-PDU
T_Data_Group.con A_GroupValue_Response-PDU
Figure 7 – Message flow for the A_Group_Value_Read service
The A_GroupValue_Read.req primitive is utilized by application layer users to request an update of the value of its ASAP, prompting a response from the communication partner with an A_GroupValue_Read.res, thereby confirming the service with the remote application process The ASAP is linked to the TSAP through a group address, as outlined in EN 50090-4-2, ensuring that all other group members also receive the A_GroupValue_Response-PDU.
The local application layer will receive the service request, translate the Application Service Access Point (ASAP) to the Transport Service Access Point (TSAP), and forward it to the local transport layer using a T_Data_Group.req The TSAP and priority parameters will be aligned with the respective parameters of the T_Data_Group.req primitive, while the Transport Service Data Unit (TSDU) will be formatted as an A_GroupValue_Read-PDU.
The user of the HBES system can during configuration decide about this mapping between ASAPs and TSAPs
The remote application layer will convert a T_Data_Group.ind primitive with TSDU = A_GroupValue_Read-PDU into an A_GroupValue_Read.ind primitive The TSAP and priority arguments will be aligned with the ASAP and priority arguments of the A_GroupValue_Read.ind primitive For each ASAP assigned to the corresponding TSAP, one A_GroupValue_Read.ind primitive will be generated.
The remote application process will assess the A_Group_Value_Read-PDU and utilize the ASAP argument to generate a response It will then reply to the A_GroupValue_Read.ind primitive with an A_GroupValue_Read.res primitive that includes the generated response.
During the configuration of the HBES system, users have the option to determine whether the A_GroupValue_Read.res primitive is generated, although it is essential that exactly one ASAP generates this primitive.
It is left to the user application programmer to decide whether an A_GroupValue_Read.Acon time-out supervision is necessary
The A_GroupValue_Response-PDU utilizes two distinct formats based on the value length, which can reach a maximum of 14 octets Any unused data bits in the PDU must be set to zero.
Figure 8 – A_GroupValue_Read-PDU (example)
21 APCI Value (up to 1 4 octets)
Figure 9 – A_GroupValue_Response-PDU (example), length of ASAP data is more than 6 bit
Values that only consist of 6 bits or less shall have the following optimized A_GroupValue_Response-PDU format:
Figure 1 0 – A_GroupValue_Response-PDU (example) length of ASAP data is 6 bit or less
The remote application layer will receive the service response, translate the ASAP to the TSAP, and forward it to the local transport layer using a T_Data_Group.req The parameters ack_request, TSAP, hop_count_type, and priority will be aligned with the respective parameters of the T_Data_Group.req primitive, while the TSDU will be designated as an A_GroupValue_Response-PDU.
The local application layer will associate a T_Data_Group.ind primitive with TSDU = A_GroupValue_Response-PDU to an A_GroupValue_Read.Acon primitive The TSAP and priority arguments will be aligned with the ASAP and priority arguments of the A_GroupValue_Read.Acon primitive Multiple A_GroupValue_Read.Acon primitives may be generated based on the number of configured group members that are set to respond.
The A_GroupValue_Read.req function includes several key parameters: the `ack_request`, which specifies if a layer-2 acknowledgment is mandatory or optional; the `ASAP`, which indicates the service access point; the `hop_count_type`, which determines if the hop count is set to 7 or if the network layer parameter is utilized; and the `priority`, which defines the transmission priority of the requested service as either "system," "urgent," "normal," or "low."
The function A_GroupValue_Read.Lcon processes several parameters: `ack_request` indicates if layer-2 acknowledgment is mandatory or optional; `ASAP` specifies the service access point; `hop_count_type` denotes whether the hop count is set to 7 or if a network layer parameter is utilized; `priority` defines the transmission priority as "system," "urgent," "normal," or "low"; and `a_status` with the value "ok" confirms successful transmission.
A_GroupValue_Read.req has been successful not_ok: this value of this parameter shall be used to indicate that the transmission of the
A_GroupValue_Read.req did not succeed
A_GroupValue_Read.ind(ASAP, priority, hop_count_type)
The ASAP parameter is designated to hold the service access point, while the hop_count_type parameter indicates whether the hop count of the received frame is equal to 7 Additionally, the priority parameter specifies the urgency level of the received frame, which can be categorized as "system," "urgent," "normal," or "low."
Application layer services on broadcast communication mode 1 7
The A_IndividualAddress_Write.req primitive allows users to modify the individual address of a communication partner at the application layer The destination must be manually selected, typically by pressing a button on a single device, which then enters 'programming mode.' In this mode, only the device that was activated will accept the A_IndividualAddress_Write.ind command, while all other devices will disregard it The method for setting a device to 'programming mode' may vary by manufacturer.
The local application layer will receive the service request and forward it to the local transport layer using a T_Data_Broadcast.req The priority parameter, set to 'system', will be mapped to the corresponding parameter in the T_Data_Broadcast.req primitive, while the TSDU will consist of an A_IndividualAddress_Write-PDU.
Figure 1 4 – A_IndividualAddress_Write-PDU (example)
The remote application layer will convert a T_Data_Broadcast.ind primitive with TSDU = A_IndividualAddress_Write-PDU into an A_IndividualAddress_Write.ind primitive The argument priority, which is implicitly set to 'system', will be aligned with the corresponding argument priority of the A_IndividualAddress_Write.ind primitive.
The application process will disregard the A_IndividualAddress_Write.ind primitive unless the device is in 'programming mode'; if it is, the local individual address will be updated to the new address.
When the local application layer receives a T_Data_Broadcast.con from the local transport layer, it forwards an A_IndividualAddress_Write.Lcon primitive to the local application process If the confirmation status is positive (t_status = ok), it sends a positive A_IndividualAddress_Write.Lcon(a_status = ok) to the application process Conversely, if the confirmation status is negative (t_status = not_ok), it communicates an A_IndividualAddress_Write.Lcon(a_status = not_ok) to the user, indicating that the transmission of the corresponding T_Data_Broadcast.req was unsuccessful.
The A_IndividualAddress_Write.req function includes several key parameters: the ack_request, which specifies if a layer-2 acknowledgment is mandatory or optional; the priority, which indicates the transmission priority for the requested service and is set to "system"; the hop_count_type, which determines whether the hop count is fixed at 7 or if the network layer parameter should be utilized; and the newaddress, which holds the new value for the individual address.
The function A_IndividualAddress_Write.Lcon is designed to handle various parameters for frame transmission The parameter `ack_request` specifies whether a layer-2 acknowledgment is mandatory or optional The `priority` parameter indicates the priority level used for transmitting the requested frame, which must be set to "system." The `hop_count_type` parameter determines if the hop count is set to 7 or if a network layer parameter is utilized The `newaddress` parameter holds the new individual address value, while the `a_status` parameter, when set to "ok," confirms the successful transmission of the frame.
A_IndividualAddress_Write.req has been successful not_ok: this value of this parameter shall be used to indicate that the transmission of the
A_IndividualAddress_Write.req did not succeed
The function A_IndividualAddress_Write is designed to process a received frame with three key parameters: priority, hop_count_type, and newaddress The priority parameter indicates the frame's importance, specifically set to "system." The hop_count_type parameter determines if the hop count of the received frame is equal to 7 Lastly, the newaddress parameter holds the new individual address value.
The A_IndividualAddress_Read.req primitive is utilized by the application layer to read the individual address of a communication partner, which is not automatically identified in the service Instead, the destination must be manually selected by pressing a button on one or more devices, activating a 'programming mode' where only the device that received the button press will accept the A_IndividualAddress_Read.ind, while others will disregard it The method for entering 'programming mode' may vary depending on the manufacturer.
The local application layer will receive the service request and forward it to the local transport layer using a T_Data_Broadcast.req The priority parameter, set to 'system', will be mapped to the T_Data_Broadcast.req primitive, while the TSDU will consist of an A_IndividualAddress_Read-PDU.
The remote application layer will translate a T_Data_Broadcast.ind primitive with TSDU = A_IndividualAddress_Read-PDU into an A_IndividualAddress_Read.ind primitive The argument priority, which is implicitly set to 'system', will be mapped to the corresponding argument priority of the A_IndividualAddress_Read.ind primitive.
The remote application process shall respond to the A_IndividualAddress_Read.ind primitive with an A_IndividualAddress_Read.res primitive only if the device is in ´programming mode'
Figure 1 5 – A_IndividualAddress_Read-PDU (example)
Figure 1 6 – A_IndividualAddress_Response-PDU (example)
The remote application layer will receive the service response and forward it to the transport layer using a T_Data_Broadcast.req, with the TSDU being an A_IndividualAddress_Response-PDU Meanwhile, the local application layer will convert a T_Data_Broadcast.ind primitive, where TSDU equals A_IndividualAddress_Response-PDU, into an A_IndividualAddress_Read.Acon primitive The argument priority, which defaults to 'system', will be aligned with the corresponding argument priority of the A_IndividualAddress_Read.Acon primitive, while the argument source_address will be matched to the individual_address argument of the A_IndividualAddress_Read.Acon primitive.
The A_IndividualAddress_Read.req function includes three key parameters: ack_request, which specifies if a layer-2 acknowledgment is mandatory or optional; priority, which indicates the transmission priority for the requested service and is set to "system"; and hop_count_type, which determines whether the hop count is fixed at 7 or if the network layer parameter should be utilized.
The A_IndividualAddress_Read.Lcon function includes several key parameters: the ack_request indicates whether layer-2 acknowledgment is mandatory or optional; the priority specifies the transmission priority as "system," "urgent," "normal," or "low"; the hop_count_type denotes whether the hop count is set to 7 or if a network layer parameter is utilized; and the a_status parameter, when set to "ok," confirms successful transmission.
A_IndividualAddress_Read.req has been successful not_ok: this value of this parameter shall be used to indicate that the transmission of the
A_IndividualAddress_Read.req did not succeed
The function A_IndividualAddress_Read.ind(priority, hop_count_type) is designed to process received frames by utilizing two key parameters The "priority" parameter indicates the frame's priority level, which is set to "system." Additionally, the "hop_count_type" parameter determines whether the hop count of the received frame is equal to 7.