Sequential Morse Code Generator in Siemens SCL TIA Portal

Problem Overview and Engineering Requirements

The challenge is straightforward: a Siemens S7-1200 (or S7-1500) holds a string such as 'ABCD' and must emit a Morse-code representation of each character one after the other on a single digital output. The naive approach - a long ladder of IF String[N] = 'A' THEN... blocks - fires every character's pattern simultaneously because all IF conditions evaluate every scan. What is required is a true sequential state machine with three responsibilities:

1. Look up the Morse pattern for the current character from a constant data block.
2. Drive the key output for the duration of the next element (dot or dash).
3. Insert the correct inter-element, inter-character, and inter-word gap before advancing the index.

This reference implementation is built on TIA Portal V13 SP1 or later for the S7-1200 firmware 4.x family, and ports cleanly to S7-1500 firmware 2.x. All code is written in SCL (Structured Control Language) so it can be copy-pasted into a single FB and reused on any project that needs deterministic character-at-a-time serial output. The pattern generalises to any sequential code table: morse, Baudot, 7-segment scanning, LED matrix refresh, or one-wire protocols.

Prerequisites

System Architecture

The complete pattern uses three artefacts plus OB1 wiring:

The sequencer FB owns all mutable state (CurrentIndex, CodePtr, the two TON timers, and the active State). The DB holds only constants - this lets you put the Morse alphabet in a single block you can also expose read-only on an HMI for diagnostics.

Morse Code Data Block

Build a global DB called DB_MorseCodes with two constant arrays. The first stores the dot/dash pattern as a STRING so you can read it from a watch table, and the second stores the pattern length so the sequencer knows when to stop without calling LEN every cycle. The array indices match the uppercase ASCII offset: index 0 = 'A', index 25 = 'Z'.

Create the DB and paste the following SCL source view (right-click the DB > Properties > Attributes > uncheck 'Optimised block access' if you want classic DB access from HMI tags; for S7-1500 leave optimised on and use symbolic access only):

DATA_BLOCK "DB_MorseCodes"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
  STRUCT
    Codes : ARRAY[0..25] OF STRING[6] := [
        '.-',     // 0  A
        '-...',   // 1  B
        '-.-.',   // 2  C
        '-..',    // 3  D
        '.',      // 4  E
        '..-.',   // 5  F
        '--.',    // 6  G
        '....',   // 7  H
        '..',     // 8  I
        '.---',   // 9  J
        '-.-',    // 10 K
        '.-..',   // 11 L
        '--',     // 12 M
        '-.',     // 13 N
        '---',    // 14 O
        '.--.',   // 15 P
        '--.-',   // 16 Q
        '.-.',    // 17 R
        '...',    // 18 S
        '-',      // 19 T
        '..-',    // 20 U
        '...-',   // 21 V
        '.--',    // 22 W
        '-..-',   // 23 X
        '-.--',   // 24 Y
        '--..'    // 25 Z
    ];
    CodeLengths : ARRAY[0..25] OF INT := [
        2,4,4,3,1,4,3,4,2,4,3,4,2,2,3,4,4,3,3,1,3,4,3,4,4,4
    ];
  END_STRUCT;
END_DATA_BLOCK

The complete international Morse alphabet is defined by the ITU-R M.1677 recommendation. The patterns above cover the 26 uppercase Latin letters. To extend to digits and punctuation, expand the array range and add the corresponding entries.

State Machine Design

The sequencer walks through five states. Each state owns one job and a single transition condition:

The dot unit is defined by the DotDuration input. Dash = 3 * DotDuration. Inter-element gap = 1 * DotDuration. Inter-character gap = 3 * DotDuration. Inter-word gap = 7 * DotDuration. These ratios are mandated by ITU-R M.1677 and ensure the receiver can decode regardless of the absolute speed.

FB_MorseSequencer SCL Implementation

