Simple SIA over TCP Protocol

This document describes how to integrate your device or application with CallOnAlarm using the SIA DC-09 protocol over TCP. This is the recommended method for hardware manufacturers and IoT device developers.

Note: This low-level TCP protocol is designed for manufacturers and developers who prefer direct socket communication over HTTP. If you're looking for a simpler integration using standard HTTP requests, see the Public API documentation instead.

Simplified Integration: This guide presents a simplified implementation of the SIA DC-09 protocol. We use the SIA-DCS message format exclusively, which is the most straightforward and widely supported format. Contact ID (ADM-CID) is not covered in this documentation.

Overview

CallOnAlarm accepts alarm messages using the SIA DC-09 protocol, an industry standard used by most professional alarm panels worldwide. Your device connects via TCP, sends a formatted message, and receives an acknowledgment (ACK).

Why SIA over TCP?

Feature

Benefit

Industry standard

Compatible with existing alarm infrastructure

TCP reliability

Guaranteed delivery with ACK confirmation

Low bandwidth

Minimal data transfer (~100 bytes per message)

Simple workflow

Connect, send, receive ACK, disconnect

Firewall friendly

Single outbound TCP connection

Connection Details

Parameter

Value

Host

sia.callonalarm.io

Port

5001

Protocol

TCP

Encryption

Not supported at this time due to inconsistent implementation across different manufacturers.

Connection Lifecycle

┌─────────────┐         ┌─────────────────┐
│   Device    │         │   CallOnAlarm   │
└──────┬──────┘         └────────┬────────┘
       │                         │
       │──── TCP Connect ───────>│
       │                         │
       │──── SIA Message ───────>│
       │                         │
       │<─────── ACK ────────────│
       │                         │
       │──── Close connection ──>│
       │                         │
       │    ─ ─ ─ OR ─ ─ ─       │
       │                         │
       │<─── Timeout (close) ────│
       └─────────────────────────┘

Timeouts

Server-side timeouts are subject to change. These values are provided for reference only and should not be hardcoded in your implementation.

Timeout

Current Value

Description

First data

10 seconds

Must send data within 10s of connecting

Idle

60 seconds

Connection closed after 60s of inactivity

Max connection

5 minutes

Maximum duration for a single connection

Note: Client-side timeouts are at your discretion. We recommend a 5-10 second timeout for ACK reception.

Message Format

Structure

All messages follow this structure:

<LF><CRC><LENGTH><CONTENT><CR>

Field

Size

Description

LF

1 byte

Line Feed character (0x0A)

CRC

4 chars

CRC-16 checksum in uppercase hex (e.g., A4FE)

LENGTH

4 chars

Content length in uppercase hex (e.g., 0052)

CONTENT

Variable

The SIA message payload

CR

1 byte

Carriage Return character (0x0D)

CRC-16 Calculation

The CRC is calculated on the CONTENT portion only, using polynomial 0x8005 (CRC-16-IBM).

C implementation:

#include <stdint.h>
#include <string.h>

static const uint16_t CRC16_TABLE[256] = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

uint16_t crc16(const char *data, size_t len) {
    uint16_t crc = 0;
    for (size_t i = 0; i < len; i++) {
        crc = (crc >> 8) ^ CRC16_TABLE[(crc ^ (uint8_t)data[i]) & 0xFF];
    }
    return crc;
}

Test Vectors

Use these examples to validate your CRC implementation before connecting to CallOnAlarm.

Content

Length

CRC

"SIA-DCS"0001L0#12345678[#12345678|BA001]

41 (0x0029)

0xEB87

"SIA-DCS"0042L0#12345678[#12345678|FA002]

41 (0x0029)

0x9DC1

"NULL"0001L0#12345678[]

23 (0x0017)

0x480A

"ACK"0001L0#[]

14 (0x000E)

0xE77D

Tip: If your CRC values don't match these examples, check that you're using the correct polynomial (0x8005) and that your table is properly initialized.

Message Types

SIA-DCS (Alarm Events)

The simplest format for sending alarm events.

Format:

"SIA-DCS"<SEQ>L0#<ACCOUNT>[#<ACCOUNT>|<EVENT_CODE><ZONE>]

Or with optional timestamp:

"SIA-DCS"<SEQ>L0#<ACCOUNT>[#<ACCOUNT>|<EVENT_CODE><ZONE>]_<TIMESTAMP>

Field

Description

Example

SEQ

