With this code you can send remote control buttons to your Samsung TV. With a button, rule and shell execution you can trigger it to change input etc.

#!  /usr/bin/python
#   Title: samsungremote.py
#   Author: Asif Iqbal
#   Date: 05APR2012
#   Info: To send remote control commands to the Samsung tv over LAN
#   TODO:

import socket
import base64
import time, datetime
import sys

cmdargs = str(sys.argv)

#IP Address of TV
tvip = "192.168.178.7"
#IP Address of TV
myip = "192.168.178.14"
#Used for the access control/validation, but not after that AFAIK
mymac = "b8:27:eb:b1:6c:7c"
#What the iPhone app reports
appstring = "iphone..iapp.samsung"
#Might need changing to match your TV type
tvappstring = "iphone.UE40D6500.iapp.samsung"
#What gets reported when it asks for permission
remotename = "Python Samsung Remote"

# Function to send keys
def sendKey(skey, dataSock, appstring):
messagepart3 = chr(0x00) + chr(0x00) + chr(0x00) + chr(len(
base64.b64encode(skey))) + chr(0x00) + base64.b64encode(skey);
part3 = chr(0x00) + chr(len(appstring)) + chr(0x00) \
+ appstring + chr(len(messagepart3)) + chr(0x00) + messagepart3
dataSock.send(part3);

# Open Socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((tvip, 55000))

# Key Reference
# Normal remote keys
#KEY_0
#KEY_1
#KEY_2
#KEY_3
#KEY_4
#KEY_5
#KEY_6
#KEY_7
#KEY_8
#KEY_9
#KEY_UP
#KEY_DOWN
#KEY_LEFT
#KEY_RIGHT
#KEY_MENU
#KEY_PRECH
#KEY_GUIDE
#KEY_INFO
#KEY_RETURN
#KEY_CH_LIST
#KEY_EXIT
#KEY_ENTER
#KEY_SOURCE
#KEY_AD #KEY_PLAY
#KEY_PAUSE
#KEY_MUTE
#KEY_PICTURE_SIZE
#KEY_VOLUP
#KEY_VOLDOWN
#KEY_TOOLS
#KEY_POWEROFF
#KEY_CHUP
#KEY_CHDOWN
#KEY_CONTENTS
#KEY_W_LINK #Media P
#KEY_RSS #Internet
#KEY_MTS #Dual
#KEY_CAPTION #Subt
#KEY_REWIND
#KEY_FF
#KEY_REC
#KEY_STOP
# Bonus buttons not on the normal remote:
#KEY_TV
#Don't work/wrong codes:
#KEY_CONTENT
#KEY_INTERNET
#KEY_PC
#KEY_HDMI1
#KEY_OFF
#KEY_POWER
#KEY_STANDBY
#KEY_DUAL
#KEY_SUBT
#KEY_CHANUP
#KEY_CHAN_UP
#KEY_PROGUP
#KEY_PROG_UP


# First configure the connection
ipencoded = base64.b64encode(myip)
macencoded = base64.b64encode(mymac)
messagepart1 = chr(0x64) + chr(0x00) + chr(len(ipencoded)) \
+ chr(0x00) + ipencoded + chr(len(macencoded)) + chr(0x00) \
+ macencoded + chr(len(base64.b64encode(remotename))) + chr(0x00) \
+ base64.b64encode(remotename)

part1 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart1)) + chr(0x00) + messagepart1
sock.send(part1)

messagepart2 = chr(0xc8) + chr(0x00)
part2 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart2)) + chr(0x00) + messagepart2
sock.send(part2)


# Now send the keys as you like, e.g.,
#sendKey("KEY_CHDOWN",sock,tvappstring)
sendKey(str(sys.argv[1]),sock,tvappstring)
print str(sys.argv[1])
# Close the socket when done
sock.close()

Just to share http://pastebin.com/5WrkNKwP

Can anyone help me out how to get this working in pimatic?

@vanturenhout

Copy the python script to a new file (you need a new script for each button I think).

sudo nano tvON.py

Paste the whole script there.
At the bottom of the script, paste the command you want to use (eg. Power)
under “sendKey(str(sys.argv[1]),sock,tvappstring)
print str(sys.argv[1])”

sendkey(“KEY_POWER”,sock,tvappstring) (it seeems like the KEY_POWER is an invalid command, as it reads on the script, but this is an example)

Save file and exit nano.

After that, you have to configure a buttonsdevice to press

{
“id”: “tvButtons”,
“name”: "Samsung Controls”,
“class”: “ButtonsDevice”,
“buttons”: [
{
“id”: “tvON”,
“name”: “Turn On TV”
},
{
“id”: “tvOFF”,
“name”: “Turn Off TV”
}
]
}

After that you need to make a rule for the button, to execute the python script you saved.
Rules > Add new rule:

When Turn On TV Button is pressed
Then execute “path/to/tvON.py”

Nice…thanks for that, i’m going to try this asap!

And if you want to chain the commands (like open tv, then switch to HDMI, etc), put time.sleep(how many seconds) between the commands

Now send the keys as you like, e.g.,