Create a new Function Block named FB_MorseSequencer. Paste the following code into the SCL editor. The block uses two TON timers in multi-instance form (no separate DB instance required - the FB's instance DB holds them). The SourceString input accepts any STRING up to 80 characters, which fits the default S7-1200 string capacity and avoids the 254-byte ceiling of older CPUs.

FUNCTION_BLOCK "FB_MorseSequencer"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 1.0
   VAR_INPUT
      iStart       : BOOL;            // Rising edge starts transmission
      iReset       : BOOL;            // Force back to IDLE
      sMessage     : STRING[80];      // Text to transmit
      tDotDuration : TIME := T#200ms; // 1 unit of Morse time
   END_VAR

   VAR_OUTPUT
      qKey         : BOOL;            // Drive output to transmitter key
      qBusy        : BOOL;            // Transmission in progress
      qDone        : BOOL;            // Set for one cycle when whole string sent
      qCharIndex   : INT;             // Diagnostic: current source index (0-based)
      qState       : INT;             // Diagnostic: current state ID
   END_VAR

   VAR
      State         : INT := 0;       // 0=IDLE 1=LOAD 2=KEY 3=GAP 4=CHAR_GAP 5=ADVANCE
      CharIndex     : INT := 0;
      CodePtr       : INT := 0;
      CurrentChar   : CHAR;
      ElementIsDash : BOOL;
      DotTimer      : TON;
      GapTimer      : TON;
      ExtraGapTimer : TON;
      LastStart     : BOOL;
      EdgeStart     : BOOL;
   END_VAR

   VAR CONSTANT
      ST_IDLE      : INT := 0;
      ST_LOAD      : INT := 1;
      ST_KEY       : INT := 2;
      ST_GAP       : INT := 3;
      ST_CHAR_GAP  : INT := 4;
      ST_ADVANCE   : INT := 5;
   END_VAR

BEGIN
   // ---- Edge detection on start trigger ----
   EdgeStart := iStart AND NOT LastStart;
   LastStart := iStart;

   // ---- Reset has highest priority ----
   IF iReset THEN
      State := ST_IDLE;
      CharIndex := 0;
      CodePtr := 0;
      DotTimer(IN := FALSE, PT := tDotDuration);
      GapTimer(IN := FALSE, PT := tDotDuration);
      ExtraGapTimer(IN := FALSE, PT := tDotDuration);
      qKey := FALSE;
      qBusy := FALSE;
      qDone := FALSE;
      qCharIndex := 0;
      qState := ST_IDLE;
      RETURN;
   END_IF;

   // ---- Main state machine ----
   CASE State OF

      ST_IDLE:
         qKey := FALSE;
         qBusy := FALSE;
         DotTimer(IN := FALSE, PT := tDotDuration);
         GapTimer(IN := FALSE, PT := tDotDuration);
         ExtraGapTimer(IN := FALSE, PT := tDotDuration);
         IF EdgeStart AND LEN(sMessage) > 0 THEN
            CharIndex := 1;                      // S7-STRING is 1-based
            CodePtr := 0;
            qBusy := TRUE;
            State := ST_LOAD;
         END_IF;

      ST_LOAD:
         qKey := FALSE;
         CurrentChar := sMessage[CharIndex];
         // Normalise: only A-Z supported. Lowercase gets uppercased by offset.
         IF CurrentChar >= 'a' AND CurrentChar <= 'z' THEN
            CurrentChar := CHAR(ORD(CurrentChar) - 32);
         END_IF;
         IF CurrentChar >= 'A' AND CurrentChar <= 'Z' THEN
            // Map 'A'..'Z' to index 0..25
            IF CodePtr < "DB_MorseCodes".CodeLengths[ORD(CurrentChar) - ORD('A')] THEN
               ElementIsDash := (MID("DB_MorseCodes".Codes[ORD(CurrentChar) - ORD('A')],
                                     CodePtr + 1, 1) = '-');
               IF ElementIsDash THEN
                  DotTimer(IN := TRUE, PT := tDotDuration * 3);
               ELSE
                  DotTimer(IN := TRUE, PT := tDotDuration);
               END_IF;
               State := ST_KEY;
            ELSE
               // End of this character, schedule inter-character gap
               IF CurrentChar = ' ' THEN
                  ExtraGapTimer(IN := TRUE, PT := tDotDuration * 4);
               ELSE
                  ExtraGapTimer(IN := TRUE, PT := tDotDuration * 2);
               END_IF;
               State := ST_CHAR_GAP;
            END_IF;
         ELSE
            // Non-alphabetic, non-space: skip with same gap as a space
            ExtraGapTimer(IN := TRUE, PT := tDotDuration * 4);
            State := ST_CHAR_GAP;
         END_IF;

      ST_KEY:
         qKey := TRUE;
         DotTimer(IN := TRUE);
         IF DotTimer.Q THEN
            DotTimer(IN := FALSE);
            qKey := FALSE;
            GapTimer(IN := TRUE, PT := tDotDuration);
            State := ST_GAP;
         END_IF;

      ST_GAP:
         GapTimer(IN := TRUE);
         IF GapTimer.Q THEN
            GapTimer(IN := FALSE);
            CodePtr := CodePtr + 1;
            State := ST_LOAD;
         END_IF;

      ST_CHAR_GAP:
         ExtraGapTimer(IN := TRUE);
         IF ExtraGapTimer.Q THEN
            ExtraGapTimer(IN := FALSE);
            State := ST_ADVANCE;
         END_IF;

      ST_ADVANCE:
         CharIndex := CharIndex + 1;
         CodePtr := 0;
         IF CharIndex > LEN(sMessage) THEN
            State := ST_IDLE;
            qBusy := FALSE;
            qDone := TRUE;
         ELSE
            State := ST_LOAD;
         END_IF;

   ELSE
      State := ST_IDLE;
   END_CASE;

   // ---- Diagnostic outputs ----
   qCharIndex := CharIndex;
   qState := State;

   // ---- One-shot done flag ----
   IF qDone THEN
      qDone := FALSE; // pulse for one cycle
   END_IF;
END_FUNCTION_BLOCK

OB1 Main Program Wiring

From OB1, instantiate the FB in a global DB called IDB_Morse. The wiring shown below uses a tag from the default tag table (tag_StartBtn) and the string tag_MessageText as inputs. The output drives a digital output module channel wired to the Morse key relay or optocoupler.

// OB1 - Main cyclic program
"IDB_Morse"(iStart       := "tag_StartBtn",
            iReset       := "tag_ResetBtn",
            sMessage     := "tag_MessageText",
            tDotDuration := T#120ms,   // ~20 WPM (PARIS method)
            qKey         => "%Q0.0",
            qBusy        => "tag_MorseBusy",
            qDone        => "tag_MorseDone",
            qCharIndex   => "tag_MorseCharIndex",
            qState       => "tag_MorseState");

Timing Parameters and the PARIS Standard

Morse speed is universally measured in words per minute using the PARIS benchmark (the word "PARIS" plus one space = 50 dot units). The conversion formula is:

DotDuration (seconds) = 1.2 / WPM

For amateur-radio applications on HF (3.5 - 30 MHz), 20 WPM (60 ms dot) is the de facto default and matches the FB default of T#200ms when scaled. Tune tDotDuration at the OB1 call site rather than editing the FB so the same block can drive multiple keys at different speeds.

Verification Procedure

1. Compile and download. Right-click the PLC in the project tree > Compile > Software (rebuild all). Download to the target CPU. Clear CPU to RUN.
2. Online watch. Open IDB_Morse in the watch table. Add the static tags State, CharIndex, CodePtr, CurrentChar, DotTimer.Q, and GapTimer.Q with 'Monitor all' toggled on.
3. Force iStart. Click on the iStart operand and use 'Modify to 1'. Confirm that State advances 0 → 1 → 2 → 3 cyclically and that qKey pulses high for the dot/dash interval.
4. Scope the output. Connect an oscilloscope or logic analyser to %Q0.0. Trigger on the rising edge. Measure the high-time of the first pulse: for an 'A' it should equal DotDuration (the dot), then a gap of equal duration, then another high-time of 3 * DotDuration (the dash).
5. End-to-end test. Set tag_MessageText := 'SOS'. The scope should show three short, three long, three short pulses in the canonical distress pattern, followed by seven dot-units of silence before the qDone pulse.
6. Edge case test. Load 'HI MOM'. Verify that the gap between 'M' and 'M' is exactly 3 dot units while the gap between 'M' and the next character across the space is 7 dot units. If the space gap is wrong, check the ST_LOAD branch that compares CurrentChar = ' '.

Troubleshooting Matrix

Edge Cases and Field Notes

• Re-triggering during transmission: Calling iStart while qBusy is true is ignored. To re-trigger mid-message, raise iReset first then pulse iStart.
• Multi-instance usage: The FB is multi-instance capable. Drop two instances - IDB_MorseA and IDB_MorseB - and call them with different tDotDuration values to drive two CW transmitters at different speeds from one CPU.
• PROFINET output module: If %Q0.0 lives on a remote ET200SP, account for PROFINET update time (typically 1 ms). The dot duration must be at least 10 ms to remain immune to update jitter.
• Cycle time impact: Each FB call adds roughly 5 to 15 microseconds per instance on an S7-1214C. At 10 ms OB1 period this is negligible; at 1 ms cycle time ten instances will consume about 1 percent of CPU budget.
• String 80 vs 254: S7-1200 strings default to 254 bytes max. Declaring STRING[80] saves 174 bytes of instance memory per FB call. If you need longer messages, declare STRING[254] and the rest of the code works unchanged.
• HMI text panel: To send text from a KTP700 Basic HMI, use a text field tied to tag_MessageText (STRING). The HMI panel's variable pointer must be set to WString-compatible string type to avoid truncation at non-ASCII characters.
• Safety integration: If the key output drives a transmitter on a manned vessel or in an aircraft simulator, route qKey through an F-CPU safety gate. The F-block FDB_MorseKeySafe can wrap the output with a 100-ms discrepancy check against a second channel before the relay pulls in.

FAQ