Complete DOPSoft Macro Guide#

Summary

This note is a complete study guide for DOPSoft Macro. It covers macro types, editor workflow, command categories, programming patterns, safety checks, and many practical macro examples. Images were intentionally removed. Code examples use Expressive Code-style fenced blocks with titles, line markers, line numbers, wrapping, diff blocks, and terminal frames.

What This Chapter Teaches#

This chapter explains how DOPSoft macros work in Delta HMI projects. A macro is a user-written sequence of commands that can run at specific moments: when a button changes state, before or after an object action, when a screen opens or closes, repeatedly while a screen is active, once after HMI startup, or continuously in the background.

The chapter also documents the macro command set:

Category	Main Purpose
Arithmetic	Integer, double word, signed, floating-point, trigonometric, and accumulation operations
Logical Operation	Bitwise OR, AND, XOR, NOT, left shift, and right shift
Data Transfer	Move values, copy blocks, fill blocks, handle strings, and store floating-point values
Data Conversion	BCD/BIN, Word/DW, byte/word, ASCII/HEX, float/integer, and string formatting
Comparison	IF, ELSEIF, ELSE, ENDIF, GOTO labels, conditional CALL, and floating-point comparison
Flow Control	GOTO, LABEL, CALL, RET, FOR/NEXT loops, and END
Bit Setting	Set, clear, toggle, and read bits
Communication	COM port initialization, checksum, send/receive characters, station control, and IP changes
Drawing	Rectangle, line, point, circle, and circle-center calculation
File Access	FileSlot read, write, remove, length, export, and import
Others	Time, errors, delay, system time, history, recipe, alarm, disk format, screen capture, PLC download

Practical takeaway

Use macros for HMI-side helper logic, display calculations, data preparation, formatting, communication helpers, screen behavior, and small automation tasks. Keep time-critical machine control in the PLC whenever possible.

Mental Model of DOPSoft Macros#

A DOPSoft macro is similar to a small script. Each macro contains command lines, and each macro type has a specific trigger. According to the manual, each macro type can contain up to 512 command lines.

A useful mental model is:

1
Trigger event happens
2
DOPSoft selects the macro assigned to that event
3
The macro reads internal memory, PLC registers, constants, or strings
4
The macro executes commands line by line
5
The macro writes results back to internal memory, PLC registers, display objects, files, or communication buffers
6
The HMI continues with the next object action, screen action, or macro cycle

Address Types#

Address Type	Example	Notes
Internal HMI word	`$10`	Stores Word values inside the HMI
Internal HMI bit	`$10.0`	Bit 0 of internal word `$10`
PLC bit/register	`M1`, device registers	Depends on PLC connection and station settings
Constant	`100`, `67.5`, `"READY"`	Literal values inside the macro
String memory	`$100` with character object length	Used by character entry/display objects

Word, Double Word, and Signed Values#

Data Option	Meaning	Practical Warning
Word	16-bit value	One register/address is used
Double Word / DW	32-bit value	Two consecutive registers/addresses are used
Signed	Negative values allowed	Needed for values below zero
Unsigned	No negative values	Good for counters, raw ADC values, IDs
Floating-point	Usually stored across Double Word space	Display object format must match

Double Word overlap

If $100 is used as a Double Word, $101 is part of that same value. Do not store a separate Word at $101.

Core Syntax Rules#

Assignment#

1
$100 = $20
2
$101 = 67
3
$102 = $100 + $101

Function Calls#

1
$100 = BCD($20)
2
$110 = MAX($10, $11)
3
$120 = FADD(67.5, 34.9) (Signed DW)
4
$130 = TIMETICK

Command Calls Without Assignment#

1
BITON $10.0
2
BITOFF $10.1
3
BMOV($200, $100, 10)
4
Delay(500)

Comments#

1
# This comment is not executed
2
$100 = $20
3
$101 = $100 * 10
4
# End of scaling block

Recommended Macro Layout#

1
# 1. Read inputs
2
$100 = $20
3
$101 = $21
4

5
# 2. Normalize or convert values
6
$110 = TODWORD($100)
7
$112 = $110 * 10
8
$114 = $112 / 4095
9

10
# 3. Apply decisions
11
IF $114 > 80
12
  BITON $200.0
13
ELSE
14
  BITOFF $200.0
15
ENDIF
16

17
# 4. Write display output
18
$300 = $114

