Samsung TV (IP)

Samsung Tizen smart TVs — the 2016-and-newer consumer line, including The Frame — are controlled over the TV's own network services. Samsung never shipped one IP control API: a current Tizen set answers on five local services at once, each good for a different job, and this driver picks the best one per operation and falls back down the chain when a service is missing or unpaired. One TV becomes one GEM device, and commands target that device directly (this driver creates no zones).

This is the path that replaces Ex-Link serial control and a Global Caché / serial-to-IP adapter on new installs: discrete input switching, absolute volume, verified power-on and power-off, art mode, apps, keys and text entry, all over the LAN with nothing wired to the TV.

Service	Port	What GEM uses it for	Pairing
REST (/api/v2/)	8001	Device info, power state, app status / launch / close	None
UPnP RenderingControl	9197	Volume and mute, read and set — the fastest path (~20 ms read, ~90 ms set)	None
JSON-RPC control API (HTTPS)	1516	Discrete input switching, input / picture-mode / sound-mode readback, power off, acknowledged art mode, direct volume	Own token (rpc_token, from pair)
Tizen websocket remote (wss)	8002	Remote keys, text entry, app deep links; the same socket family carries the art channel (artwork, brightness, mattes, slideshow)	Own token (token, prompt on first connect)
Wake-on-LAN	—	The only way on from standby — the TV leaves the network when it sleeps	MAC learned automatically

Everything on this page was verified against a 2021 Frame (QN50LS03A, Tizen 6). The same services exist on ordinary consumer sets; port 1516 is not a "Pro" or commercial-only feature.

Which Samsung driver?

Samsung ships several control paths, and GEM has a driver for each:

• Samsung TV (IP) (this page) — networked Tizen sets (2016+, including The Frame). Prefer this for any new install.
• Samsung MDC — Samsung commercial / signage panels that speak the MDC protocol (Display ID addressing, a different command set).
• Samsung TV (Serial-over-IP) — the TV's RS-232 (Ex-Link) service port through a serial-to-IP adapter, for sets that cannot be reached over the network.

If you remember a separate samsung_tv_pro driver: it no longer exists. The port-1516 HTTPS API it wrapped is now one of the transports inside this driver, paired with the same pair command.

What's controlled

• Power — on (Wake-on-LAN, verified by polling until the TV answers) and off (real standby, or art mode on a Frame if you prefer), plus a state-aware toggle.
• Inputs — discrete switching to TV, HDMI 1–4 or "the active HDMI", with readback of the current input, picture mode and sound mode.
• Volume and mute — absolute level 0–100, step up/down, discrete mute on/off, a toggle that reads the live mute state first, and readback of both.
• Navigation, transport and keys — the D-pad, menu/guide/exit/home/info/tools/back, play/pause/ stop/rewind/fast-forward, digits, any Samsung remote key by name, press-and-hold, paced key sequences, and typing text into the focused field.
• Channels — direct entry (7, 7-1), up/down, previous channel.
• Apps — launch by name or app id, close, status, and a list of what is installed.
• Art Mode (The Frame) — art on/off, the artwork on screen, the stored library, selecting, favouriting and deleting artwork, brightness / colour temperature / motion sensor settings, slideshow, mattes and photo filters.
• Live status — GEM polls the TV every few seconds and writes power, mode, volume, mute, input, art state and more to device attributes, so touchpanels and triggers stay in sync.
• Diagnostics — one command probes every transport and reports latency, tokens, MAC detection and the driver's state, so a commissioning problem can be read from the UI.

Prerequisites

• A Samsung Tizen TV on the same LAN as GEM, reachable by IP with no NAT in between. Give it a static IP or a DHCP reservation so the address never moves.
• Wake-on-LAN enabled on the TV if power_on must work from standby: Settings → General → Network → Expert Settings → Power On with Mobile (some firmware calls it Network Standby). GEM and the TV must share a broadcast domain (same VLAN / subnet).
• The TV on while you pair — the allow-prompts only appear on a live screen.
• Nothing to type for the MAC: GEM learns it from the network (see the power section below). Set mac_address by hand only if the automatic detection cannot see the TV.

