Help

IoT Digital Signage Architecture

Complete system design for sensor-driven, event-based digital signage
From GPIO pins to cloud-connected displays

[ Event System | GPIO Integration | Multi-Device Scalability ]

Complete IoT Architecture for Digital Signage

The Digital Signage IoT system is built on a layered architecture that connects physical sensors and devices to dynamic display content. This event-driven design enables real-time data flow from temperature sensors, motion detectors, and buttons to interactive signage displays.

Whether you're building an elevator floor indicator, temperature-responsive menu boards, or touch-activated automation, this architecture provides the foundation for smart, responsive digital signage solutions.

► Watch Video Tutorial - Step-by-step guide to IoT Digital Signage setup

System Layers Architecture

Four distinct layers work together to create a complete IoT signage ecosystem

+============================================================================+
||                          PRESENTATION LAYER                              ||
||  +--------------------------------------------------------------------+  ||
||  |  SignStudio (Web UI)     |  SignPlayer (Display)  |  IoT Web Portal|  ||
||  |  - Scene Design          |  - Content Rendering   |  - Testing UI  |  ||
||  |  - Event Configuration   |  - Touch Events        |  - Monitoring  |  ||
||  |  - Deployment            |  - Event Handling      |  - Debugging   |  ||
||  +--------------------------------------------------------------------+  ||
+============================================================================+
                                     |
                                     v
