FAQ's

Use your custom webbased GUI to control devices in your local network.

HTMLRemote is an all-in-one solution for local device control. Acting as a local HTTP server, HTMLRemote allows you to host your custom web-based GUI on your local network effortlessly. Simply enter the URL of your custom GUI, and HTMLRemote takes care of the local hosting. With the ability to send TCP/IP sockets over the local network, you can create buttons and events (using JavaScript, etc...) to seamlessly control devices in your network.

So the HTMLRemote App is used for two purposes :

• It loads and hosts your web page locally, providing you with control over your devices..
• It functions as a local HTTP server that processes HTTP requests, establishes a socket connection to the specified IP address and port, and transmits commands through this socket.

The ability to send commands from the internet (using a webbrowser) to devices on your local network is generally restricted due to security considerations. Allowing external commands to access and control devices within a local network can pose significant security risks, as it creates a potential entry point for unauthorized access and control. To mitigate these risks, network security measures, such as firewalls and network address translation (NAT), are typically implemented to limit external access to devices within the local network. Allowing direct commands from the internet could bypass these security measures, making the network more vulnerable to various cyber threats.

HTMLRemote is designed to operate within the local network to maintain a secure and controlled environment. The "executeCommand()" function is a mechanism for local communication, ensuring that commands are transmitted securely within the confines of the user's own network.

• It starts your web page that allows you to control your devices
• It acts as a local http server that takes the http requests, opens a socket to the provided ip address and port, and sends the command over this socket.

The app is only necessary for devices or extenders that are accessed through sockets. For devices supporting the rest protocol, or another http-based protocol, the communication occurs directly between the web page (the javascript library) and the device. The app allows to set the following parameters :

• url : the url to load when the app is started. By default, this will be http://myuremote.com/userconfig (Free Universal AV GUI)
• port : the port at which the local http server is listening. By default, the port is 9090, but this can be adjusted if there is already another server running on this port. See the gatewayUrl variable in clientconfig.js
• optional: default extender ip : if no ip address is provided in the http request, this ip address is used as default
• optional: default extender port : if no port is provided in the http request, this port is used as default

• Create Your HTML GUI: Design a customized HTML interface that suits your control preferences and aesthetic preferences. Use our sample pages to learn how to easily integrate socket communication into your GUI using the javascript executecommand function.

  
• Upload your HTML: Upload your HTML GUI to a server of your choice (for free).
• Connect: Easily connect the URL of your GUI with HTMLRemote. Goto the settings of your iOS device, scroll to HTMLRemote and fill in the URL in the Url field. (AV lovers who want to use the free MyURemote GUI, use "http://wwwmyuremote.com/userconfig")
• Expand Your Control Center: As your device system grows, HTMLRemote allows you to expand your control center effortlessly, adapting your HTML GUI to accommodate new devices.

• ir (anything with an infrared remote control)
• serial
• socket communication - TCP/IP
• ethernet

The remote control solution consists of:

• a web page, showing buttons, tabs and other html controls
• a set of javascript components
• the HTMLRemote app, which is a local http server on your device (smartphone, tablet, PC)
• optionally a device such as a GlobalCaché device to communicate with devices using ir or serial signals

• Download from the Apple App Store: Get HTMLRemote for iPhone and iPad.
• Free (at this moment only compatible with firefox!): Windows version.

• Use Your device or PC: Feel free to use the TCP/IP Command Builder page to test communication with your device. Here's how:

  Run HTMLRemote on your source device.

  Enter a test command to verify communication. For example, you can input a basic command like "ping" to check responsiveness.

  Specify the IP address of your device that you want to test,

  enter the port number configured for communication with your device.

  Once your input is set, click the "Execute" button. This will send the specified command to the provided IP address over the designated port. Use this feature to validate that your device is responding appropriately and that communication is established.

  Note: Ensure that the device is correctly configured to receive commands on the specified port and is reachable through the provided IP address. This testing process allows you to confirm that HTMLRemote is effectively communicating with your device, giving you confidence in the setup. A feebback appears in green text.