sendKey(“KEY_VOLUP”,sock,tvappstring)
time.sleep(1)
sendKey(“KEY_TOOLS”,sock,tvappstring)
time.sleep(1)
sendKey(“KEY_RIGHT”,sock,tvappstring)
time.sleep(1)
sendKey(“KEY_DOWN”,sock,tvappstring)
time.sleep(1)
sendKey(“KEY_RIGHT”,sock,tvappstring)

@Mdesign

Hi, can you tell me if is possible to get current channel number from TV.
tahnks

Try to press the info key with te script and looks what happend

You don’t need a script per command and you don’t need to change that script at all. You can simply use that one single script and use parameters.
On linux level do a chmod a+x TVon.py (or whatever you called the script)

And from pimatic make a rule with an execute like:
execute "/<path_to_python_script>/TVon.py KEY_CHUP"
or
execute "/<path_to_python_script>/TVon.py KEY_VOLUP"
and for the channel info perhaps
execute "/<path_to_python_script>/TVon.py KEY_INFO"

And when “chaining” commands you could try to use something like
execute "/<path_to_python_script>/TVon.py KEY_SOURCE; /<path_to_python_script>/TVon.py KEY_UP; /<path_to_python_script>/TVon.py KEY_ENTER;"
to change source, go one line up and enter (confirm) your choice
You do need a button per command in your pimatic with a rule, but you only need one script.

If the chaining doesn’t work in one execute command, you could create another python or shell script (more easy) where you simply call the commands one after another with a sleep statement like:

#! /usr/bin/bash

/<path_to_python_script>/TVon.py KEY_SOURCE
sleep 1
/<path_to_python_script>/TVon.py KEY_UP
sleep 1
/<path_to_python_script>/TVon.py KEY_ENTER

and call that shell script from a rule

Hello,
can someone publish a Plugin?

https://www.npmjs.com/package/samsung-remote

@temp Thanks for the hint, i will look into this

@temp This library does not work with the newer Samsung TVs (2016 models)

EDIT: I have done a first POC implementation using the library: pimatic-samsung-tv@0.9.0
Currently the implementation only provides for a presence sensor. This will only work with older Samsung TVs (before 2016). The library “samsung-remote” does not appear to be well mantained as there are some pull request pending since 10 months. Some work will also be required to integrate the new control API.

Hi @mwittig Yesterday I implemented an action provider as a plugin wrapper around the library, It works, remaining bit is to correctly promisify the callback function so a promise gets returned to the framework. Shall I hand over the code so you can integrate into yours?

@Dan This’ll be great. I am happy to integrate this.

I am also working on an extension of the libarry to make it usable with new Samsung TV models

@mwittig great ! I can do a pull request on github (need to create a repo first, or simply email you the file as it is a limited code base anyway). Let me know what you prefer

Update: I have pushed to github, pull request is ready

Dan

@Dan Excellent. I’ll look into this asap

@mwittig See https://github.com/aap82/pimatic-samsung-tv-2016.

This plugin works with my KS8000 to turn the television on and off. I’m not sure if it’s a good idea to combine this with your plugin, as they may not play nice with each other. Perhaps a device config option to denote model-year to determine protocol method to use.

#IP Address of TV
tvip = "192.168.178.7"
#IP Address of TV
myip = "192.168.178.14"
#Used for the access control/validation, but not after that AFAIK
mymac = "b8:27:eb:b1:6c:7c"
#What the iPhone app reports
appstring = "iphone..iapp.samsung"
#Might need changing to match your TV type
tvappstring = "iphone.UE40D6500.iapp.samsung"
#What gets reported when it asks for permission
remotename = "Python Samsung Remote"

I have some questions concerning the config.

What’s the difference between “tvip” and “myip”, both are commented as “#IP Address of TV”?
Is “mymac” the mac address of the tv and is it optional?
Are “appstring” and “tvappstring” optional or can I just use the same parameters customized to my tv and what are they used for?

Thanks in advance and keep on writing such good scripts, they make pimatic even better than it is anyway.
Martin

Hi,
“myip” ist the pimatic “ip”, “mymac” is the pimatic “mac” and i have "tvappstring = “iphone.UE55D7000.iapp.samsung” write in the file.

my example:

#IP Address of TV
tvip = "192.168.2.50"
#IP Address of Raspi
myip = "192.168.2.8"
#Used for the access control/validation, but not after that AFAIK
mymac = "b8:27:eb:38:b2:5a"
#What the iPhone app reports
appstring = "iphone..iapp.samsung"
#Might need changing to match your TV type
tvappstring = "iphone.UE55D7000.iapp.samsung"
#What gets reported when it asks for permission
remotename = "Python Samsung Remote"

@jens said in Control your Samsung TV:

Hi,
“myip” ist the pimatic “ip”, “mymac” is the pimatic “mac” and i have "tvappstring = “iphone.UE55D7000.iapp.samsung” write in the file.

Thank you, now I can test it.

Best wishes, Martin

Edit: Doesn’t work for my H-Series TV, seems that the port has shifted to 8001 and the protocoll has changed.

Did you already try the Samsung TV plugins?
https://pimatic.org/plugins/pimatic-samsung-tv/
https://pimatic.org/plugins/pimatic-samsung-tv-2016/