Setup

1. Open Devices, add a device, and choose the Samsung TV (IP) driver. It suggests the AV subsystem and a tv device type — accept those.

2. Enter the TV IP Address (required), e.g. 192.168.1.50. Leave everything else at its default for now. Save and enable the device.

3. Pair. With the TV on, run the pair command against the device — from the Script Console:

   await gem.command({device: <device_id>, action: 'pair'});

   or from System → Commands. The TV shows two prompts, one after the other:

   • "Allow GEM?" — the websocket remote. Accepting it stores the token attribute. This prompt also appears by itself the first time any key command runs, so a TV that was set up on the older websocket-only driver is already half paired.
   • A second access prompt — the port-1516 control API. Accepting it stores rpc_token.

   Accept each within about a minute. pair returns {remote: 'paired', rpc: 'paired'} when both took; a transport argument of remote or rpc re-runs just one half.

4. Verify. Run diagnostics and confirm REST, UPnP, the control API (rpc) and the websocket (remote) all report ok: true (see the Diagnostics section below). Then run get_status and check that power, volume, mute and input match what the TV is doing.

What each token unlocks

Paired	What works
Nothing	Power state and device info over REST; volume and mute over UPnP (set and read); app launch, close and status over REST; Wake-on-LAN power-on.
token (websocket)	Everything above plus remote keys, text entry, key sequences, channel entry, app deep links, art-channel features (artwork, brightness, slideshow, mattes), and art-mode switching on a Frame.
rpc_token (control API)	Discrete input switching and input readback, picture / sound mode readback, acknowledged art-mode switching, power-off without a key hold, direct volume as a UPnP fallback, and a limited key set as a websocket fallback.

Pair both. The driver degrades to whatever it has, but the control API is what makes hdmi_1–hdmi_4 a single verified call instead of a remote key the firmware ignores.

Power on, off, and Wake-on-LAN

A Frame has three states — showing TV, showing art, and standby — and a plain set has two. The REST port reports both TV and art as on, so the driver keeps power_state a two-value on / off for everything that already depends on it, and writes the finer state to a separate mode attribute: tv, art, standby (the TV answered REST but reports standby) or off (unreachable).

power_on sends a Wake-on-LAN magic packet, waits wake_interval (default 4 s), probes the TV over REST, and repeats until the TV answers or wake_timeout (default 30 s) elapses. The packet goes to the global broadcast address, the directed broadcast of every local subnet that contains the TV (so multi-NIC GEM boxes reach the right VLAN), and the TV's own IP. If the control API is paired, a powerOn request is also sent in case the TV is still in its short standby window. Once the TV is up, a Frame that woke into art mode is switched to TV — power_on means "show a picture".

The MAC comes from the network, not from a form field: after every successful REST probe the driver reads the TV's entry in the ARP table (the MAC of whichever interface the TV is actually using, which is right for a wired set where the TV's own wifiMac report would be wrong), falls back to the wifiMac the TV reports, and stores the result in detected_mac. If mac_address is blank it is filled in from that. If you set mac_address by hand and it disagrees with the ARP table, the driver logs a warning once and sends wake packets to both.

Wake-on-LAN is best-effort on 2020/2021 Frames

These sets drop off the network entirely a few seconds after entering standby. On the test unit a single burst of packets did nothing in 45 s; the TV only woke during a repeated-send loop, which is why power_on loops. Keep Power On with Mobile enabled, keep GEM on the TV's VLAN, and if cold power-on must be beyond doubt, an IR blaster on the TV's power code remains the fallback.

power_off reaches real standby. With the control API paired it is one acknowledged powerOff call. Without it, a Frame gets a 3 s hold of KEY_POWER (a plain click only toggles art mode on a Frame) and any other set gets KEY_POWEROFF. The driver marks the TV off immediately and confirms on the next poll.