4-digit sequence number (0001-9999)

0001

ACCOUNT

Your account number from CallOnAlarm

12345678

EVENT_CODE

2-letter SIA code

BA (Burglary Alarm)

ZONE

3-4 digit zone number

001 or 0001

TIMESTAMP

Optional. Format: HH:MM:SS,MM-DD-YYYY

12:38:20,01-30-2026

Example - Burglary Alarm on Zone 1:

"SIA-DCS"0001L0#12345678[#12345678|BA001]

Example - With timestamp (optional):

"SIA-DCS"0001L0#12345678[#12345678|BA001]_12:38:20,01-30-2026

Complete message with framing:

Content: "SIA-DCS"0001L0#12345678[#12345678|BA001]
Length:  41 (0x0029)
CRC:     0xEB87

Full message: <LF>EB870029"SIA-DCS"0001L0#12345678[#12345678|BA001]<CR>

NULL (Heartbeat)

Keep the connection alive and verify connectivity.

Format:

"NULL"<SEQ>L0#<ACCOUNT>[]

Example:

"NULL"0001L0#12345678[]

Note: NULL messages do not trigger alerts. Use them for periodic connectivity checks (recommended: every 30-60 seconds for persistent connections).

ACK Response

After receiving a valid message, CallOnAlarm responds with an ACK.

Format:

<LF><CRC><LENGTH>"ACK"<SEQ>L0#[]<CR>

Example:

If you sent sequence 0001, you will receive:

<LF>E77D000E"ACK"0001L0#[]<CR>

Validating the ACK:

Extract sequence number

Extract the sequence number from the ACK message.

Verify match

Ensure the sequence matches the sequence you sent.

Optional CRC check

Optionally verify the CRC of the ACK payload.

Important: Always wait for the ACK before sending the next message or closing the connection.

Complete Examples

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdint.h>

// CRC16 Table (polynomial 0x8005)
static const uint16_t CRC16_TABLE[256] = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

uint16_t crc16(const char *data, size_t len) {
    uint16_t crc = 0;
    for (size_t i = 0; i < len; i++) {
        crc = (crc >> 8) ^ CRC16_TABLE[(crc ^ (uint8_t)data[i]) & 0xFF];
    }
    return crc;
}

int build_sia_message(char *buffer, size_t buffer_size,
                      const char *account, const char *event_code, 
                      const char *zone, uint16_t seq) {
    // Build content
    char content[256];
    int content_len = snprintf(content, sizeof(content),
        "\"SIA-DCS\"%04uL0#%s[#%s|%s%s]",
        seq, account, account, event_code, zone);
    
    // Calculate CRC
    uint16_t crc_value = crc16(content, content_len);
    
    // Build full message: LF + CRC + LEN + CONTENT + CR
    return snprintf(buffer, buffer_size,
        "\n%04X%04X%s\r",
        crc_value, content_len, content);
}

int send_alarm(const char *host, uint16_t port,
               const char *account, const char *event_code, const char *zone) {
    int sockfd;
    struct hostent *server;
    struct sockaddr_in serv_addr;
    char buffer[512];
    char response[256];
    
    // Create socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("ERROR opening socket");
        return -1;
    }
    
    // Set timeout (10 seconds)
    struct timeval timeout;
    timeout.tv_sec = 10;
    timeout.tv_usec = 0;
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    
    // Resolve hostname
    server = gethostbyname(host);
    if (server == NULL) {
        fprintf(stderr, "ERROR: no such host\n");
        close(sockfd);
        return -1;
    }
    
    // Setup address
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    memcpy(&serv_addr.sin_addr.s_addr, server->h_addr, server->h_length);
    serv_addr.sin_port = htons(port);
    
    // Connect
    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("ERROR connecting");
        close(sockfd);
        return -1;
    }
    
    // Build and send message
    int msg_len = build_sia_message(buffer, sizeof(buffer), account, event_code, zone, 1);
    printf("Sending: %s\n", buffer);
    
    if (write(sockfd, buffer, msg_len) < 0) {
        perror("ERROR writing to socket");
        close(sockfd);
        return -1;
    }
    
    // Wait for ACK
    int n = read(sockfd, response, sizeof(response) - 1);
    if (n < 0) {
        perror("ERROR reading from socket");
        close(sockfd);
        return -1;
    }
    
    response[n] = '\0';
    printf("Received: %s\n", response);
    
    // Check for ACK
    int success = (strstr(response, "\"ACK\"") != NULL);
    if (success) {
        printf("✓ Alarm acknowledged!\n");
    } else {
        printf("✗ Invalid response\n");
    }
    
    close(sockfd);
    return success ? 0 : -1;
}