+============================================================================+
||                          COMMUNICATION LAYER                             ||
||  +--------------------------------------------------------------------+  ||
||  |                    SignService (C# WatchDog)                       |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  |  | REST API (HTTPS:8094)  |  | Event Router & Callback Manager  |  |  ||
||  |  | - /player/sendEvent    |  | - Event Registration             |  |  ||
||  |  | - /player/registerEvent|  | - Callback Dispatch              |  |  ||
||  |  | - Health Monitoring    |  | - Event Storage (store=1)        |  |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  +--------------------------------------------------------------------+  ||
+============================================================================+
                                     |
                                     v
+============================================================================+
||                          IOT PROCESSING LAYER                            ||
||  +--------------------------------------------------------------------+  ||
||  |                     Node.js IoT Scripts                            |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  |  | Event Senders          |  | Event Receivers                  |  |  ||
||  |  | - iotSendTemperture.js |  | - iotReceiveAlertRelay.js        |  |  ||
||  |  | - Custom sensors       |  | - iotReceiveAlertAudio.js        |  |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  +--------------------------------------------------------------------+  ||
+============================================================================+
                                     |
                                     v
+============================================================================+
||                          HARDWARE LAYER                                  ||
||  +--------------------------------------------------------------------+  ||
||  |                     Raspberry Pi GPIO                              |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  |  | Input Devices          |  | Output Devices                   |  |  ||
||  |  | - DHT11 Temperature    |  | - Relays                         |  |  ||
||  |  | - PIR Motion Sensors   |  | - LEDs                           |  |  ||
||  |  | - Buttons/Switches     |  | - Buzzers/Speakers               |  |  ||
||  |  | - Floor Sensors        |  | - Motor Controllers              |  |  ||
||  |  +------------------------+  +----------------------------------+  |  ||
||  +--------------------------------------------------------------------+  ||
+============================================================================+

4

System Layers

REST

API Communication

40

GPIO Pins Available

Real-time

Event Processing

Presentation Layer

The user-facing components where content is designed, displayed, and monitored.

SignStudio - Web-based scene designer with event configuration
SignPlayer - Display renderer handling touch and content events
IoT Web Portal - Testing and debugging interface for IoT integration

Communication Layer

The middleware that routes events between all system components.

SignService - C# watchdog daemon managing all communications
REST API - HTTPS endpoints on port 8094 for event handling
Event Router - Manages callback registrations and dispatch

IoT Processing Layer

Node.js scripts that bridge hardware sensors with the signage platform.

Event Senders - Read sensor data and push to SignService
Event Receivers - Listen for callbacks and control outputs
Custom Scripts - Extensible architecture for any IoT scenario

Hardware Layer

Physical devices connected via Raspberry Pi GPIO pins.

Input Devices - Temperature sensors, motion detectors, buttons
Output Devices - Relays, LEDs, buzzers, motor controllers
GPIO Control - Python lgpio library for hardware access

Event Registration & Dispatch Flow

How IoT scripts register for events and receive callbacks from the signage system

+-----------------------------------------------------------------------------+
|                         EVENT REGISTRATION FLOW                              |
+-----------------------------------------------------------------------------+

  Node.js IoT Script                    SignService
  (Event Receiver)                      (C# WatchDog)
         |                                    |
         |  POST /player/registerEvent        |
         |  ?eventName=clickAlarm             |
         |  &callbackUrl=http://pi:5001/cb    |
         +----------------------------------->|
         |                                    |
         |                                    |  Store in Registry:
         |                                    |  +------------------+
         |                                    |  | Event Registry   |
         |                                    |  |------------------|
         |                                    |  | clickAlarm:      |
         |                                    |  |   - http://pi1/cb|
         |                                    |  |   - http://pi2/cb|
         |                                    |  | tempUpdate:      |
         |                                    |  |   - http://pi3/cb|
         |                                    |  +------------------+
         |                                    |
         |  200 OK                            |
         |<-----------------------------------+
         |                                    |

+-----------------------------------------------------------------------------+
|                         EVENT DISPATCH FLOW                                  |
+-----------------------------------------------------------------------------+

  SignPlayer                            SignService                  Node.js
  (Display)                             (C# WatchDog)                (Receiver)
      |                                      |                           |
      |  Event: clickAlarm                   |                           |
      |  Data: {"clickAlarm": "on"}          |                           |
      +------------------------------------->|                           |
      |                                      |                           |
      |                                      |  Lookup callbacks for     |
      |                                      |  "clickAlarm" event       |
      |                                      |                           |
      |                                      |  POST to each callback    |
      |                                      +-------------------------->|
      |                                      |                           |
      |                                      |                           |  Process
      |                                      |                           |  Event
      |                                      |                           +---+
      |                                      |                           |   |
      |                                      |  200 OK                   |<--+
      |                                      |<--------------------------+
      |                                      |                           |

SignStudio Event Configuration

In SignStudio, users can configure scenes with interactive components that fire events to IoT devices:

+-----------------------------------------------------------------------------+
|                           SIGNSTUDIO SCENE                                   |
|  +-----------------------------------------------------------------------+  |
|  |                         Scene Canvas (1920x1080)                      |  |
|  |                                                                       |  |
|  |    +-------------------+           +-------------------+              |  |
|  |    |   Button Block    |           |   Label Block     |              |  |
|  |    |   "Alarm ON"      |           |   "Temperature"   |              |  |
|  |    |                   |           |                   |              |  |
|  |    | EventCommand:     |           | DataBinding:      |              |  |
|  |    |   from: "click"   |           |   field: "name"   |              |  |
|  |    |   command: "send" |           |   event: "temp"   |              |  |
|  |    |   event: "click-  |           |                   |              |  |
|  |    |          Alarm"   |           |                   |              |  |
|  |    |   data: {"click-  |           |                   |              |  |
|  |    |     Alarm": "on"} |           |                   |              |  |
|  |    +-------------------+           +-------------------+              |  |
|  |                                                                       |  |
|  +-----------------------------------------------------------------------+  |
+-----------------------------------------------------------------------------+

                            |                           |
                            v                           v
              +---------------------------+  +---------------------------+
              | OUTBOUND EVENT            |  | INBOUND DATA BINDING      |
              | User taps button -->      |  | IoT sends data -->        |
              | SignPlayer fires event--> |  | SignService receives -->  |
              | SignService routes -->    |  | SignPlayer updates -->    |
              | Node.js receives          |  | Label displays "25.3C"    |
              +---------------------------+  +---------------------------+

Event Configuration JSON Structure

When a user configures an interactive button in SignStudio:

{
  "$": {
    "player": "7000",
    "label": "Alarm Button",
    "id": "__100"
  },
  "Data": [{
    "Layout": [{
      "$": {
        "x": "800",
        "y": "500",
        "width": "300",
        "height": "100"
      }
    }],
    "Button": [{
      "$": {
        "label": "Alarm ON",
        "fieldName": "clickAlarm"
      }
    }],
    "EventCommands": [{
      "EventCommand": [{
        "$": {
          "from": "click",
          "command": "sendEvent"
        },
        "Params": {
          "eventName": "clickAlarm",
          "data": {
            "clickAlarm": "on"
          }
        }
      }]
    }]
  }]
}

Real-World Data Flow Scenarios

Scenario 1: Temperature Monitoring

+-----------------------------------------------------------------------------+
|                     TEMPERATURE MONITORING FLOW                              |
+-----------------------------------------------------------------------------+

   DHT11         Node.js              SignService           SignPlayer
   Sensor        Script               (C#)                  (Display)
     |              |                      |                     |
     |  Read Temp   |                      |                     |
     +------------->|                      |                     |
     |              |                      |                     |
     |   25.3C      |                      |                     |
     |<-------------+                      |                     |
     |              |                      |                     |
     |              |  POST /player/sendEvent                    |
     |              |  ?eventName=myCustomEvent                  |
     |              |  {"name": "25.3"}    |                     |
     |              +--------------------->|                     |
     |              |                      |                     |
     |              |                      |  Forward to Player  |
     |              |                      +-------------------->|
     |              |                      |                     |
     |              |                      |                     |  Update Label
     |              |                      |                     |  with "25.3"
     |              |                      |                     +----+
     |              |                      |                     |    |
     |              |                      |                     |<---+

   +------------------------------------------------------------------------+
   | DISPLAY OUTPUT:                                                        |
   |    +--------------------------------------------------+                |
   |    |              ROOM TEMPERATURE                    |                |
   |    |                   25.3 C                         |                |
   |    +--------------------------------------------------+                |
   +------------------------------------------------------------------------+

Scenario 2: Touch-Activated Relay

+-----------------------------------------------------------------------------+
|                     TOUCH-ACTIVATED RELAY FLOW                               |
+-----------------------------------------------------------------------------+

  SignPlayer          SignService           Node.js            Relay
  (Display)           (C#)                  Script             (GPIO 4)
      |                    |                    |                  |
      |  User Touches      |                    |                  |
      |  "Alarm ON"        |                    |                  |
      +----+               |                    |                  |
      |    |               |                    |                  |
      |<---+               |                    |                  |
      |                    |                    |                  |
      |  Event:            |                    |                  |
      |  clickAlarm        |                    |                  |
      |  {"clickAlarm":    |                    |                  |
      |    "on"}           |                    |                  |
      +------------------->|                    |                  |
      |                    |                    |                  |
      |                    |  Lookup: clickAlarm has               |
      |                    |  callback: http://pi:5001/callback    |
      |                    |                    |                  |
      |                    |  POST /callback    |                  |
      |                    |  {"eventName":     |                  |
      |                    |   "clickAlarm",    |                  |
      |                    |   "data": {...}}   |                  |
      |                    +------------------->|                  |
      |                    |                    |                  |
      |                    |                    |  GPIO Write      |
      |                    |                    |  Pin 4 = HIGH    |
      |                    |                    +----------------->|
      |                    |                    |                  |
      |                    |                    |                  |  RELAY ON
      |                    |                    |                  +---+
      |                    |                    |                  |   |
      |                    |                    |                  |<--+

Scenario 3: Elevator Floor Indicator

+-----------------------------------------------------------------------------+
|                     ELEVATOR FLOOR INDICATOR FLOW                            |
+-----------------------------------------------------------------------------+

  Floor           Node.js              SignService           SignPlayer
  Sensor          Script               (C#)                  (Elevator Display)
    |                |                      |                     |
    |  Floor 5       |                      |                     |
    |  Detected      |                      |                     |
    +--------------->|                      |                     |
    |                |                      |                     |
    |                |  POST /player/sendEvent                    |
    |                |  ?eventName=elevatorFloor                  |
    |                |  {"floor": 5, "direction": "up"}           |
    |                +--------------------->|                     |
    |                |                      |                     |
    |                |                      |  Forward to Player  |
    |                |                      +-------------------->|
    |                |                      |                     |
    |                |                      |                     |  Update Display
    |                |                      |                     +----+
    |                |                      |                     |    |
    |                |                      |                     |<---+

   +------------------------------------------------------------------------+
   | DISPLAY OUTPUT:                                                        |
   |    +--------------------------------------------------+                |
   |    |                  FLOOR                           |                |
   |    |                    5                             |                |
   |    |                    ^                             |                |
   |    |                  (UP)                            |                |
   |    +--------------------------------------------------+                |
   +------------------------------------------------------------------------+

Network Topology

A typical IoT digital signage deployment connects multiple Raspberry Pi devices through a local network to a central SignService hub:

+-----------------------------------------------------------------------------+
|                           NETWORK TOPOLOGY                                   |
+-----------------------------------------------------------------------------+

                              INTERNET
                                 |
                    +------------+------------+
                    |      Cloud Server       |
                    |    (SignCloud API)      |
                    +------------+------------+
                                 |
                                 | HTTPS
                                 |
    +============================|============================+
    |                      ROUTER/FIREWALL                    |
    |                      192.168.68.1                       |
    +============================|============================+
                                 |
          +----------------------+----------------------+
          |                      |                      |
          v                      v                      v
    +-----------+          +-----------+          +-----------+
    | Windows   |          |   Pi #1   |          |   Pi #2   |
    | Server    |          | SignPlayer|          | IoT Node  |
    | (Service) |          | + Display |          | + Sensors |
    +-----------+          +-----------+          +-----------+
    |192.168.68.|          |192.168.68.|          |192.168.68.|
    |    .52    |          |    .24    |          |    .25    |
    +-----------+          +-----------+          +-----------+
          |                      |                      |
          |      HTTPS:8094      |                      |
          |<-------------------->|                      |
          |                      |                      |
          |             HTTP Callbacks (5001)           |
          |<--------------------------------------------+
          |                      |                      |
          |      Events          |                      |
          +--------------------->|                      |
          |                      |                      |

Port Configuration

Service	Port	Protocol	Purpose
SignService	8094	HTTPS	Main API endpoint for all event communication
IoT Web Portal	5000	HTTP	Testing and debugging web interface
IoT Relay Receiver	5001	HTTP	Callback endpoint for relay control
IoT Audio Receiver	5002	HTTP	Callback endpoint for audio alerts

GPIO Architecture

Raspberry Pi GPIO pin layout and common IoT connections

+-----------------------------------------------------------------------------+
|                        RASPBERRY PI GPIO LAYOUT                              |
|                           (40-Pin Header)                                    |
+-----------------------------------------------------------------------------+

                    +-----+-----+
          3.3V   1  |  o  |  o  |  2   5V
    (SDA) GPIO2  3  |  o  |  o  |  4   5V
    (SCL) GPIO3  5  |  o  |  o  |  6   GND
          GPIO4  7  |  o  |  o  |  8   GPIO14 (TXD)    <-- Relay Default
          GND    9  |  o  |  o  | 10   GPIO15 (RXD)
         GPIO17 11  |  o  |  o  | 12   GPIO18 (PWM)
         GPIO27 13  |  o  |  o  | 14   GND
         GPIO22 15  |  o  |  o  | 16   GPIO23
          3.3V  17  |  o  |  o  | 18   GPIO24
   (MOSI)GPIO10 19  |  o  |  o  | 20   GND
   (MISO) GPIO9 21  |  o  |  o  | 22   GPIO25
   (SCLK)GPIO11 23  |  o  |  o  | 24   GPIO8 (CE0)
          GND   25  |  o  |  o  | 26   GPIO7 (CE1)
    (ID_SD)     27  |  o  |  o  | 28   (ID_SC)
          GPIO5 29  |  o  |  o  | 30   GND             <-- DHT11 Data
          GPIO6 31  |  o  |  o  | 32   GPIO12
         GPIO13 33  |  o  |  o  | 34   GND
         GPIO19 35  |  o  |  o  | 36   GPIO16
         GPIO26 37  |  o  |  o  | 38   GPIO20
          GND   39  |  o  |  o  | 40   GPIO21
                    +-----+-----+

DHT11 Temperature Sensor Wiring

  +--------+     +---------------------+
  | DHT11  |     |    Raspberry Pi     |
  |--------|     |---------------------|
  | VCC    |---->| Pin 1 (3.3V)        |
  | DATA   |---->| Pin 29 (GPIO 5)     |
  | GND    |---->| Pin 30 (GND)        |
  +--------+     +---------------------+

Relay Module Wiring

  +--------+     +---------------------+
  | Relay  |     |    Raspberry Pi     |
  |--------|     |---------------------|
  | VCC    |---->| Pin 2 (5V)          |
  | IN     |---->| Pin 7 (GPIO 4)      |
  | GND    |---->| Pin 6 (GND)         |
  +--------+     +---------------------+

GPIO Control via lgpio (Python Bridge)

The Node.js scripts use Python with lgpio for GPIO control:

+-----------------------------------------------------------------------------+
|                        GPIO CONTROL FLOW                                     |
+-----------------------------------------------------------------------------+

  Node.js                   Python                    GPIO
  Script                    (lgpio)                   Hardware
     |                         |                         |
     |  exec("python3 -c       |                         |
     |    'import lgpio;       |                         |
     |     h=gpiochip_open(0); |                         |
     |     gpio_write(h,4,1)'  |                         |
     |    ")                   |                         |
     +------------------------>|                         |
     |                         |                         |
     |                         |  lgpio.gpio_write(      |
     |                         |    handle, 4, 1)        |
     |                         +------------------------>|
     |                         |                         |
     |                         |                         |  Pin 4 = HIGH
     |                         |                         +----+
     |                         |                         |    |
     |                         |                         |<---+
     |                         |                         |
     |  exit code: 0           |                         |
     |<------------------------+                         |
     |                         |                         |

Security Considerations

Important security aspects to consider when deploying IoT digital signage:

Network Security

SignService uses HTTPS with self-signed certificates
Node.js uses --insecure flag for self-signed certs
Local network only - no internet exposure recommended
Firewall: Only allow ports 8094, 5000-5002 on local network

API Security

No authentication by default (local network assumption)
Consider adding API keys for production deployments
Validate all input data before processing
Sanitize event names and callback URLs

GPIO Security

Scripts run as root for GPIO access
Limit which GPIO pins can be controlled
Validate commands before execution
Consider using dedicated IoT user with limited permissions

Multi-Device Scalability

Scale from a single display to enterprise-wide deployments with centralized event routing

+-----------------------------------------------------------------------------+
|                        MULTI-DEVICE DEPLOYMENT                               |
+-----------------------------------------------------------------------------+

                           SignService
                           (Central Hub)
                                |
          +---------------------+---------------------+
          |                     |                     |
          v                     v                     v
    +-----------+         +-----------+         +-----------+
    |   Pi #1   |         |   Pi #2   |         |   Pi #3   |
    | Lobby     |         | Elevator  |         | Cafeteria |
    | Display   |         | Display   |         | Display   |
    +-----------+         +-----------+         +-----------+
         |                      |                     |
         v                      v                     v
    +-----------+         +-----------+         +-----------+
    | Motion    |         | Floor     |         | Menu      |
    | Sensor    |         | Sensor    |         | Touch     |
    +-----------+         +-----------+         +-----------+

+-----------------------------------------------------------------------------+
|  Event Routing:                                                              |
|  - Each Pi registers for relevant events                                     |
|  - SignService routes events to appropriate callbacks                        |
|  - Multiple Pis can listen to same event                                     |
|  - Events can be broadcast to all or targeted to specific devices            |
+-----------------------------------------------------------------------------+

1 to 1000+

Scalable Device Count

Centralized

Event Management

Broadcast

Or Targeted Events

Explore Related IoT & Digital Signage Resources

Learn more about implementing IoT-enabled digital signage solutions:

Ready to Build IoT-Enabled Digital Signage?

Start with our FREE platform and connect sensors, displays, and automation to create smart, responsive signage solutions.

Get Started FREE View Tutorials

live examples, see it in action

Checkout live examples of Digital Signage presentations. The SignPlayer can run everywhere, on Android, Windows, Mac, iPad and even inside your web browser

product pricing

Find out why people call us “the world’s most popular digital signage platform”

customers

Can it really be free?
What’s the catch?
Want to be amazed?
Read on...