Set power_off_mode to art if a Frame should switch to art mode on power_off instead of going dark — that is the behaviour the old websocket-only driver had by accident, and some homeowners want it. The default is standby.

power_toggle probes the TV and runs power_off when it is on, power_on when it is off, so it works from either state.

Inputs

hdmi_1–hdmi_4, tuner and the general input command (argument input: tv, hdmi, hdmi_1…hdmi_4; hdmi picks the active HDMI port) switch the TV over the control API on port 1516 — one discrete, acknowledged call. get_input reads the current input the same way. Two TV-side rules apply:

Inputs and art mode

A Frame showing art ignores input changes: the control API answers inputSourceControl with Method not found until art mode is off. Every input command therefore leaves art mode first (and waits for the TV to confirm it), then switches. Verified on the 2021 Frame.

• The TV only switches to an input with a powered device attached. Ask for an empty port and the command returns tv refused input HDMI1: no powered device on that port while the TV shows "not found". This is the TV, not the driver — power the source first (a room-on macro should bring the source up before the input switch).
• KEY_HDMI1–KEY_HDMI4 remote codes are ignored by 2016+ firmware. Without the control API there is no discrete switch over the websocket.

input_method chooses the mechanism:

Value	Behaviour
auto (default)	Control API when rpc_token is present; otherwise the legacy remote key (exactly what the old driver sent). If the control API is unreachable mid-session it falls back to the key rather than failing.
rpc	Control API only. Errors if not paired.
key	Legacy KEY_HDMIn / KEY_TV only — for older firmware that still honours them.
source_bar	Drive the on-screen source bar with keys: KEY_SOURCE, wait source_bar_delay (1500 ms), left past the start of the bar, right n steps, enter. source_bar_order gives the bar's left-to-right order (default tv,hdmi1,hdmi2,hdmi3,hdmi4). Use it on a set that refuses to pair the control API.

Without the control API, get_input returns the last input GEM set, with a note that readback needs pairing.

Volume and mute

Volume runs over the TV's UPnP RenderingControl service — no pairing, ~20 ms reads and ~90 ms sets, verified to land every call in a burst of ten. If UPnP fails and the control API is paired, the driver retries the same operation over port 1516 (directVolumeControl, muteControl); mute falls back once more to the KEY_MUTE toggle, but only when the current state is known so it never flips the wrong way.

• volume / set_volume — absolute level 0–100 (level argument; clamped).
• volume_up / volume_down — one step, as remote keys.
• mute_on / mute_off — discrete, over UPnP.
• mute_toggle — reads the live mute state over UPnP first, then sets the opposite, so a toggle after someone used the physical remote still does the right thing.
• get_volume / get_mute — readback.

In an AV zone, set this device as the zone's Volume Device (see AV Zones) — the zone's volume slider and mute button route straight to it, and because the driver has a native mute_toggle no server-side emulation is involved. Wire power_on, the input switch and power_off into the zone's on/off macros.

Keys, text and channels

Key traffic goes over a persistent websocket that the driver opens on the first key (and keeps warm while the TV is on), with a heartbeat that detects a dead socket and a reconnect on the next press. Keys are serialised with a 200 ms gap (key_delay) because the TV coalesces presses that arrive back-to-back — five KEY_VOLUP frames sent with no gap register as one. If the websocket is unavailable and the control API is paired, the cursor, enter/menu/exit/return, transport, digit and volume keys are sent over port 1516 instead.