Macro Types and Execution Timing#

Quick Comparison#

Macro Type	Trigger	Best Use	Important Limitation
On Macro	Button state changes to ON	Start command, latch, timestamp	Only available for supported button types
Off Macro	Button state changes to OFF	Stop command, reset, timestamp	Requires state change caused by button action
Before Execute Macro	Before button/input action	Validation and input preparation	Runs only when object action is actually executed
After Execute Macro	After button/input action	Post-processing user input	Runs after the object action
Screen Open Macro	Once when a screen opens	Screen initialization	Other screen actions wait until it finishes
Screen Close Macro	Once when a screen closes	Cleanup, save temporary values	New screen actions wait until it finishes
Screen Cycle Macro	Repeated while screen is open	Screen-local monitoring	Depends on Macro Cycle Delay
Submacro	Called by another macro	Shared reusable logic	Must return properly with `RET` when needed
Initial Macro	Once after HMI startup	Global initialization	Runs only once
Background Macro	Repeated during HMI operation	Continuous low-load helper tasks	Executes one or several lines per execution cycle
Clock Macro	Repeated during HMI operation	Periodic batch logic	Executes all commands in one run

On Macro and Off Macro#

Use On/Off Macros when you need to react to the state transition of supported buttons such as Set ON, Set OFF, Maintained, and Momentary buttons.

1
# On Macro: button changed to ON
2
BITON $100.0
3
$110 = TIMETICK
4
$111 = 1
5

6
# Off Macro: button changed to OFF
7
BITOFF $100.0
8
$112 = TIMETICK
9
$111 = 0

Before Execute Macro#

Use it to validate or prepare data before the object action runs.

1
# Before Execute Macro for a Numeric Entry object
2
IF $10 < 0
3
  $10 = 0
4
ELSEIF $10 > 1000
5
  $10 = 1000
6
ENDIF

After Execute Macro#

Use it to calculate derived values after a button or input element finishes its action.

1
# After Execute Macro for a Numeric Entry object
2
$100 = $10 * 10
3
$101 = $100 / 100
4
$102 = TIMETICK

Screen Open Macro#

1
# Screen Open Macro
2
# Reset temporary screen state
3
FILL($100, 0, 20)
4

5
# Load current machine values into display buffer
6
$200 = $20
7
$201 = $21
8
$202 = $22

Screen Close Macro#

1
# Screen Close Macro
2
BITOFF $150.0
3
BITOFF $150.1
4
$151 = 0
5
$152 = TIMETICK

Screen Cycle Macro#

The Screen Cycle Macro repeats while the screen is open. The manual states that the default Macro Cycle Delay is 100 ms.

1
# Screen Cycle Macro
2
IF $20 > 800
3
  BITON $300.0
4
  $301 = 2
5
ELSEIF $20 < 100
6
  BITON $300.1
7
  $301 = 1
8
ELSE
9
  BITOFF $300.0
10
  BITOFF $300.1
11
  $301 = 0
12
ENDIF

Submacro#

Submacros are similar to subroutines or helper functions.

1
# Main Macro
2
CALL 10
3
$300 = $150
4
END
5

6
# Submacro 10: scale raw value
7
$150 = $20 * 100
8
$150 = $150 / 4095
9
RET

Initial Macro#

1
# Initial Macro: runs once after HMI startup
2
FILL($100, 0, 50)
3
BITOFF $200.0
4
BITOFF $200.1
5
$300 = TIMETICK
6
$301 = 1
7
$302 = 0

Background Macro#

1
# Background Macro
2
BITNOT $500.0
3
$501 = TIMETICK
4
Delay(1000)
5
$502 = $502 + 1

Clock Macro#

Clock Macro runs repeatedly and executes its program as a batch. The manual notes a default delay of 100 ms and a maximum delay of 65535 ms.

1
# Clock Macro
2
$600 = TIMETICK
3
IF $600 > 60000
4
  BITON $601.0
5
ELSE
6
  BITOFF $601.0
7
ENDIF
8
$602 = $602 + 1

Macro Editor Workflow#

DOPSoft provides a macro edit window and a toolbar. The important toolbar functions are Open, Save, Update, Cut, Copy, Paste, Syntax Check, Macro Wizard, Insert, Delete, Comment, Command, Variable, and Input Address.