int main(int argc, char *argv[]) {
    const char *host = "sia.callonalarm.io";
    uint16_t port = 5001;
    const char *account = "12345678";
    const char *event_code = "BA";
    const char *zone = "001";
    
    printf("Sending alarm to %s:%u\n", host, port);
    printf("Account: %s, Event: %s, Zone: %s\n", account, event_code, zone);
    
    return send_alarm(host, port, account, event_code, zone);
}

#include <WiFi.h>
#include <stdint.h>

// WiFi credentials
const char* WIFI_SSID = "your_ssid";
const char* WIFI_PASS = "your_password";

// CallOnAlarm configuration
const char* SIA_HOST = "sia.callonalarm.io";
const uint16_t SIA_PORT = 5001;
const char* ACCOUNT = "12345678";

// CRC16 Table
static const uint16_t CRC16_TABLE[256] PROGMEM = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

static uint16_t sequence = 1;

uint16_t crc16(const char* data, size_t len) {
    uint16_t crc = 0;
    for (size_t i = 0; i < len; i++) {
        uint16_t table_val = pgm_read_word(&CRC16_TABLE[(crc ^ data[i]) & 0xFF]);
        crc = (crc >> 8) ^ table_val;
    }
    return crc;
}

bool send_alarm(const char* event_code, const char* zone) {
    WiFiClient client;
    
    Serial.printf("Connecting to %s:%u...\n", SIA_HOST, SIA_PORT);
    
    if (!client.connect(SIA_HOST, SIA_PORT)) {
        Serial.println("Connection failed!");
        return false;
    }
    
    // Build content
    char content[128];
    snprintf(content, sizeof(content), 
             "\"SIA-DCS\"%04uL0#%s[#%s|%s%s]", 
             sequence, ACCOUNT, ACCOUNT, event_code, zone);
    
    // Calculate CRC and length
    uint16_t crc_value = crc16(content, strlen(content));
    uint16_t length = strlen(content);
    
    // Build full message
    char message[256];
    snprintf(message, sizeof(message), 
             "\n%04X%04X%s\r", crc_value, length, content);
    
    // Send
    Serial.printf("Sending: %s\n", message);
    client.print(message);
    
    // Wait for ACK (5 second timeout)
    unsigned long timeout = millis() + 5000;
    while (client.available() == 0 && millis() < timeout) {
        delay(10);
    }
    
    bool success = false;
    if (client.available()) {
        String response = client.readString();
        Serial.printf("Received: %s\n", response.c_str());
        
        if (response.indexOf("ACK") >= 0) {
            Serial.println("✓ Alarm acknowledged!");
            success = true;
        } else {
            Serial.println("✗ Invalid response");
        }
    } else {
        Serial.println("✗ Timeout waiting for ACK");
    }
    
    client.stop();
    
    // Increment sequence for next message
    sequence = (sequence % 9999) + 1;
    
    return success;
}

void setup() {
    Serial.begin(115200);
    delay(1000);
    
    Serial.println("Connecting to WiFi...");
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    
    Serial.println("\nWiFi connected!");
    Serial.printf("IP: %s\n", WiFi.localIP().toString().c_str());
}

void loop() {
    // Example: Send burglary alarm on zone 001
    // In real application, trigger this on sensor event
    
    if (send_alarm("BA", "001")) {
        Serial.println("Alarm sent successfully!");
    } else {
        Serial.println("Failed to send alarm");
    }
    
    // Wait before next test (remove in production)
    delay(60000);
}

You can test the ESP32 CallOnAlarm integration in the playground here: https://wokwi.com/projects/457058213945128961

Best Practices

Sequence Numbers

Increment the sequence number (0001-9999) for each message
Roll over from 9999 to 0001
Use the sequence to match ACKs to sent messages

Error Handling

Scenario

Action

No ACK received

Retry after 5 seconds (max 3 retries)

Connection refused

Retry after 30 seconds

Invalid ACK

Log and retry with new sequence

Timeout

Close connection, reconnect, retry

Persistent Connections

Heartbeats

Send a NULL heartbeat every 30-60 seconds.

Connection drops

Handle connection drops gracefully.

Reconnection