Command	Notes
up down left right enter menu guide exit home info tools back	One remote key each.
play pause stop rewind fast_forward	Transport keys.
0–9	Digit keys.
send_key (key)	Any Samsung key by name. The KEY_ prefix is optional and case does not matter (volup, KEY_VOLUP, VolUp). Aliases: ok/select, back, volup/voldown, chup/chdown, rw, forward, art (KEY_AMBIENT), dash.
hold_key (key, duration)	Press-and-hold for duration ms (default 2000).
key_sequence (sequence)	Several keys with pacing in one command: source wait:1.5 left*8 right*2 enter. Tokens are keys (with the same aliases), name*N repeats (max 50), and wait:SECS / 1.5s pauses. Runs as one unit so nothing interleaves.
send_text (text)	Types into the focused text field on the TV (a search box, a login form).
channel (channel, or major / minor)	Direct entry: 7, 7-1 or major=7 minor=1. Sent as digit keys, the dash, then enter.
channel_up channel_down previous_channel	Remote keys.
source	Opens the on-screen source bar.

Apps

• launch_app (app_id, optional app_type, meta_tag) — by name or raw Tizen app id. In the command tester and macro editor the app_id picker lists the apps installed on the selected TV (it runs get_apps behind the scenes) as Netflix (3201907018807) and sends the id; the same picker backs close_app and app_status. It stays empty until a concrete device is chosen or while the TV is unreachable, and a known name can always be typed instead. Known names: netflix, youtube, youtubetv, prime, disney, appletv, applemusic, spotify, plex, max, hulu, browser, smartthings. Launches over the websocket as a DEEP_LINK (pass NATIVE_LAUNCH to open the app without a link, and meta_tag for a content deep link); if the websocket is unavailable it falls back to a REST launch, which cannot deep-link.
• close_app (app_id) and app_status (app_id) — over REST, no pairing needed; status returns running and visible.
• get_apps — asks the TV for its installed-app list over the websocket. Current firmware ignores that query, so the driver then probes the well-known ids above over REST and returns the ones the TV answers for. The result is cached for five minutes.

Art Mode (The Frame)

Both switching mechanisms are verified by reading the state back. The control API acknowledges an art-mode change immediately, but the TV takes several seconds to finish switching and ignores a request that lands mid-transition, so the driver polls the state and re-sends until it holds (up to about ten seconds), exactly as it does on the art channel. A Frame that has dozed off through its motion sensor is woken with Wake-on-LAN first, then switched to art.

Art features need a Frame (the driver refuses them on a set whose device info says it is not one) and the websocket token; art-mode switching also uses the control API when paired.

• art_mode_on / art_mode_off — with the control API, one acknowledged call. Without it, the driver uses the art channel: older firmware never acknowledges set_artmode_status and ignores it while the TV is still switching, so the driver sends, polls the status every second, re-sends every ~3 s and reports success only when the readback matches (up to ~10 s). art_mode_on wakes a TV that is off first.

• art_current — the artwork on screen (content_id, matte ids); also written to the artwork attribute.

• art_list (category: mine, favorites, store, or a raw category id) — the stored library.

• art_select (content_id, show) — show a stored artwork; the driver reads the current artwork back and reports an error if it did not change (an unknown id, for instance).

• art_favorite (content_id, state on/off) and art_delete (content_id, comma-separated for several).

• art_setting (setting, value) — read (no value) or set one setting; every set is read back and an unchanged value is reported as an error, because older firmware silently drops set_*:

  setting	Values
  brightness	0–10
  color_temperature	−5…5
  motion_sensitivity	1–3
  motion_timer	off, 5, 15, 30, 60, 120, 240 (minutes)
  brightness_sensor_setting	on, off

• art_slideshow (interval minutes or off, shuffle true/false, category) — speaks both the 2022+ (slideshow_status) and 2021 (auto_rotation_status) dialects and returns the state read back.

• art_mattes / art_matte (content_id, matte, portrait_matte) — list matte types and colours, apply one as <type>_<colour> (e.g. modern_black) or none.

• art_filters / art_filter (content_id, filter) — photo filters (None, Aqua, ArtDeco, Ink, Wash, Pastel, Feuve on the test unit).

• art_request (request, fields as JSON) — any raw art-channel request, for anything above that this page does not cover; the reply is returned as-is.

