What is the OTUk-SMOH?

This blog post brief defines the term “Section Monitoring Overhead” (SMOH) for OTN Applications.

What Exactly is the OTUk-SMOH (Section Monitoring Overhead)?

Throughout much of this Blog, whenever I discuss Defects or Errors at the OTUk Layer, I usually mention the expression – OTUk-SMOH.

We have also referred to this same field as the Section Monitoring Overhead or SMOH.  Each of these terms means the same things, and I can use them interchangeably within this blog post.  

What exactly is the OTUk-SMOH?

SMOH is an abbreviation for Section Monitoring Overhead.

Figure 1 presents the location of the Section Monitoring (SM) Overhead within the OTU Frame.  

OTUk Framing Format - Identifying Section Monitoring field

Figure 1, Illustration of the OTU Overhead (within an OTU Frame) – with the Section Monitoring Overhead (or SM) Highlighted.

The SM field (or the Section Monitoring Overhead) is a three byte-field. If I were to take that SM field and zoom in on it (to take a closer look), I would have the image below in Figure 2.

Byte-Level View of the Section Monitoring Field

Figure 2, Close Up Look at the SM (or Section Monitoring) field.

Figure 2 shows that the SM field consists of 3-byte fields.

  • TTI Byte-field
  • BIP-8 Byte field and
  • the SM Byte field.

What Are These Byte-Fields within the SMOH?

Let’s go through and define these byte-fields and the role that they take in Section-Monitoring and Management.

What is the TTI Byte field?

I present an illustration of the SM field with the TTI Byte field Highlighted in Figure 3.

Section Monitoring Field with the TTI (Trail Trace Identifier) Byte-field highlighted

Figure 3, Illustration of the SM Field with the TTI Byte Highlighted