Implement automatic reconnection with exponential backoff.

Security Recommendations

Store account numbers securely
Implement rate limiting on your device
Validate ACK responses before proceeding

Troubleshooting

Common Issues

Problem

Cause

Solution

No ACK received

CRC mismatch

Verify CRC calculation

Connection closed immediately

Invalid first byte

Ensure message starts with LF (0x0A)

ACK received but no event in dashboard

Wrong account number

Verify account number matches your connection

Timeout

Network issue

Check firewall, verify host/port

Note: CallOnAlarm always sends an ACK for valid SIA messages, even if the account number doesn't exist. The only way to confirm your integration is working correctly is to check the Events section of your connection in the dashboard.

Testing Your Integration:

Create account

Create an account on CallOnAlarm.

Create connection

Create a connection but do not activate it — allows testing without triggering real alerts.

Connect device

Connect your device and send test messages.

Verify events

Check the Events tab in your connection dashboard to verify messages are received correctly.

Activate

Activate your connection only when testing is complete and everything works.

Security & Rate Limiting

CallOnAlarm implements server-side protections against abuse and misconfigured devices. Ensure your implementation follows best practices to avoid being banned.

Active Protections

Please, see this IP Banned by CallOnAlarm

Avoiding Bans

Cause

Solution

CRC calculation error

Verify your CRC implementation against test vectors

Missing framing bytes

Ensure messages start with LF and end with CR

Reconnection loop

Implement exponential backoff on connection failures

Excessive NULL heartbeats

For persistent connections only: send heartbeats every 30-60 seconds (30s min, 60s max)

Design Philosophy

Buffer Overflow = Attack → Immediate ban, no tolerance
Invalid Messages = Configuration Error → 10 attempts tolerance, then 1h ban
Rapid Connections = Port Scan/Flood/Brute-force → Detection and 1h to 24h ban
Automatic Reset → A valid message resets the error counter

Important: If your device gets banned, it will be automatically unbanned after the ban duration. Check your implementation before reconnecting.

Event Codes Reference

The EVENT_CODE field uses standard SIA (Security Industry Association) codes.

Complete event codes list in the API v1 section : Event Codes Reference

Support

For integration support, contact us at:

Email: [email protected]
Documentation: https://docs.callonalarm.io

Changelog

v1.0.0 (2026-01-30)

Initial release
SIA-DCS and NULL message support
CRC-16 ASCII format
C examples (POSIX and ESP32/Arduino)

PreviousSIA DC-09 Alarm Panels Configuration NextLegal Notice

Last updated 1 month ago

hashtagOverview

hashtagWhy SIA over TCP?

hashtagConnection Details

hashtagConnection Lifecycle

hashtagTimeouts

hashtagMessage Format

hashtagStructure

hashtagCRC-16 Calculation

hashtagTest Vectors

hashtagMessage Types

hashtagSIA-DCS (Alarm Events)

hashtagNULL (Heartbeat)

hashtagACK Response

hashtagExtract sequence number

hashtagVerify match

hashtagOptional CRC check

hashtagComplete Examples

hashtagBest Practices

hashtagSequence Numbers

hashtagError Handling

hashtagPersistent Connections

hashtagHeartbeats

hashtagConnection drops

hashtagReconnection

hashtagSecurity Recommendations

hashtagTroubleshooting

hashtagCommon Issues

hashtagCreate account

hashtagCreate connection

hashtagConnect device

hashtagVerify events

hashtagActivate

hashtagSecurity & Rate Limiting

hashtagActive Protections

hashtagAvoiding Bans

hashtagDesign Philosophy

hashtagEvent Codes Reference

hashtagSupport

hashtagChangelog

hashtagv1.0.0 (2026-01-30)

Overview

Why SIA over TCP?

Connection Details

Connection Lifecycle

Timeouts

Message Format

Structure

CRC-16 Calculation

Test Vectors

Message Types

SIA-DCS (Alarm Events)

NULL (Heartbeat)

ACK Response

Extract sequence number

Verify match

Optional CRC check

Complete Examples

Best Practices

Sequence Numbers

Error Handling

Persistent Connections

Heartbeats

Connection drops

Reconnection

Security Recommendations

Troubleshooting

Common Issues

Create account

Create connection

Connect device

Verify events

Activate

Security & Rate Limiting

Active Protections

Avoiding Bans

Design Philosophy

Event Codes Reference

Support

Changelog

v1.0.0 (2026-01-30)