Uploading images is deliberately not offered: the 2021 firmware reads the whole image over the TV's data socket and then never registers it (the same "upload service unavailable" that 2021 owners see in the SmartThings app), and the flow could not be verified end to end.

rpc_request (method, params as JSON) is the equivalent escape hatch for the port-1516 API; the token is added for you.

Status feedback

While the device is enabled GEM polls the TV every status_interval (5 s): a REST probe for power and device info, then volume and mute over UPnP while the TV is on. Every rpc_status_interval (15 s) it also reads input, picture mode, sound mode, speaker selection and art state over the control API — or, on a Frame without the control API, the art state alone over the art channel. After every state-changing command a quick extra read runs about 1.5 s later so a touchpanel updates before the next scheduled poll. Attributes are written only when the value changes.

Attributes

Device — required

Attribute	Type	Description
ip	string	The TV's LAN IP address.

Device — optional

Attribute	Type	Default	Description
mac_address	string	(learned)	MAC for Wake-on-LAN. Filled in automatically from the ARP table or the TV's Wi-Fi MAC when blank.
port	int	8002	Websocket (remote / art channel) port.
rpc_port	int	1516	HTTPS JSON-RPC control API port.
token	string (secure, read-only)		Websocket token, stored when the first allow-prompt is accepted. Clear it to force re-pairing.
rpc_token	string (secure, read-only)		Control API token, stored by the pair command.
input_method	string	auto	auto, rpc, key or source_bar — see the Inputs section.
source_bar_order	string	tv,hdmi1,hdmi2,hdmi3,hdmi4	Left-to-right order of the on-screen source bar (source_bar method).
source_bar_delay	int	1500	ms to wait for the source bar to open before stepping through it (source_bar method).
power_off_mode	string	standby	standby = real off; art = a Frame switches to art mode on power_off.
status_interval	int	5000	Poll interval in ms for power, volume and mute.
rpc_status_interval	int	15000	Poll interval in ms for input, picture / sound mode and art state.
key_delay	int	200	Minimum gap between remote keys, in ms.
wake_timeout	int	30000	How long power_on keeps sending Wake-on-LAN, in ms.
wake_interval	int	4000	Gap between wake packets, in ms.

Device — status (set automatically, read-only)

Attribute	Type	Description
power_state	string	on / off. Stays two-valued for compatibility with existing zones, macros and UI; off covers both standby and unreachable.
mode	string	tv, art, standby or off — the Frame-aware state.
volume	int	Current volume 0–100.
mute_state	string	on / off.
input	string	tv, hdmi, hdmi_1 … hdmi_4 (control API readback, or the last input GEM set).
art_mode	string	on / off (Frame).
artwork	string	content_id of the artwork on screen (Frame, after art_current / art_select).
picture_mode, sound_mode, speaker_select	string	From the control API.
model, device_name	string	From the TV's device info (e.g. QN50LS03AAFXZA).
frame_tv	bool	Whether the TV reports Frame (art) support.
detected_mac	string	The MAC the driver learned from ARP or the TV's report.
last_error	string	The most recent command or transport failure, for the Attributes tab.

note

Only the attributes declared in the device form autocomplete in the Attributes editor. Status attributes must be typed exactly as shown when you reference them in triggers or macros. See Attributes.

Commands

Driver-declared commands appear on the device's Commands tab and can be used in macros, triggers, and on UI buttons.

Setup and status

Command	Args	Action
pair	transport (all, remote, rpc)	Pair with the TV; accept the on-screen prompts.
diagnostics		Probe every transport and report latency, tokens, MAC detection and state.
get_status		Refresh and return power, mode, volume, mute, input and art state.
get_device_info		Device info over REST: model, name, MAC, power state, Frame support.
get_power		Probe the TV; returns power_state, mode, is_on.
is_available		Cached on/off state without touching the TV.

Power