First, “TTI Byte” means Trail Trace Identifier Byte. The purpose of the TTI byte (within the OTUk-SMOH) is to transport the Trail-Trace Identifier Messages from a Source STE to a Sink STE. I show an illustration of the Source STE (STE # 1) transporting the TTI Message to the Sink STE (STE # 2) in Figure 4.

STE transporting a TTI Message to another STE

Figure 4, Illustration of a Network Consisting of an STE transmitting the TTI Message to another STE.

Figure 4 illustrates a network that consists of two (2) pieces of equipment:

  • STE # 1, and
  • STE # 2

I will briefly define and elaborate on these pieces of equipment.

STE # 1

This piece of equipment accepts an OTU4 signal (as an input) from the left-hand side (of the figure) and ultimately outputs an OTU4 single (at the other end of this equipment) out to STE # 2

STE # 2

This piece of equipment accepts an OTU4 signal (as an input) from STE # 1 and ultimately outputs an OTU4 signal (at the other end of this equipment) out to some off-page STE.

What is the TTI Message?

Without going into the details of the TTI Message (and what it means), we will, for now, say that this is a 64-byte message (16-byte SAPI, 16-byte DAPI, and 32 bytes Operator Specific) that uniquely identifies a particular STE (Section Terminating Equipment). Figure 5 presents the byte format of the TTI Message.

Byte Format of the SM-TTI Message - Showing Synchronization between TTI Message and the MFAS Byte

Figure 5, Illustration of the Byte Format of the TTI Message

In this figure, we show that the TTI Message is a 64-byte message that:

  • Consists of 16 bytes for the SAPI (Source Access Point Identifier)
  • 16 bytes for the DAPI (Destination Access Point Identifier), and
  • 32 bytes for the Operator Specific field.

I will define the SAPI and the DAPI in another post. Another point I will make in Figure 5 is that the transmission of TTI Messages is always synchronized with the MFAS byte-field.

For this blog post, I will say that a given STE (STE # 1 in this case) will use the 64-byte TTI Message to repeatedly identify itself to the other STE (STE # 2). STE # 1 will continually transmit these TTI messages to STE # 2. STE # 2 will ensure that it consistently receives an expected (and correct) TTI Message. In other words, STE # 2 will use these TTI Messages to continually check and verify that it is connected to the correct STE (STE # 1) in this case.

How Do We Use the TTI Bytes to Transport the TTI Messages?

Figure 5 shows that there are 64 bytes within each TTI Message. However, Figure 3 shows only one TTI byte within the SM field (hence, only one TTI byte within an entire OTU frame). Therefore, transporting a single 64-byte TTI message over an OTU Section requires that we transport 1 TTI byte at a time over a set of 64 OTU frames.

Further, Figure 5 shows that we will synchronize our transmission of these TTI bytes with the MFAS byte.

For example, whenever the 6-LSBs of the MFAS is set to [0, 0, 0, 0, 0, 0], then we will transport the very first TTI byte of the 64-byte TTI Message. Whenever the 6-LSBs of MFAS is set to [0, 0, 0, 0, 0, 1], then we will transport the second TTI byte of the 64-byte TTI message, and so on.

The Receiving STE (STE # 2) in Figure 4 will use this relationship between the LSBs of the MFAS byte to interpret the data it receives from the Transmitting STE (STE# 1) in this case.

If the Receiving STE receives an erred (or unexpected) value for the TTI Message, then that STE can declare the dTIM (Trail-Trace Identifier Mismatch) defect. We will discuss exactly how an STE declares and clears the dTIM defect in another post.

Clueless About OTN? We Can Help! Click on the Banner Below to Learn More!

Discounts Available for a Short Time

What is the SM-BIP-8 Byte-Field?

I present an illustration of the SM field with the BIP-8 Byte-field Highlighted in Figure 6.

Section Monitoring Field with the SM-BIP-8 Byte Highlighted

Figure 6, Illustration of the SM Field with the SM-BIP-8 Byte field highlighted.

The purpose of the BIP-8 Byte field is to permit the receiving STE to perform error checking (and reporting) on each OTU frame it receives.

Without going into many details, the transmitting STE will compute the value for the BIP-8 Byte (based upon the data within the OPU Payload of a given OTU frame).

Section Monitoring BIP-8 Calculation Region

Figure 7, OPU Payload Data that the Transmitting STE uses to Compute the SM-BIP-8 Value

The transmitting STE will then insert this BIP-8 Byte within the BIP-8 Byte (of a specific OTU frame).

Section Monitoring BIP-8 Calculation and Insertion Region

Figure 8, Transmitting STE inserting the SM-BIP-8 Value into a Specific Location within the OTU data stream.

The transmitting STE will then transmit this SM-BIP-8 value (along with the rest of the data within the SM field and the OTU data stream) to the remote receiving STE.

As this Receiving STE receives and accepts an OTU data stream, it also locally computes its own value for the SM-BIP-8 byte-field (based on the data within the OPU Payload). The Receiving STE will also read in the SM-BIP-8 value (the transmitting STE computed and inserted into the SM-byte within the OTU data stream).

If the Receiving STE determines that the SM-BIP-8 value (that it reads from the SM field within the OTU data-stream) matches that of its locally computed SM-BIP-8, then it will determine that the Receive STE received an OTU frame in an un-erred manner.

On the other hand, if the Receiving STE determines that the SM-BIP-8 value (that it reads from the SM-field within the OTU data-stream) differs from that within its locally computed SM-BIP-8 value, then it will determine that the Receive STE received some OTU data in an erred manner.

The SM-BIP-8 blog post presents a detailed discussion on how the Transmitting STE computes the SM-BIP-8 value and inserts it into the SM field within the OTU frame.

What is the SM Byte field (within the SM field)?

I present an illustration of the SM field with the SM Byte field Highlighted in Figure 7.

SM Field with the SM Byte Highlighted

Figure 7, Illustration of the SM-field with the SM-byte highlighted

However, if we were to take a closer look at the SM byte (within the SM-byte), we could see that the SM-byte would consist of multiple bit fields, as shown below in Figure 8.

Section Monitoring Byte with the SM-BEI field Highlighted

Figure 8, A Closer Look at the SM-byte-field within the SM-field

Figure 8 shows that the SM-byte consists of the following bit or nibble fields.

  • BEI/BIAE Nibble-Field
  • BDI bit-field
  • IAE bit-field
  • RES field (2 bits in width)

I will briefly define these nibble and bit-fields within the SM-byte field.

BEI/BIAE – Backward Error Indicator/Backward Input Alignment Error

The Backward Error Indicator is a four-bit field that reflects the number of SM-BIP-8 errors detected by a Receiving STE (and flagged) within the remote recently received OTU frame. If this nibble field contains a value of 0x00 to 0x08, it is transporting the BEI value for a given OTU frame. Please see the blog post on the SM-BEI nibble field to learn more about this topic.

On the other hand, if the BEI/BIAE contains the value of 0x0B, then this reflects a BIAE (Back Input Alignment Error) condition. Please see the blog post on IAE and BIAE defects to learn more about this topic.

BDI – Backward Defect Indicator bit-field

If the local receiving STE declares a service affecting defect, it will set the BDI bit-field (that it sends out to the remote terminal) to “1”. On the other hand, if the local receiving STE does not declare a service-affecting defect, it will set the BDI bit-field (that it sends out to the remote terminal) to “0”.

Please see the blog post on the SM-BDI Indicator to learn precisely how this signaling scheme works in an OTU connection.

IAE – Input Alignment Error Bit-field

It Receiving STE detects a frame slip event (upstream) within the incoming OTU data stream, then will set this IAE bit-field to “1”.

Please see the blog post on IAE and BIAE defects to learn more about this topic.

Conclusion

I have briefly discussed the Section Monitoring Overhead within this blog post. This write-up was intended to be introductory and kept at a high (and simple) level. Please check out those individual blog posts if you wish more details on how we compute specific SMOH fields. I did not want to repeat this detailed material (calculating the SM-BIP-8 value, the SM-BEI value, etc.) in this blog post.

What is the OTUk_TT_So Atomic Function?

This blog post briefly defines the OTUk_TT_So (OTUk Trail Termination Source) Atomic Function. One of the roles of this function is to insert the real Section Monitoring Overhead (SMOH) into the OTU Overhead.


What is the OTUk_TT_So Atomic Function?

We formally call the OTUk_TT_So Atomic Function the OTUk Trail Termination Source Function.

Introduction

The OTUk_TT_So function is any function that accepts data from upstream circuitry (usually the OTUk/ODUk_A_So function).  It uses the data (within this data stream) along with signals from a collocated OTUk_TT_Sk function to compute/generate and insert the OTUk Section Monitoring Overhead (SMOH) into the OTUk signal.

We have an extensive discussion of the OTUk_TT_So Atomic Function in Lesson 9 within THE BEST DARN OTN TRAINING PRESENTATION…PERIOD!!!

I show how we can connect these atomic functions below in Figure 1.

OTUk_TT_So_Function_with_OTUk/ODUk_A_So and Collocated OTUk-TT_Sk functions highlighted

Figure 1, Drawing of a Bidirectional Network (consisting of various Atomic Functions) with the OTUk/ODUk_A_So, the OTUk_TT_So, and its collocated OTUk_TT_Sk functions highlighted 

So What Does this Atomic Function Do?

If you recall, from our discussion of the OTUk/ODUk_A_So function, that function will only generate default values for the OTUk-SMOH within the OTUk signal it transmits.  The OTUk/ODUk_A_So function creates this default SMOH as a place-holder for a future (and actual) SMOH.

Computes and Inserts the Real SMOH Values into the Outbound OTUk Frames

Well, the purpose of the OTUk_TT_So function is to calculate and replace these default SMOH values with actual SMOH values.

More specifically, this function will compute and replace the following SMOH fields with actual Overhead data.

  • SM-BIP-8 field, within the Section Monitoring field
  • SM-BEI/BIAE nibble field within the Section Monitoring Byte
  • SM-BDI bit-field within the Section Monitoring Byte
  • IAE bit-field within the Section Monitoring Byte
  • SM-TTI (Trail Trace Identification) byte within the Section Monitoring field.

Afterward, the OTUk_TT_So function will transmit this OTUk data stream to either the OTSi/OTUk-a_A_S0 function (for OTU1/2 applications) or the OTSiG/OTUk-a_A_S0 function (for OTU3/4 applications). 

These functions will condition the OTUk data stream for transmission over Optical Fiber.

Why Do We Care about the SMOH from the OTUk_TT_So Function?

The SMOH that the OTUk_TT_So function computes and inserts into the OTUk data stream serves as the basis of comparison for the OTUk_TT_Sk function (at the remote Network Element).

The OTUk_TT_Sk function (at the remote end of our OTUk connection) will use this SMOH data to determine:

  • if it should declare any defect conditions, or
  • if errors have occurred during transmission between the near-end OTUk_TT_So and the remote OTUk_TT_Sk functions.

I show an illustration where both the OTUk_TT_So and OTUk_TT_Sk functions “fit into the big picture” below in Figure 2.

Roles of the SMOH within the OTUk_TT_So function

Figure 2, Drawing of Unidirectional Connection between a Source STE and a Sink STE with the OTUk_TT_So and OTUk_TT_Sk functions highlighted.  

Some Details about the OTUk_TT_So Function

Figure 3 presents a drawing of the ITU-T G.798 symbol for the OTUk_TT_So function.

OTUk_TT_So Simple Block Diagram - ITU-T G.798 Symbol

Figure 3, Simple Drawing of the OTUk_TT_So function

The OTUk_TT_So function accepts a basic OTUk data stream from the upstream OTUk/ODUk_A_So function via the OTUk_AP Interface.

The data that is output from the OTUk/ODUk_A_So function includes the Clock Signal (AI_CK), Frame Synchronization Signal (AI_FS), the Multi-Frame Synchronization Signal (AI_MFS), the OTUk data-stream (AI_D) and the IAE (Input Alignment Error) indicator (via the AI_IAE signal).

The OTUk_TT_So function is responsible for accepting data from its various interfaces and then computing and inserting the correct SMOH data into the OTUk data stream.

Figure 2 shows that this function consists of the following four different interfaces.

  • OTUk_AP
  • OTUk_CP
  • OTUk_RP and
  • OTUk_TT_So_MP

We will discuss each of these interfaces below.

Figure 4 presents a functional block diagram of the OTUk_TT_So function.

OTUk_TT_So Atomic Functional Block Diagram

Figure 4 Functional Block Diagram of the OTUk_TT_So function

Clueless about OTN? We Can Help!!! Click on the Banner Below to Learn More!!!

Corporate Discounts Available!!

The OTUk_AP (OTUk Access Point) Interface

Figure 4 shows that the circuitry connected to (and driving) the OTUk_AP Interface (e.g., the OTUk/ODUk_A_So function) will supply the following signals to this interface.

  • AI_D – Bare-bones OTUk data (with the default SMOH)
  • AI_CK – The OTUk clock input signal
  • AI_FS – The OTUk Frame Start Input
  • AI_MFS – the OTUk Multi-Frame Start Input
  • AI_IAE – The OTUk Input Alignment Error Indicator Signal

The OTUk_TT_So function will then perform the following operations on these signals.

NOTE:  (*) – Indicates that you need to be a member of THE BEST DARN OTN TRAINING PRESENTATION….PERIOD!!!  to see this post.  

Let’s move on to another port within this atomic function.

The OTUk_TT_So_RP (Remote Port) Interface

The OTUk_TT_So function will also accept data via the OTUk_TT_So_RP interface.  This interface consists of the following inputs.

  • RI_BEI – Remote Interface – Backward Error Indicator
  • RI_BIAE – Remote Interface – Backward Input Alignment Error Indicator
  • RI_BDI – Remote Interface – Backward Defect Indicator

The OTUk_TT_So function will operate in conjunction with a collocated Near-End OTUk_TT_Sk function and perform the following operations on these signals.

  • BDI Insertion (into the OTUk-SMOH) – The OTUk_TT_So function will accept the BDI information from the Near-End Collocated OTUk_TT_Sk function via the RI_BDI input and insert this data into the SM-BDI bit-field (within the SMOH) of the very next outbound OTUk frame.
  • BEI Insertion (into the OTUk-SMOH) – The OTUk_TT_So function will take the BEI information from the Near-End Collocated OTUk_TT_Sk function via the RI_BEI input and insert this data into the SM-BEI/BIAE nibble-field (within SMOH) of the very next outbound OTUk frame.
  • BIAE Insertion (into the OTUk-SMOH) – The OTUk_TT_So function will accept the BIAE information from the Near-End Collocated OTUk_TT_Sk function via the RI_BIAE input and (if appropriate) will insert this information into the SM-BEI/BIAE nibble-field (within the SMOH) of the very next outbound OTUk frame.

I show a drawing of our OTUk_TT_So function that is electrically connected to its collocated, Near-End OTUk_TT_Sk function via the Remote Port below in Figure 5.

OTUk_TT_So Atomic Function connected to its Collocated OTUk_TT_Sk function

Figure 5, Illustration of our OTUk_TT_So Function, along with its collocated, Near-End OTUk_TT_Sk function

We discuss the operations through the RP Interface in another post.

Next, let’s move on and discuss the Management Port of this atomic function.

The OTUk_TT_So_MP (Management Port) Interface

Finally, the OTUk_TT_So function accepts data from the OTUk_TT_So_MP Interface.  This particular interface consists of the following input pin.

  • MI_TxTI – Trail Trace Identifier Input

The function user is expected to load the contents of the outbound Trail Trace Identifier Message (64 bytes) to this input port.

The OTUk_TT_So function will then take this message data, and it will proceed to use the TTI byte-field within the OTUk-SMOH to transmit the contents of this message, one byte at a time, to the OTUk_TT_Sk function within the remote Network Element, via the OTUk data-stream.  Since the TTI Message is 64 bytes long, the OTUk_TT_So function will require 64 OTUk frames to transmit the complete TTI Message.

We will discuss these processes in greater detail in the Trail Trace Identifier post.

How the OTUk_TT_So function sources each of the various Overhead Fields within the SMOH

As we mentioned earlier, the primary responsibility of the OTUk_TT_So function is to compute/source the correct values for multiple fields within the SMOH and insert those values into the SMOH within each outbound OTUk frame.

Table 1 presents a list of Overhead-fields that the OTUk_TT_So function computes and sources.  This table also shows where this function gets its data for these Overhead fields.

Table 1, A List of the SMOH Overhead-fields that the OTUk_TT_So function computes/sources and how/where this function gets/derives this data.

Overhead FieldLocation within OTUk-SMOHSource of Data/How Derived?
BIP-8 ByteBIP-8 Byte within the Section Monitoring FieldThe OTUk_TT_So function locally computes the BIP-8 value based upon the contents within the OPUk portion of the OTUk frame.
IAE Bit-FieldThe IAE Bit-field within the Section Monitoring ByteBased upon the AI_IAE input to the function (at the OTUk_AP Interface)
BDI Bit-FieldThe BDI bit-field within the Section Monitoring byteBased upon the RI_BDI input to this function (at the Remote Port Interface).
BEI Nibble-FieldThe BEI/BIAE Nibble-field within the Section Monitoring ByteBased upon the RI_BEI and RI_BIAE inputs to this function (at the Remote Port Interface).
BIAE Nibble-FieldThe BEI/BIAE bit-fields within the Section Monitoring byte.Based upon the RI_BIAE and RI_BEI inputs to this function (at the Remote Port Interface).
TTI Byte-FieldTTI Byte within the Section Monitoring Field.The user is expected to load in the contents of the 64-byte Trace Identifier Message (TIM) into a buffer via the MI_TxTI input to this function.

The function will proceed to transmit the contents of this TIM, one byte at a time, via the TTI byte-field within each outbound OTUk Frame.

The OTUk_TT_So function will transport the entire TIM over 64 consecutive OTUk frames.

List of Input and Output Signals for the OTUk_TT_So Atomic Function

Table 2 presents a Pin Description for each of the Input/Output signals of the OTUk_TT_So Atomic Function.

Table 2, Input/Output Pin Description of the OTUk_TT_So Atomic Function

Signal NameTypeDescription
OTUk_AP Interface
AI_DInputOTUk Adapted Interface - OTUk Data Input:
The function user is expected to apply a bare-bones OTUk signal (which is output from the AI_D output of the OTUk/ODUk_A_So function) to this input pin.

NOTE: This OTUk data will contain the following fields
- Default OTUk SMOH data,
- The contents of the APS/PCC channel and
- The rest of the OTUk frame.

This OTUk data-stream will not include the FAS, MFAS or FEC field. This function will compute, generate and insert the appropriate OTUk-SMOH into this OTUk data-stream

The OTUk_TT_So function will sample this input signal on one of the edges of the AI_CK input clock signal.
AI_CKInputOTUk Adapted Interface - Clock Input:
The OTUk_TT_So function will sample all data and signals (that the user applies to the OTUk_AP Interface) upon one of the edges of this input clock signal. This statement applies to the following signals: AI_D, AI_FS, AI_MFS and AI_IAE.

This clock signal will also function as the timing source for this function as well.
AI_FSInputOTUk Adapted Information - Frame Start Input:
The upstream OTUk/ODUk_A_So function should pulse this input signal HIGH whenever the OTUk_AP Interface accepts the very first bit (or byte) of a new OTUk frame, via the AI_D inputs.

The upstream OTUk/ODUk_A_So function should drive this input HIGH once for each OTUk frame.
AI_MFSInputOTUk Adapted Information - Multiframe Start Output:
The upstream OTUk/ODUk_A_So function should pulse this input signal HIGH whenever the OTUk_AP interface accepts the very first bit (or byte) of a new OTUk superframe, via the AI_D input.

The upstream OTUk/ODUk_A_So function should drive this input HIGH once for each OTUk superframe.
AI_IAEInputOTUk Adapted Information - Input Alignment Error Input:
the OTUk/ODUk_A_So function (upstream from this function) will drive this input pin HIGH whenever it detects a frame-slip (or IAE event).

Anytime the OTUk_TT_So function detects this input pin, going from LOW to HIGH, then it should respond by setting the IAE bit-field to "1" for 16 consecutive Superframes (or 4096 consecutive OTUk frames).

Please see the blog on IAE for more information on this feature.
OTUk_CP Interface
CI_DOutputOTUk Characteristic Information - OTUk Data Output:
The OTUk_TT_So function will compute, generate and insert the SMOH (Section Monitoring Overhead) into the outbound OTUk data-stream. It will then output this OTUk data-stream via this output signal.

NOTE: This OTUk data will contain the following fields.
- The newly computed, inserted BIP-8 value
- The newly received and inserted BEI-nibble value or BIAE indicator.
- The newly received and inserted BDI bit-value.
- the newly received and inserted IAE value.
- The contents of the APS/PCC channel and
- The rest of the OTUk frame.

This OTUk data-stream will not include the FAS, MFAS or FEC field.

The OTUk_TT_So function will update this output signal on one of the edges of the CI_CK output clock signal.
CI_CKOutputOTUk Adapted Information - Clock Output:
The OTUk_TT_So function will output all data and signals (via the OTUk_CP interface) upon one of the edges of this output clock signal. This statement applies to the following signals: CI_D, CI_FS and CI_MFS.
CI_FSOutputOTUk Characteristic Information - Frame Start Output:
This function will drive this output pin HIGH whenever the OTUk_CP interface outputs the very first bit (or byte) of a new OTUk frame, via the CI_D output.

The OTUk_TT_So function should only pulse this output pin HIGH once for each outbound OTUk frame.
CI_MFSOutputOTUk Characteristic Information - Multiframe Start Output:
This function will drive this output pin HIGH whenever the OTUk _CP Interface outputs the very first bit (or byte) of a new OTUk Superframe via the CI_D.

The OTUk_TT_So function will drive this output pin HIGH once for each OTUk Superframe.
OTUk_TT_So_RP Interface
REI_BEIInputRemote Port Interface - BEI (Backward Error Indicator) Input:
The OTUk_TT_So function will accept one nibble of data (for each outbound OTUk frame) via this input signal and it will insert this data into the BEI/BIAE nibble-field within the Section Monitor field within each outbound OTUk frame.

The BEI value will reflect the number of BIP-8 errors that the collocated OTUk_TT_Sk function has detected and flagged within its most recently recevied and verified OTUk frame.

NOTE: If the OTUk_TT_So function receives a BIAE = 1 (via the RI_BIAE input) then it will overwrite the BEI/BIAE nibble-field with the value "1011" to denote a BIAE event.

Please see the BEI post for more information about Backward Error Indication.
RI_BIAEInputRemote Port Interface - BIAE (Backward Input Alignment Error) Input:
The OTUk_TT_So function will accept one bit of data (for each outbound OTUk frame) via this input signal and it will do either of the following, depending on the value of this single bit-field.

If BIAE = 0
Then the OTUk_TT_So function will write the BEI value that it has received via the RI_BEI input, into the BEI nibble-field within the Section Monitor byte of the next outbound OTUk frame.

If BIAE = 1
Then the OTUk_TT_So function will not write the BEI value (that it has received from the collocated OTUk_TT_Sk function). It will instead, write the value "1011" into the BEI/BIAE nibble-field, within the Section Monitor byte of the next outbound OTUk frame.
RI_BDIInputRemote Port Interface - Backward Defect Indicator Input:
The OTUk_TT_So function will accept one bit of data (for each outbound OTUk frame) via this input pin and it will write the contents of this value into the RDI bit-field (within the Section Monitor byte) of the next outbound OTUk frame.

If RI_BDI = 0
The the OTUk_TT_So function will set the BDI bit-field to "0" within the next outbound OTUk frame.

If RI_BDI = 1
Then the OTUk_TT_So function will set the BDI-bit-field to "1" within the next outbound OTUk frame.
OTUk_TT_So_MP Interface
MI_TxTIInputManagement Interface - Trail Trace Identifier Input:
The function user is expected to load in the 64-byte TTI Message into the OTUk_TT_So circuitry via this input. The OTUk_TT_So function will then transmit the message to the remote Network Element, one byte-at-a-time, over 64 consecutive outbound OTUk frames.

Has Inflation got You Down? Our Price Discount Can Help You Beat Inflation and Help You Become an Expert on OTN!! Click on the Banner Below to Learn More!!

Discounts Available for a Short Time!!

For More Information on OTN Posts in this Blog, click on the Image below.

OTN Related Blog

OTN Related Topics within this Blog

OTN Related Topics within this Blog General Topics Consequent Equations - What are they and How can you use them? ...
Read More