Tool	Purpose	Recommended Use
Open	Import a macro	Reuse tested logic from another project
Save	Export a macro	Keep backups and reusable snippets
Update	Apply changes and check syntax	Use before closing the editor
Syntax Check	Check syntax errors	Use often, but do not treat it as full testing
Macro Wizard	Build commands through UI	Good for avoiding address and parameter errors
Insert/Delete	Add or remove command lines	Keep command order clean
Comment	Add non-executed notes	Explain intent, not obvious syntax
Input Address	Select addresses through UI	Prevent typing wrong PLC/HMI addresses

Syntax Check is not enough

Syntax Check verifies command syntax. It does not prove that the logic is correct, that the PLC address is right, or that communication timing is safe.

Suggested Editing Routine#

1
1. Write the macro in small sections
2
2. Add comments for address groups and assumptions
3
3. Run Syntax Check
4
4. Update the macro
5
5. Compile the project
6
6. Test with safe values
7
7. Test boundary values
8
8. Download only after reviewing destructive commands

Command Reference Map#

Full Category Overview#

Category	Commands
Arithmetic	`+`, `-`, ``, `/`, `%`, `+-/`, `MUL64`, `ADDSUMW`, `FADD`, `FSUB`, `FMUL`, `FDIV`, `FMOD`, `SIN`, `COS`, `TAN`, `COT`, `SEC`, `CSC`
Logical Operation	`
Data Transfer	`MOV`, `BMOV`, `ArrayCopy`, `FILL`, `FILLASC`, `STRCAT`, `FMOV`
Data Conversion	`BCD`, `BIN`, `TODWORD`, `TOWORD`, `TOBYTE`, `SWAP`, `XCHG`, `MAX`, `MIN`, `TOHEX`, `TOASC`, `FCNV`, `ICNV`, `SPRINTF`
Comparison	`IF...THEN GOTO`, `IF...THEN CALL`, `IF`, `ELSEIF`, `ELSE`, `ENDIF`, `FCMP`
Flow Control	`GOTO LABEL`, `LABEL`, `CALL`, `RET`, `FOR/NEXT`, `END`
Bit Setting	`BITON`, `BITOFF`, `BITNOT`, `GETB`
Communication	`INITCOM`, `ADDSUM`, `XORSUM`, `PUTCHARS`, `GETCHARS`, `SELECTCOM`, `CLEARCOMBUFFER`, `CHRCHKSUM`, `LOCKCOM`, `UNLOCKCOM`, `STATIONCHK`, `STATIONON`, `STATIONOFF`, `IPON`, `IPOFF`, `IPCHANGE`
Drawing	`RECTANGLE`, `LINE`, `POINT`, `CIRCLE`, `GetCircleCenter`
File Access	`FileSlotRead`, `FileSlotWrite`, `FileSlotRemove`, `FileSlotGetLength`, `FileSlotExport`, `FileSlotImport`
Others	`TIMETICK`, `GETLASTERROR`, `COMMENT`, `Delay`, `GETSYSTEMTIME`, `SETSYSTEMTIME`, `GETHISTORY`, `EXPORT`, `EXRCP16`, `IMRCP16`, `EXRCP32`, `IMRCP32`, `EXENRCP`, `IMENRCP`, `EXHISTORY`, `EXALARM`, `EXALARMGROUP`, `DISKFORMAT`, `BMPCAPTURE`, `PLCDOWNLOAD`

Arithmetic Commands#

Arithmetic commands include integer, Double Word, signed, floating-point, trigonometric, and accumulation operations.

Integer Operations#

1
$1 = 67 + 34
2
$2 = 67 - 34
3
$3 = 67 * 34
4
$4 = 67 / 34
5
$5 = 67 % 34

1
# Convert a raw 0-4095 value into a 0-100 percent value
2
$100 = $20 * 100
3
$101 = $100 / 4095
4
$102 = MAX($101, 0)
5
$103 = MIN($102, 100)

1
# Engineering value = raw * gain + offset
2
$100 = $20 * $21
3
$101 = $100 + $22
4
$200 = $101

Combined Expression#

1
# Calculate a compact expression in one line
2
$1 = $2 + $3 - 57 * $4

64-bit Multiplication#

1
# Store a large multiplication result
2
$1 = MUL64(67, 34) (Signed DW)

Accumulation#

1
# Example data: $0=1, $2=2, $4=3, $6=4, $8=5 when using DW spacing
2
$0 = 1
3
$2 = 2
4
$4 = 3
5
$6 = 4
6
$8 = 5
7
$50 = ADDSUMW($0, 5)

Floating-point Operations#

1
$100 = FADD(67.5, 34.9) (Signed DW)
2
$102 = FSUB(67.5, 34.9) (Signed DW)
3
$104 = FMUL(67.5, 34.9) (Signed DW)
4
$106 = FDIV(67.5, 34.9) (Signed DW)

1
# Convert Celsius to Fahrenheit: F = C * 1.8 + 32
2
$100 = FMUL($20, 1.8) (Signed DW)
3
$102 = FADD($100, 32.0) (Signed DW)
4
$200 = $102

Trigonometric Operations#

1
$10 = SIN(67) (Signed DW)
2
$12 = COS(67) (Signed DW)
3
$14 = TAN(67) (Signed DW)
4
$16 = COT(67) (Signed DW)
5
$18 = SEC(67) (Signed DW)
6
$20 = CSC(67) (Signed DW)

Arithmetic rule

Use integer commands for counters, states, raw values, and register manipulation. Use floating-point commands only when the displayed or calculated value truly needs decimals.

Logical Operation Commands#

Logical operations work on binary representation of values.

Command	Meaning	Example
`	`	OR
`&&`	AND	`$10 = $1 && $2`
`^`	XOR	`$10 = $1 ^ $2`
`NOT`	Bitwise NOT	`$10 = NOT $1`
`<<`	Left shift	`$10 = $1 << 2`
`>>`	Right shift	`$10 = $1 >> 2`

1
# Use a mask to check whether bit 4 is set
2
$100 = $20 && 16
3
IF $100 != 0
4
  BITON $200.0
5
ELSE
6
  BITOFF $200.0
7
ENDIF

1
# Build a status word from separate bit masks
2
$100 = 0
3
IF $10.0 == ON
4
  $100 = $100 | 1
5
ENDIF
6
IF $10.1 == ON
7
  $100 = $100 | 2
8
ENDIF

1
# Move low-level packed data into the expected position
2
$100 = $20 << 4
3
$101 = $100 && 255
4
$102 = $101 >> 2

1
# Toggle bit mask 1 in a status word
2
$100 = $100 ^ 1

Data Transfer Commands#

MOV#

1
$100 = $20
2
$101 = $21
3
$102 = $22
4
$103 = $23

BMOV#

1
# Copy 10 words from $100 to $200
2
BMOV($200, $100, 10)

ArrayCopy#

1
# Copy a section of an array-like memory area
2
# Parameters must be selected according to Macro Wizard and project memory layout
3
$10 = ArrayCopy($100, 0, $200, 0, 20)

FILL#

1
# Clear 50 words starting at $300
2
FILL($300, 0, 50)

1
# Initialize recipe defaults
2
FILL($400, 100, 10)
3
FILL($410, 0, 10)
4
FILL($420, 1, 5)

FILLASC#

1
# Store ASCII text for a character display area
2
FILLASC($500, "READY")
3
FILLASC($520, "ALARM")
4
FILLASC($540, "STOP")

STRCAT#

1
# Join two character areas into one display buffer
2
$600 = STRCAT($500, $520, 20)

FMOV#

1
# Store a floating-point constant
2
$700 = FMOV(67.5) (Signed DW)

Data Conversion Commands#

BCD and BIN#

1
$100 = BCD($20)
2
$101 = BIN($100)

Word and Double Word Conversion#

1
# Prepare a Word value for a larger calculation
2
$100 = TODWORD($20)
3
$102 = $100 * 1000
4
$104 = $102 / 4095

Byte and Word Conversion#

1
# Convert byte-level data into Word-level data
2
$100 = TOWORD($20, 4)
3

4
# Convert Word-level data back into byte-level data
5
$200 = TOBYTE($100, 4)

SWAP#

1
# Swap high and low bytes for two words
2
SWAP($10, $20, 2)

XCHG#

1
# Exchange two blocks of two words
2
XCHG($10, $20, 2)

MAX and MIN#

1
# Clamp $20 into 0..100 range
2
$100 = MAX($20, 0)
3
$101 = MIN($100, 100)

ASCII and HEX Conversion#

1
$100 = TOHEX($20)
2
$110 = TOASC($100)

FCNV and ICNV#

1
# Convert integer to floating-point, divide, then convert back if needed
2
$100 = FCNV($20) (Signed DW)
3
$102 = FDIV($100, 10.0) (Signed DW)
4
$104 = ICNV($102)

SPRINTF#

1
# Format a text message for a character display buffer
2
$500 = SPRINTF($100, "TEMP=%d", $20)

1
# Conceptual formatted status string
2
$520 = SPRINTF($200, "P=%d T=%d MODE=%d", $20, $21, $22)

SPRINTF parameter check

Use Macro Wizard to confirm the exact parameter count and destination length in your DOPSoft version. Character display length must be large enough for the final string.

Comparison and Conditional Commands#

Operators#

Operator	Meaning
`==`	Equal
`!=`	Not equal
`>`	Greater than
`>=`	Greater than or equal
`<`	Less than
`<=`	Less than or equal
`AND == 0`	Bitwise AND result equals zero
`AND != 0`	Bitwise AND result is not zero
`== ON`	Bit is ON
`== OFF`	Bit is OFF

IF / ELSE / ENDIF#

1
IF $10 > 800
2
  BITON $200.0
3
  $201 = 2
4
ELSE
5
  BITOFF $200.0
6
  $201 = 0
7
ENDIF

ELSEIF Chain#

1
IF $10 < 100
2
  $300 = 1
3
ELSEIF $10 < 500
4
  $300 = 2
5
ELSEIF $10 < 900
6
  $300 = 3
7
ELSE
8
  $300 = 4
9
ENDIF

IF THEN GOTO#

1
IF $1 == $2 THEN GOTO LABEL 1
2
$100 = $100 + 1
3
END
4

5
LABEL 1
6
$100 = $200

IF THEN CALL#

1
IF $1.0 == ON THEN CALL 5
2
$300 = $100
3
END
4

5
# Submacro 5
6
$100 = $20 + $21
7
RET

AND Condition#

1
IF ($10 && 16) != 0
2
  BITON $200.4
3
ELSE
4
  BITOFF $200.4
5
ENDIF

Floating-point Comparison#

1
$50 = FCMP($10, $20) (Signed DW)
2
IF $50 > 0
3
  $60 = 1
4
ELSEIF $50 < 0
5
  $60 = -1
6
ELSE
7
  $60 = 0
8
ENDIF

Nesting limit

The manual states that nested IF structures support up to 7 layers. For maintainability, prefer Submacros over deeply nested logic.

Flow Control Commands#

GOTO and LABEL#

1
GOTO LABEL 1
2
$100 = 0
3

4
LABEL 1
5
$100 = $100 + 1

CALL and RET#

1
CALL 20
2
$300 = $150
3
END
4

5
# Submacro 20
6
$150 = $10 + $11
7
RET

FOR / NEXT#

1
FOR 4
2
  $100 = $100 + 1
3
NEXT
4
$101 = $100

END#

1
IF $1.0 == OFF
2
  END
3
ENDIF
4

5
$100 = $100 + 1

Loop With Data Buffer#

1
# Conceptual loop: repeat a calculation block
2
$100 = 0
3
FOR 10
4
  $100 = $100 + 1
5
  $200 = $200 + $100
6
NEXT
7
$300 = $200

Bit Setting Commands#

1
BITON $1.0
2
BITOFF $1.1
3
BITNOT $1.2
4
$10.0 = GETB $2.0

1
# Set alarm bits from thresholds
2
IF $20 > 900
3
  BITON $100.0
4
ELSE
5
  BITOFF $100.0
6
ENDIF
7

8
IF $21 == 0
9
  BITON $100.1
10
ENDIF

1
# Toggle mode bit and store timestamp
2
BITNOT $200.0
3
$201 = TIMETICK
4
IF $200.0 == ON
5
  $202 = 1
6
ELSE
7
  $202 = 0
8
ENDIF

Communication Commands#

Communication macros can initialize COM ports, calculate checksums, send and receive characters, select/clear/lock/unlock COM ports, check stations, and enable/disable/change IP connections.

Communication warning

Do not run heavy communication loops with very short delay. Always use timeout values, clear buffers intentionally, and check return values.

COM Initialization#

1
# Parameters must match your port, interface, data bits, parity, stop bits, baud rate, and flow control
2
$50 = INITCOM(1, 0, 8, 0, 1, 9600, 0)

Send Characters#

1
# Send 12 bytes from $100 with a timeout
2
$50 = PUTCHARS($100, 12, 500)
3
IF $50 == 0
4
  $51 = GETLASTERROR
5
  BITON $300.0
6
ELSE
7
  BITOFF $300.0
8
ENDIF

Receive Characters#

1
# Clear buffer before receiving a new message
2
CLEARCOMBUFFER(1, 0)
3
$60 = GETCHARS($200, 12, 500)
4
IF $60 == 0
5
  BITON $300.1
6
ELSE
7
  BITOFF $300.1
8
ENDIF

Checksums#

1
$70 = ADDSUM($100, 12)
2
$71 = XORSUM($100, 12)

1
# Calculate string length/checksum according to selected parameters
2
$80 = CHRCHKSUM("READ", 0, 4)

Lock and Unlock COM Port#

1
$90 = LOCKCOM(1, 1000)
2
IF $90 == 1
3
  CLEARCOMBUFFER(1, 0)
4
  $91 = PUTCHARS($100, 8, 500)
5
  $92 = GETCHARS($200, 8, 500)
6
  UNLOCKCOM(1)
7
ELSE
8
  $93 = GETLASTERROR
9
  BITON $300.2
10
ENDIF

Station Control#

1
$100 = STATIONCHK(1, 1000)
2
IF $100 == 0
3
  STATIONON(1, 1000)
4
ELSE
5
  $101 = 1
6
ENDIF

IP Control#

1
$120 = IPON(192, 168, 0, 1)
2
IF $120 == 1
3
  $121 = IPCHANGE(192, 168, 0, 20, 502, 1000)
4
ELSE
5
  $122 = GETLASTERROR
6
ENDIF

Drawing Commands#

Drawing commands are useful for simple visual marks. For complex interfaces, use DOPSoft objects instead.

1
RECTANGLE($50)
2
LINE($60)
3
POINT($70)
4
CIRCLE($80)

1
# Conceptual example: draw a marker only during alarm
2
IF $100.0 == ON
3
  RECTANGLE($50)
4
  LINE($60)
5
ELSE
6
  $90 = 0
7
ENDIF

1
# Parameters must be configured using Macro Wizard for the project coordinate system
2
$100 = GetCircleCenter($20, $21, $22, $23, $24, $25)

File Access Commands#

FileSlot commands work with file storage slots. Use them carefully, especially write/remove/import operations.

Read and Write#

1
$10 = FileSlotRead(1, $100, 0, 20)
2
IF $10 == 1
3
  $11 = $100
4
ENDIF
5
$12 = FileSlotWrite(1, $200, 0, 20)

Remove and Length#

1
$20 = FileSlotGetLength(1, $300)
2
IF $20 > 0
3
  $21 = FileSlotRemove(1)
4
ELSE
5
  $21 = 0
6
ENDIF

Export and Import#

1
$30 = FileSlotExport(1, $400, 0, 20)
2
$31 = FileSlotImport(1, $500, 0, 20)

File operation safety

Never call FileSlotWrite, FileSlotRemove, or import commands from a fast repeated macro without a strong condition, confirmation bit, and status feedback.

Other Utility Commands#

Time Tick#

1
$100 = TIMETICK
2
Delay(500)
3
$101 = TIMETICK

Elapsed Time Measurement#

1
# Start event
2
$100 = TIMETICK
3

4
# Later in the macro or after another event
5
$101 = TIMETICK
6
$102 = $101 - $100

GETLASTERROR#

1
$10 = FileSlotWrite(1, $100, 0, 20)
2
IF $10 == 0
3
  $11 = GETLASTERROR
4
  BITON $200.0
5
ENDIF

Delay#

1
BITON $10.0
2
Delay(500)
3
BITOFF $10.0
4
Delay(500)

System Time#

1
$100 = GETSYSTEMTIME
2
SETSYSTEMTIME($200)

Recipe Export and Import#

1
$100 = EXRCP16(1, $200)
2
$101 = IMRCP16(1, $200)
3
$102 = EXRCP32(1, $300)
4
$103 = IMRCP32(1, $300)
5
$104 = EXENRCP(1, $400)
6
$105 = IMENRCP(1, $400)

History and Alarm Export#

1
$200 = GETHISTORY(1, $300, $301, $302, $303)
2
$210 = EXHISTORY(1, $400, 0)
3
$220 = EXALARM(1, $500)
4
$221 = EXALARMGROUP(1, $520, 2)

Screen Capture and Destructive Utilities#

1
# Only run these commands behind an explicit service-mode condition
2
IF $900.0 == OFF
3
  END
4
ENDIF
5

6
# Examples must be verified through Macro Wizard before real use
7
$910 = BMPCAPTURE($920)
8

9
IF $900.1 == ON
10
  # DISKFORMAT is destructive. Use only with strict confirmation.
11
  DISKFORMAT($930)
12
ENDIF

Practical Programming Recipes#

Recipe 1: Safe Numeric Entry Clamp#

1
# After Execute Macro for Numeric Entry $10
2
IF $10 < 0
3
  $10 = 0
4
ELSEIF $10 > 100
5
  $10 = 100
6
ENDIF
7

8
$100 = $10

Recipe 2: Alarm With Acknowledgement#

1
# $20 is process value, $21 is high limit, $30.0 is acknowledge button
2
IF $20 > $21
3
  BITON $100.0
4
ELSE
5
  BITOFF $100.0
6
ENDIF
7

8
IF $100.0 == ON
9
  BITON $101.0
10
ENDIF
11

12
IF $30.0 == ON
13
  BITOFF $101.0
14
ENDIF

Recipe 3: HMI Heartbeat Bit#

1
# Background or Clock Macro with a reasonable delay
2
BITNOT $500.0
3
$501 = TIMETICK
4
Delay(1000)

Recipe 4: Display Raw Value as Percent#

1
# raw input: $20, output percent: $200
2
$100 = $20 * 100
3
$101 = $100 / 4095
4
$102 = MAX($101, 0)
5
$103 = MIN($102, 100)
6
$200 = $103

Recipe 5: Mode Selector From Two Buttons#

1
# $10.0 = auto button, $10.1 = manual button
2
IF $10.0 == ON
3
  $100 = 1
4
  BITOFF $10.1
5
ELSEIF $10.1 == ON
6
  $100 = 2
7
  BITOFF $10.0
8
ELSE
9
  $100 = 0
10
ENDIF

Recipe 6: Startup Default Values#

1
# Initial Macro
2
FILL($100, 0, 50)
3
$200 = 100
4
$201 = 500
5
$202 = 1000
6
BITOFF $300.0
7
BITOFF $300.1

Recipe 7: Communication Request With Timeout Status#

1
$50 = LOCKCOM(1, 1000)
2
IF $50 == 1
3
  CLEARCOMBUFFER(1, 0)
4
  $51 = PUTCHARS($100, 8, 500)
5
  $52 = GETCHARS($200, 8, 1000)
6
  UNLOCKCOM(1)
7

8
  IF $52 == 0
9
    $53 = GETLASTERROR
10
    BITON $300.0
11
  ELSE
12
    BITOFF $300.0
13
  ENDIF
14
ENDIF

Recipe 8: File Write With Confirmation Bit#

1
# $10.0 is a one-shot confirmation bit from an HMI button
2
IF $10.0 == OFF
3
  END
4
ENDIF
5

6
$20 = FileSlotWrite(1, $100, 0, 20)
7
IF $20 == 0
8
  $21 = GETLASTERROR
9
  BITON $200.0
10
ENDIF
11

12
BITOFF $10.0

Recipe 9: Submacro-Based Scaling Library#

1
# Main macro
2
CALL 100
3
CALL 101
4
END
5

6
# Submacro 100: scale pressure raw value
7
$300 = $20 * 100
8
$301 = $300 / 4095
9
$302 = MAX($301, 0)
10
$303 = MIN($302, 100)
11
RET
12

13
# Submacro 101: scale temperature raw value
14
$310 = $21 * 200
15
$311 = $310 / 4095
16
$312 = $311 - 50
17
RET
18

4 collapsed lines
19
# Reserved for future reusable conversions
20
# Submacro 102
21
# Submacro 103
22
# Submacro 104

Recipe 10: Screen-Local State Machine#

1
# $100 is state: 0=idle, 1=ready, 2=run, 3=alarm
2
IF $20.0 == ON
3
  $100 = 3
4
ELSEIF $10.0 == ON
5
  $100 = 2
6
ELSEIF $11.0 == ON
7
  $100 = 1
8
ELSE
9
  $100 = 0
10
ENDIF
11

12
IF $100 == 3
13
  BITON $200.0
14
ELSE
15
  BITOFF $200.0
16
ENDIF

Before and After Refactoring Examples#

Replace Repeated Logic With Submacro#

1
$100 = $20 * 100
2
$101 = $100 / 4095
3
$200 = $101
4
$110 = $21 * 100
5
$111 = $110 / 4095
6
$201 = $111
7
CALL 10
8
CALL 11
9
$200 = $101
10
$201 = $111

1
CALL 10
2
CALL 11
3
END
4

5
# Submacro 10
6
$100 = $20 * 100
7
$101 = $100 / 4095
8
RET
9

10
# Submacro 11
11
$110 = $21 * 100
12
$111 = $110 / 4095
13
RET

Guard Destructive Commands#

1
DISKFORMAT($930)
2
IF $900.0 == ON
3
  IF $900.1 == ON
4
    DISKFORMAT($930)
5
  ENDIF
6
ENDIF

Add Error Handling#

1
$10 = FileSlotWrite(1, $100, 0, 20)
2
$10 = FileSlotWrite(1, $100, 0, 20)
3
IF $10 == 0
4
  $11 = GETLASTERROR
5
  BITON $200.0
6
ELSE
7
  BITOFF $200.0
8
ENDIF

Testing and Debugging Workflow#

Test Memory Map#

Memory Range	Suggested Use
`$0-$49`	Temporary values for small macros
`$50-$99`	Communication return values and errors
`$100-$199`	Display buffers and calculated values
`$200-$299`	Status words and alarm bits
`$300-$399`	Recipe and file operation buffers
`$400-$499`	String buffers
`$500-$599`	Background/Clock macro state

Boundary Test Macro#

1
# Test clamp logic with low, normal, and high values
2
$10 = -1
3
CALL 30
4
$11 = 50
5
CALL 31
6
$12 = 1001
7
CALL 32
8
END

Debug Status Pattern#

1
$900 = 0
2
IF $20 > 800
3
  $900 = 1
4
ENDIF
5
IF $21 == 0
6
  $901 = GETLASTERROR
7
ENDIF
8
$902 = TIMETICK

Recommended Test Flow#

1
Syntax Check
2
Update macro
3
Compile project
4
Run with safe simulated values
5
Run lower boundary values
6
Run upper boundary values
7
Run communication timeout test
8
Run power-cycle startup test
9
Review destructive commands before download

Common Mistakes#

Mistake	Why It Matters	Fix
Using `$101` after `$100` as DW	`$101` belongs to `$100` DW value	Reserve two addresses for DW values
Running communication too fast	Buffer and timeout errors	Use delay, locks, and return checks
Missing `RET` in Submacro	Macro may not return as expected	End reusable Submacros with `RET`
Duplicate labels	GOTO may jump to the wrong place	Keep label numbers unique per macro
Using Screen Cycle for global logic	Logic only runs while screen is open	Use Clock or Background Macro
No confirmation for file/write/format commands	Data loss risk	Use service mode and confirmation bits
Too many nested IF blocks	Hard to maintain and debug	Split into Submacros
No comments for memory ranges	Future edits become dangerous	Document address ownership
Syntax Check only	Logical errors remain hidden	Compile and test behavior

Final Checklist#

FAQ#

Should control logic be written in the HMI macro or PLC?

Safety-critical and time-critical control should remain in the PLC. Use HMI macros for display logic, data preparation, formatting, simple helper tasks, and UI-related automation.

When should I use Screen Cycle Macro instead of Clock Macro?

Use Screen Cycle when the logic only matters while a specific screen is open. Use Clock Macro for repeated global logic that should run regardless of the current screen.

Why does my button macro not execute?

Some button-related macros execute only if the button state changes through the user action. If the state is controlled externally by the PLC or another macro, the trigger may not occur.

Why does my floating-point value display incorrectly?

Check the macro command type, Double Word address allocation, display object Data Type, and display Data Format. Floating values usually require matching DW/floating configuration in the object.

How should I organize many Submacros?

Group them by function. For example, 1-99 for screen helpers, 100-199 for scaling, 200-299 for communication, and 300-399 for file/recipe utilities.

Can I use comments inside macros?

Yes. Use # comments for memory maps, assumptions, and purpose. Avoid commenting obvious single assignments unless the address meaning is important.

References#

Delta Electronics, DOPSoft User Manual - Chapter 24: Macro, November 2018.