Command	Action
power_on	Wake-on-LAN loop until the TV answers; leaves art mode.
power_off	Real standby (control API, else a 3 s KEY_POWER hold on a Frame / KEY_POWEROFF); power_off_mode=art switches a Frame to art instead.
power_toggle	power_off when on, power_on when off.

Volume and mute

Command	Args	Action
volume, set_volume	level	Absolute volume 0–100 (UPnP, control API fallback).
get_volume		Read the current volume.
volume_up, volume_down		One step.
mute_on, mute_off		Discrete mute (UPnP, control API fallback).
mute_toggle		Toggle from the live mute state.
get_mute		Read the current mute state.

Inputs

Command	Args	Action
input	input (tv, hdmi, hdmi_1, hdmi_2, hdmi_3, hdmi_4)	Switch input; hdmi picks the active HDMI port.
get_input		Read the current input (control API).
hdmi_1 … hdmi_4		Switch to that HDMI port.
tuner		Switch to the TV tuner.
source		Open the on-screen source bar.

Channels

Command	Args	Action
channel	channel, or major / minor	Direct entry, e.g. 7 or 7-1.
channel_up, channel_down, previous_channel		Remote keys.

Navigation and keys

Command	Args	Action
up down left right enter menu guide exit home info tools back		One remote key each.
play pause stop rewind fast_forward		Transport keys.
0 … 9		Digit keys.
send_key	key	Any remote key by name (KEY_ prefix optional).
hold_key	key, duration	Press and hold for duration ms (default 2000).
key_sequence	sequence	Paced keys, e.g. source wait:1.5 left*8 right*2 enter.
send_text	text	Type into the focused field.

Apps

Command	Args	Action
get_apps		Installed apps (websocket query, REST probe of well-known ids as fallback).
launch_app	app_id (picker of installed apps), app_type (DEEP_LINK, NATIVE_LAUNCH), meta_tag	Launch by name or id.
close_app	app_id (picker of installed apps)	Close by name or id.
app_status	app_id (picker of installed apps)	Running / visible state.

Art Mode (The Frame)

Command	Args	Action
art_mode_on, art_mode_off		Show art / show TV (wakes the TV first if needed).
art_current		The artwork on screen.
art_list	category (mine, favorites, store)	List stored artwork.
art_select	content_id, show	Show a stored artwork, verified by readback.
art_favorite	content_id, state (on, off)	Mark or unmark a favourite.
art_delete	content_id (comma-separated)	Delete uploaded artwork.
art_setting	setting, value	Read or set brightness, colour temperature, motion sensitivity, motion timer, brightness sensor (ranges above).
art_slideshow	interval, shuffle (true, false), category	Slideshow interval in minutes or off.
art_mattes, art_matte	content_id, matte, portrait_matte	List / apply mattes.
art_filters, art_filter	content_id, filter	List / apply photo filters.
art_request	request, fields (JSON)	Raw art-channel request.

Escape hatch

Command	Args	Action
rpc_request	method, params (JSON)	Raw port-1516 JSON-RPC call; the token is added for you.

Diagnostics

diagnostics is the commissioning tool: it probes every transport live and returns one object you can read from the Commands tab or the Script Console.

Section	What to look at
rest	ok, ms, error; plus power_state, model, frame_tv and wifi_mac as the TV reports them. ok: false means the TV is off, asleep, or not reachable at that IP.
upnp	ok, ms, error, and the volume read. Needs no pairing — a failure here with REST healthy usually means the TV has IP control disabled or a firewall between GEM and port 9197.
rpc	paired (is rpc_token stored), ok / ms / error for a live getTVStates, rejected (the TV refused the stored token — run pair again), and the states read back.
remote	paired (is token stored), ok / ms / error for opening the websocket, connected (the persistent socket is up). Only attempted while the TV is on.
wake	configured_mac versus detected_mac, and targets — every address a wake packet is sent to. If detected_mac is empty the ARP table has no entry for the TV's IP (wrong IP, or a routed network where GEM cannot see the TV's MAC).
state	The driver's current view: power, mode, volume, mute, input, art, model, last_error.
transports	Per-transport health counters: last success, last failure, consecutive failures, last error text.
last_seen	When the TV last answered REST.
prompt_backoff_until	Non-empty when a recent websocket connect failed (declined prompt, revoked token, no answer) and the background warm-up is holding off. Explicit commands and pair still try.

