Serial vs Ethernet communication in SCADA systems - Performance Comparison

Time Complexity: Serial vs Ethernet communication

O(n) for Serial, O(1) for Ethernet

Understanding Time Complexity

When devices talk using Serial or Ethernet, the time it takes to send data matters a lot.

We want to see how the time to send messages grows as we send more data.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// Send data over Serial
function sendSerial(data) {
  for (let i = 0; i < data.length; i++) {
    serialPort.write(data[i]);
    waitForAck();
  }
}

// Send data over Ethernet
function sendEthernet(data) {
  ethernetSocket.send(data);
  waitForAck();
}
    

This code sends data either byte-by-byte over Serial or all at once over Ethernet.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Serial sends each byte one by one in a loop.
• How many times: Once for every byte in the data.
• Ethernet operation: Sends all data in one go, no loop.

How Execution Grows With Input

Sending more data over Serial means more repeated sends, but Ethernet sends once no matter the size.

Input Size (n)	Approx. Operations Serial	Approx. Operations Ethernet
10	10 sends	1 send
100	100 sends	1 send
1000	1000 sends	1 send

Pattern observation: Serial time grows linearly with data size; Ethernet time stays almost the same.

Final Time Complexity

Time Complexity: O(n) for Serial, O(1) for Ethernet

Serial communication time grows with data size; Ethernet communication time stays constant regardless of data size.

Common Mistake

[X] Wrong: "Sending data byte-by-byte over Serial is just as fast as sending all at once over Ethernet."

[OK] Correct: Serial sends each byte separately, causing delays for each send, while Ethernet sends all data in one message, making it faster for large data.

Interview Connect

Understanding how communication methods scale with data size helps you design better systems and explain your choices clearly.

Self-Check

What if the Serial communication sent data in chunks of 10 bytes instead of one byte at a time? How would the time complexity change?