• Use Python's TCP server: Testing a TCP socket involves creating a server and a client to establish a connection and exchange data. Below, I'll provide a simple example using Python. Python has a built-in socket library that makes it easy to create a TCP server. HTMLRemote is the client :-)

  			
  			import socket
  
  			# Define the server settings. The host IP address is the IP address of the computer running Python
  			host = '127.0.0.1'
  			port = 12345
  
  			# Create a socket object
  			server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  
  			# Bind the socket to a specific address and port
  			server_socket.bind((host, port))
  
  			# Listen for incoming connections (max 5 connections in the queue)
  			server_socket.listen(5)
  
  			print(f"Server listening on {host}:{port}")
  
  			# Accept a connection from a client
  			client_socket, addr = server_socket.accept()
  			print(f"Connection from {addr}")
  
  			# Receive data from the client
  			data = client_socket.recv(1024)
  			print(f"Received data: {data.decode()}")
  
  			# Send a response back to the client
  			response = "Hello, client! This is the server."
  			client_socket.send(response.encode())
  
  			# Close the connection
  			client_socket.close()
  			server_socket.close()
  			
  			

  Edit the port and the IP address in the text. The IP address must be the same IP address of the computer which will run the text (PY) file.

  Save the server code in one textfile, let's say server.py .

  Install Python server.

  Run the server script in a terminal or command prompt.

  Send a message (fi with the Get started button) with HTMLRemote to the IP address op the Python server.

  You should see the messages indicating that the server and client have successfully connected and exchanged data. This is a basic example, and you can modify it based on your specific testing needs.

• Use Wireshark "man in the middle": using Wireshark for network monitoring to analyze network communication between devices, including HTMLRemote, here are some general steps:

  • Install Wireshark: Ensure that Wireshark is installed on the machine where you want to capture network traffic.
  • Select the Appropriate Interface: Open Wireshark and choose the network interface through which the traffic passes. This could be an Ethernet interface, Wi-Fi interface, or another relevant option.
  • Apply Filters: Use display filters in Wireshark to focus on the specific traffic you're interested in. For example, you can filter by IP address, port number, or protocol (e.g., TCP).
  • Start Capture: Initiate the capture process to start collecting network traffic.
  • Generate Traffic: Use HTMLRemote to generate the desired TCP traffic or send commands. Monitor the captured packets in Wireshark to analyze the communication.
  • Stop Capture: Stop the capture process in Wireshark when you have collected the necessary data.
  • Analyze Packets: Analyze the captured packets in Wireshark to understand the details of the communication, such as the exchanged data, protocols used, and any potential issues:
  If you are sending commands, whether they be Infrared (IR) or serial commands, via HTMLRemote to a device like a GC100/6 through a TCP/IP socket, and the device responds, it's possible to identify these commands in the Wireshark capture. Here are steps to help you identify the commands:
  • Filter based on IP address and port number: Use a Wireshark filter to capture only the traffic between the sender (HTMLRemote) and the device (e.g., GC100/6). This can be done with a filter like ip.src == [your IP] && ip.dst == [device IP] && tcp.port == [your port]. This helps focus on the relevant traffic.
  • View the TCP stream: Choose one of the TCP packets related to the communication between HTMLRemote and the device. Right-click on the packet and select "Follow" and then "TCP Stream". This will show you the complete TCP stream.
  • Analyze the data in the TCP stream: Within the TCP stream, you might see the data sent between HTMLRemote and the device. The actual command may appear as text or hexadecimal data, depending on how it's implemented.
  Keep in mind that if the communication between HTMLRemote and the device is encrypted, it might be challenging to see the exact command in a readable form, as encrypted traffic is not easily interpretable without the correct keys. If you cannot determine the exact details of the command through Wireshark, consider checking the documentation of the HTMLRemote software or the device to see if there is specific information about the format of the commands sent via the TCP/IP socket. This approach can be applied to various types of commands, not just limited to IR.

There are several platforms where you can upload a small webpage for free. Here are a few options:

• GitHub Pages: GitHub allows you to host static websites directly from your GitHub repositories. If your webpage is just HTML, CSS, and JavaScript, you can create a repository and enable GitHub Pages.

  Tutorial: GitHub Pages

• Netlify: Netlify is a platform that offers free hosting for static websites. It's easy to use and integrates well with Git.

  Website: Netlify

• Vercel: Vercel is another platform that provides hosting for static websites. It supports various frameworks and languages.

  Website: Vercel

• GitLab Pages: Similar to GitHub Pages, GitLab Pages allows you to host static websites directly from your GitLab repositories.

  Tutorial: GitLab Pages

• Firebase Hosting: Firebase, a platform by Google, provides hosting services for web applications. It's not just for static sites, but it's still free for small projects.

  Website: Firebase Hosting

Remember that for dynamic websites with server-side code or databases, you might need to explore other options beyond these free static hosting services. Additionally, the terms and conditions of these services may change, so be sure to check their current offerings and limitations.