Known limitations

• No channel readback. None of the TV's IP services report the tuned channel; channel sends digits and the TV does the rest.
• No image upload. See the Art Mode section for why.
• Art state on an unpaired Frame is only as fresh as rpc_status_interval. Without the control API the art status costs a websocket session (about 1.3 s) each time, so it is read every 15 s rather than every poll; mode may lag a physical-remote art toggle by that long.
• Wake-on-LAN is best-effort on 2020/2021 Frames, which leave the network in standby.
• The websocket carries a limited key set on the control API fallback — cursor, enter, menu, exit, return, transport, digits, volume and channel keys. Anything else needs the websocket.
• Single device, no zones. A Samsung TV is one GEM device; group rooms at the AV-zone / macro layer.

Troubleshooting

Symptom	Check
hdmi_1–hdmi_4 do nothing	The control API is not paired, so the driver fell back to KEY_HDMIn, which 2016+ firmware ignores. Run pair and accept the second prompt; diagnostics → rpc.paired should read true.
tv refused input HDMI2: no powered device on that port	Nothing powered is attached to that HDMI port — the TV only switches to live inputs. Bring the source up first.
power_on does nothing	Enable Power On with Mobile on the TV. In diagnostics compare wake.configured_mac with wake.detected_mac and check targets includes the TV's subnet broadcast — GEM must share a broadcast domain with the TV. On a 2020/2021 Frame allow the full wake_timeout.
The TV keeps showing an "Allow GEM?" prompt	A stored token was revoked (factory reset, or the TV's Device Connection Manager was cleared). Accept the prompt once, or run pair. The driver clears the dead token and backs off (30 s, doubling to 10 min) on background reconnects so the prompt is not re-shown every poll.
diagnostics shows rpc.rejected: true	The TV no longer recognises rpc_token. Run pair with transport=rpc.
Volume commands fail	UPnP on port 9197 needs no pairing; if diagnostics → upnp.ok is false while REST is healthy, the TV has IP control disabled or something is filtering port 9197. With the control API paired the driver already fell back to port 1516.
Fast key presses register once	The TV coalesces presses that arrive without a gap. The driver spaces keys by key_delay (200 ms); raise it if a particular set still drops presses. Use key_sequence rather than firing several send_key commands from parallel macro steps.
An art_setting set reports "still x after set"	Older firmware silently ignores set_* requests while the TV is transitioning; the driver read the value back and it had not changed. Retry after a second, and check the value is inside the allowed range.
power_state reads off shortly after power_off and the TV cannot be pinged	Normal. The TV reports standby for a few seconds, then leaves the network entirely until it is woken.
art_* commands return not a frame tv	The TV's device info reports no Frame support. On a Frame this means the REST probe has not run yet — run get_device_info and try again.
Power / volume readout is stale	Confirm the device is enabled; diagnostics → last_seen shows when the TV last answered. Polling runs every status_interval.

See also

• AV Zones — make the TV a zone's Volume Device so volume and mute route to it.
• Samsung MDC — commercial / signage panels over MDC.
• Samsung TV (Serial-over-IP) — RS-232 (Ex-Link) through a serial-to-IP adapter.
• Devices — adding and configuring devices.
• Attributes — device attributes and the Attributes editor.
• Commands — running and scripting device commands.
• Script Console — where pair and diagnostics are easiest to run.
• Macros — room-on / room-off sequences that wake the TV and switch inputs.
• Triggers — fire automations on the TV's power, mode, volume or input.