Added numpad support

remdeskd/.vscode/settings.json

@@ -4,7 +4,7 @@
   "C_Cpp_Runner.debuggerPath": "gdb",
   "C_Cpp_Runner.cStandard": "",
   "C_Cpp_Runner.cppStandard": "",
-  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Auxiliary/Build/vcvarsall.bat",
   "C_Cpp_Runner.useMsvc": false,
   "C_Cpp_Runner.warnings": [
     "-Wall",

remdeskd/go.mod

@@ -3,13 +3,9 @@ module imuslab.com/remdeskvm/remdeskd
 go 1.23.4
 
 require (
+	github.com/gorilla/websocket v1.5.3
 	github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07
 	github.com/vladimirvivien/go4vl v0.0.5
-	golang.org/x/crypto v0.36.0
 )
 
-require (
-	golang.org/x/net v0.21.0 // indirect
-	golang.org/x/sys v0.31.0 // indirect
-	golang.org/x/text v0.23.0 // indirect
-)
+require golang.org/x/sys v0.31.0 // indirect

remdeskd/go.sum

@@ -1,13 +1,9 @@
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07 h1:UyzmZLoiDWMRywV4DUYb9Fbt8uiOSooupjTq10vpvnU=
 github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
 github.com/vladimirvivien/go4vl v0.0.5 h1:jHuo/CZOAzYGzrSMOc7anOMNDr03uWH5c1B5kQ+Chnc=
 github.com/vladimirvivien/go4vl v0.0.5/go.mod h1:FP+/fG/X1DUdbZl9uN+l33vId1QneVn+W80JMc17OL8=
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
 golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=

remdeskd/main.go

@@ -5,15 +5,26 @@ import (
 	"io/fs"
 	"log"
 	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"imuslab.com/remdeskvm/remdeskd/mod/remdeshid"
 )
 
 const development = true
 
+var (
+	remdesHIDController *remdeshid.Controller
+)
+
+/* Web Server Static Files */
 //go:embed www
 var embeddedFiles embed.FS
 var webfs http.FileSystem
 
 func init() {
+	// Initiate the web server static files
 	if development {
 		webfs = http.Dir("./www")
 	} else {
@@ -24,13 +35,36 @@ func init() {
 		}
 		webfs = http.FS(subFS)
 	}
+
+	// Initiate the HID controller
+	remdesHIDController = remdeshid.NewHIDController(&remdeshid.Config{
+		PortName: "COM4",
+		BaudRate: 115200,
+	})
+
 }
 
 func main() {
-	http.Handle("/", http.FileServer(webfs))
+	//Start the HID controller
+	err := remdesHIDController.Connect()
+	if err != nil {
+		log.Fatal(err)
+	}
 
-	addr := ":8080"
+	// Handle program exit to close the HID controller
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		log.Println("Shutting down...")
+		remdesHIDController.Close()
+		os.Exit(0)
+	}()
 
+	// Start the web server
+	http.HandleFunc("/hid", remdesHIDController.HIDWebSocketHandler)
+	http.Handle("/", http.FileServer(webfs))
+	addr := ":8080"
 	log.Printf("Serving on http://localhost%s\n", addr)
 	log.Fatal(http.ListenAndServe(addr, nil))
 

remdeskd/mod/remdeshid/handler.go

@@ -0,0 +1,76 @@
+package remdeshid
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/websocket"
+)
+
+type HIDCommand struct {
+	EventType    string `json:"t"`
+	EventSubType string `json:"s"`
+	Data         string `json:"d"`
+}
+
+// HIDWebSocketHandler is a handler for the HID WebSocket connection
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+func (c *Controller) HIDWebSocketHandler(w http.ResponseWriter, r *http.Request) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Println("Failed to upgrade to websocket:", err)
+		return
+	}
+	defer conn.Close()
+
+	for {
+		_, message, err := conn.ReadMessage()
+		if err != nil {
+			log.Println("Error reading message:", err)
+			break
+		}
+		log.Printf("Received: %s", message)
+
+		//Try parsing the message as a HIDCommand
+		var hidCmd HIDCommand
+		if err := json.Unmarshal(message, &hidCmd); err != nil {
+			log.Println("Error parsing message:", err)
+			continue
+		}
+
+		//Send the command to the HID controller
+		bytes, err := ConvHIDCommandToBytes(hidCmd)
+		if err != nil {
+			errmsg := map[string]string{"error": err.Error()}
+			if err := conn.WriteJSON(errmsg); err != nil {
+				log.Println("Error writing message:", err)
+			}
+			continue
+		}
+
+		fmt.Println("Sending bytes:", bytes)
+
+		//Write the bytes to the serial port
+		if err := c.Send(bytes); err != nil {
+			errmsg := map[string]string{"error": err.Error()}
+			if err := conn.WriteJSON(errmsg); err != nil {
+				log.Println("Error writing message:", err)
+			}
+			continue
+		}
+
+		if err := conn.WriteMessage(websocket.TextMessage, []byte("ok")); err != nil {
+			log.Println("Error writing message:", err)
+			continue
+		}
+	}
+}

remdeskd/mod/remdeshid/hidcomm.go

@@ -0,0 +1,79 @@
+package remdeshid
+
+import "fmt"
+
+//Convert a HIDCommand to bytes that can be sent over the USBKVM device
+func ConvHIDCommandToBytes(cmd HIDCommand) ([]byte, error) {
+	// Convert the HID command to bytes
+	var data []byte
+	if cmd.EventType == FRONTEND_OPR_TYPE_KEYBOARD_WRITE {
+		data = []byte{OPR_TYPE_KEYBOARD_WRITE}
+
+		/* Keyboard Subtypes */
+		if len(cmd.Data) == 1 && cmd.Data[0] >= 32 && cmd.Data[0] <= 127 {
+			//Valid ASCII character
+			if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_DOWN {
+				data = append(data, SUBTYPE_KEYBOARD_ASCII_PRESS)
+			} else if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_UP {
+				data = append(data, SUBTYPE_KEYBOARD_ASCII_RELEASE)
+			} else {
+				//Key Click
+				data = append(data, SUBTYPE_KEYBOARD_ASCII_WRITE)
+			}
+			data = append(data, cmd.Data[0])
+			return data, nil
+		} else if isFuncKey(cmd.Data) {
+			//Function Key
+			if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_DOWN {
+				data = append(data, SUBTYPE_KEYBOARD_FUNCTKEY_PRESS)
+			} else {
+				data = append(data, SUBTYPE_KEYBOARD_FUNCTKEY_RELEASE)
+			}
+			data = append(data, funcKeyToByte(cmd.Data))
+			if data[0] == 0xFF {
+				return nil, fmt.Errorf("invalid function key: %v", cmd.Data)
+			}
+			return data, nil
+		} else if isOtherKeys(cmd.Data) {
+			//Other Keys
+			if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_DOWN {
+				data = append(data, SUBTYPE_KEYBOARD_OTHERKEY_PRESS)
+			} else if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_UP {
+				data = append(data, SUBTYPE_KEYBOARD_OTHERKEY_RELEASE)
+			} else {
+				return nil, fmt.Errorf("invalid HID command subtype: %v", cmd.Data)
+			}
+			data = append(data, nonAsciiKeysToBytes(cmd.Data)...)
+			return data, nil
+		} else if isNumpadKey(cmd.Data) {
+			//Numpad Keys
+			if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_DOWN {
+				data = append(data, SUBTYPE_KEYBOARD_NUMPAD_PRESS)
+			} else if cmd.EventSubType == FRONTEND_SUBTYPE_KEYBOARD_KEY_UP {
+				data = append(data, SUBTYPE_KEYBOARD_NUMPAD_RELEASE)
+			} else {
+				return nil, fmt.Errorf("invalid HID command subtype: %v", cmd.Data)
+			}
+			data = append(data, numpadKeyToByte(string(cmd.Data)))
+			return data, nil
+		} else if cmd.Data == "NumLock" {
+			//Special Key: NumLock
+			//TODO: Implement NumLock
+			return nil, fmt.Errorf("numLock not implemented")
+		} else if cmd.Data == "Ctrl+Alt+Del" {
+			//Special Key: Ctrl+Alt+Del
+			data = append(data, SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL)
+			data = append(data, 0x00)
+			return data, nil
+		} else {
+			return nil, fmt.Errorf("invalid HID command subtype: %v", cmd.Data)
+		}
+
+	} else if cmd.EventType == FRONTEND_OPR_TYPE_MOUSE_WRITE {
+		data = []byte{OPR_TYPE_MOUSE_WRITE}
+	} else {
+		return nil, fmt.Errorf("invalid HID command type: %s", cmd.EventType)
+	}
+
+	return data, nil
+}

remdeskd/mod/remdeshid/hidconv.go

@@ -0,0 +1,235 @@
+package remdeshid
+
+/*
+	hidconv.go
+
+	This file contains functions to convert HID commands to bytes
+	that can be sent over the USBKVM device
+*/
+
+// Operation Types
+const (
+	// Frontend Opr Types
+	FRONTEND_OPR_TYPE_KEYBOARD_WRITE = "kw"
+	FRONTEND_OPR_TYPE_MOUSE_WRITE    = "mw"
+	FRONTEND_OPR_TYPE_MOUSE_MOVE     = "mm"
+	FRONTEND_OPR_TYPE_MOUSE_SCROLL   = "ms"
+
+	// USBKVM Operation Types
+	OPR_TYPE_RESERVED       = 0x00
+	OPR_TYPE_KEYBOARD_WRITE = 0x01
+	OPR_TYPE_MOUSE_WRITE    = 0x02
+	OPR_TYPE_MOUSE_MOVE     = 0x03
+	OPR_TYPE_MOUSE_SCROLL   = 0x04
+	OPR_TYPE_DATA_RESET     = 0xFF
+)
+
+// Operation Sub-types
+const (
+	SUBTYPE_RESERVED = 0x00
+)
+
+// Keyboard Subtypes
+const (
+	// Frontend Keyboard Opr Types
+	FRONTEND_SUBTYPE_KEYBOARD_KEY_DOWN  = "kd"
+	FRONTEND_SUBTYPE_KEYBOARD_KEY_UP    = "ku"
+	FRONTEND_SUBTYPE_KEYBOARD_KEY_CLICK = "kc"
+
+	// USBKVM Keyboard Subtypes
+	SUBTYPE_KEYBOARD_ASCII_WRITE        = 0x01
+	SUBTYPE_KEYBOARD_ASCII_PRESS        = 0x02
+	SUBTYPE_KEYBOARD_ASCII_RELEASE      = 0x03
+	SUBTYPE_KEYBOARD_MODIFIER_SET       = 0x04
+	SUBTYPE_KEYBOARD_MODIFIER_CLEAR     = 0x05
+	SUBTYPE_KEYBOARD_FUNCTKEY_PRESS     = 0x06
+	SUBTYPE_KEYBOARD_FUNCTKEY_RELEASE   = 0x07
+	SUBTYPE_KEYBOARD_OTHERKEY_PRESS     = 0x08
+	SUBTYPE_KEYBOARD_OTHERKEY_RELEASE   = 0x09
+	SUBTYPE_KEYBOARD_NUMPAD_PRESS       = 0x0A
+	SUBTYPE_KEYBOARD_NUMPAD_RELEASE     = 0x0B
+	SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL = 0xFD
+	SUBTYPE_KEYBOARD_SPECIAL_RESET      = 0xFE
+	SUBTYPE_KEYBOARD_SPECIAL_RESERVED   = 0xFF
+
+	// Numpad Buttons IDs
+	PAYLOAD_KEYBOARD_NUMPAD_0       = 0x00
+	PAYLOAD_KEYBOARD_NUMPAD_1       = 0x01
+	PAYLOAD_KEYBOARD_NUMPAD_2       = 0x02
+	PAYLOAD_KEYBOARD_NUMPAD_3       = 0x03
+	PAYLOAD_KEYBOARD_NUMPAD_4       = 0x04
+	PAYLOAD_KEYBOARD_NUMPAD_5       = 0x05
+	PAYLOAD_KEYBOARD_NUMPAD_6       = 0x06
+	PAYLOAD_KEYBOARD_NUMPAD_7       = 0x07
+	PAYLOAD_KEYBOARD_NUMPAD_8       = 0x08
+	PAYLOAD_KEYBOARD_NUMPAD_9       = 0x09
+	PAYLOAD_KEYBOARD_NUMPAD_DOT     = 0x0A
+	PAYLOAD_KEYBOARD_NUMPAD_TIMES   = 0x0B
+	PAYLOAD_KEYBOARD_NUMPAD_DIV     = 0x0C
+	PAYLOAD_KEYBOARD_NUMPAD_PLUS    = 0x0D
+	PAYLOAD_KEYBOARD_NUMPAD_MINUS   = 0x0E
+	PAYLOAD_KEYBOARD_NUMPAD_ENTER   = 0x0F
+	PAYLOAD_KEYBOARD_NUMPAD_NUMLOCK = 0x10
+)
+
+// Response Codes
+const (
+	RESP_OK                = 0x00
+	RESP_UNKNOWN_OPR       = 0x01
+	RESP_INVALID_OPR_TYPE  = 0x02
+	RESP_INVALID_KEY_VALUE = 0x03
+	RESP_NOT_IMPLEMENTED   = 0x04
+)
+
+//Is a key a function key
+func isFuncKey(key string) bool {
+	switch key {
+	case "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+		"F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24":
+		return true
+	default:
+		return false
+	}
+}
+
+//Convert function key string to byte
+func funcKeyToByte(key string) byte {
+	switch key {
+	case "F1":
+		return 0xC2
+	case "F2":
+		return 0xC3
+	case "F3":
+		return 0xC4
+	case "F4":
+		return 0xC5
+	case "F5":
+		return 0xC6
+	case "F6":
+		return 0xC7
+	case "F7":
+		return 0xC8
+	case "F8":
+		return 0xC9
+	case "F9":
+		return 0xCA
+	case "F10":
+		return 0xCB
+	case "F11":
+		return 0xCC
+	case "F12":
+		return 0xCD
+	case "F13":
+		return 0xF0
+	case "F14":
+		return 0xF1
+	case "F15":
+		return 0xF2
+	case "F16":
+		return 0xF3
+	case "F17":
+		return 0xF4
+	case "F18":
+		return 0xF5
+	case "F19":
+		return 0xF6
+	case "F20":
+		return 0xF7
+	case "F21":
+		return 0xF8
+	case "F22":
+		return 0xF9
+	case "F23":
+		return 0xFA
+	case "F24":
+		return 0xFB
+	default:
+		return 0xFF
+	}
+}
+
+/* Check for other keys */
+func isOtherKeys(key string) bool {
+	return nonAsciiKeysToBytes(key)[0] != 0xFF
+}
+
+func nonAsciiKeysToBytes(key string) []byte {
+	switch key {
+	case "ArrowUp":
+		return []byte{0xDA}
+	case "ArrowDown":
+		return []byte{0xD9}
+	case "ArrowLeft":
+		return []byte{0xD8}
+	case "ArrowRight":
+		return []byte{0xD7}
+	case "Backspace":
+		return []byte{0xB2}
+	case "Tab":
+		return []byte{0xB3}
+	case "Enter":
+		return []byte{0xB0}
+	case "Escape":
+		return []byte{0xB1}
+	case "Insert":
+		return []byte{0xD1}
+	case "Delete":
+		return []byte{0xD4}
+	case "PageUp":
+		return []byte{0xD3}
+	case "PageDown":
+		return []byte{0xD6}
+	case "Home":
+		return []byte{0xD2}
+	case "End":
+		return []byte{0xD5}
+	case "CapsLock":
+		return []byte{0xC1}
+	default:
+		return []byte{0xFF}
+	}
+}
+
+/* Numpad keys */
+func isNumpadKey(key string) bool {
+	return len(key) > 7 && key[:7] == "NUMPAD_"
+}
+
+func numpadKeyToByte(key string) byte {
+	switch key {
+	case "NUMPAD_0":
+		return PAYLOAD_KEYBOARD_NUMPAD_0
+	case "NUMPAD_1":
+		return PAYLOAD_KEYBOARD_NUMPAD_1
+	case "NUMPAD_2":
+		return PAYLOAD_KEYBOARD_NUMPAD_2
+	case "NUMPAD_3":
+		return PAYLOAD_KEYBOARD_NUMPAD_3
+	case "NUMPAD_4":
+		return PAYLOAD_KEYBOARD_NUMPAD_4
+	case "NUMPAD_5":
+		return PAYLOAD_KEYBOARD_NUMPAD_5
+	case "NUMPAD_6":
+		return PAYLOAD_KEYBOARD_NUMPAD_6
+	case "NUMPAD_7":
+		return PAYLOAD_KEYBOARD_NUMPAD_7
+	case "NUMPAD_8":
+		return PAYLOAD_KEYBOARD_NUMPAD_8
+	case "NUMPAD_9":
+		return PAYLOAD_KEYBOARD_NUMPAD_9
+	case "NUMPAD_.":
+		return PAYLOAD_KEYBOARD_NUMPAD_DOT
+	case "NUMPAD_*":
+		return PAYLOAD_KEYBOARD_NUMPAD_TIMES
+	case "NUMPAD_/":
+		return PAYLOAD_KEYBOARD_NUMPAD_DIV
+	case "NUMPAD_+":
+		return PAYLOAD_KEYBOARD_NUMPAD_PLUS
+	case "NUMPAD_-":
+		return PAYLOAD_KEYBOARD_NUMPAD_MINUS
+	case "NUMPAD_Enter":
+		return PAYLOAD_KEYBOARD_NUMPAD_ENTER
+	default:
+		return 0xFF
+	}
+}

remdeskd/mod/remdeshid/remdeshid.go

@@ -19,24 +19,23 @@ type Config struct {
 	BaudRate int
 }
 
-// HIDController is a struct that represents a HID controller
-type HIDController struct {
+// Controller is a struct that represents a HID controller
+type Controller struct {
 	Config        *Config
 	serialPort    *serial.Port
 	serialRunning bool
 	stopChan      chan bool
 }
 
-func NewHIDController(config *Config) *HIDController {
-	return &HIDController{
+func NewHIDController(config *Config) *Controller {
+	return &Controller{
 		Config:        config,
 		serialRunning: false,
 	}
 }
 
 // Connect opens the serial port and starts reading from it
-func (c *HIDController) Connect() error {
-
+func (c *Controller) Connect() error {
 	// Open the serial port
 	config := &serial.Config{
 		Name:   c.Config.PortName,
@@ -79,10 +78,22 @@ func (c *HIDController) Connect() error {
 			}
 		}
 	}()
+
+	//Send over an opr queue reset signal
+	err = c.Send([]byte{OPR_TYPE_DATA_RESET})
+	if err != nil {
+		return err
+	}
+
+	//Reset keyboard press state
+	err = c.Send([]byte{OPR_TYPE_KEYBOARD_WRITE, SUBTYPE_KEYBOARD_SPECIAL_RESET, 0x00})
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
-func (c *HIDController) Send(data []byte) error {
+func (c *Controller) Send(data []byte) error {
 	n, err := c.serialPort.Write(data)
 	if err != nil {
 		return err
@@ -94,7 +105,7 @@ func (c *HIDController) Send(data []byte) error {
 	return nil
 }
 
-func (c *HIDController) Close() {
+func (c *Controller) Close() {
 	if c.stopChan != nil {
 		c.stopChan <- true
 	}

remdeskd/mod/remdeshid/typedef.go

@@ -1,47 +0,0 @@
-package remdeshid
-
-// Operation Types
-const (
-	OPR_TYPE_RESERVED          = 0x00
-	OPR_TYPE_KEYBOARD_WRITE    = 0x01
-	OPR_TYPE_MOUSE_WRITE       = 0x02
-	OPR_TYPE_SWITCH_WRITE      = 0x03
-	OPR_TYPE_LED_WRITE         = 0x04
-	OPR_TYPE_RESET_INSTR_COUNT = 0xFE
-	OPR_TYPE_DATA_RESET        = 0xFF
-)
-
-// Operation Sub-types
-const (
-	SUBTYPE_RESERVED = 0x00
-)
-
-// Keyboard Subtypes
-const (
-	SUBTYPE_KEYBOARD_ASCII_WRITE        = 0x01
-	SUBTYPE_KEYBOARD_ASCII_PRESS        = 0x02
-	SUBTYPE_KEYBOARD_ASCII_RELEASE      = 0x03
-	SUBTYPE_KEYBOARD_MODIFIER_SET       = 0x04
-	SUBTYPE_KEYBOARD_MODIFIER_CLEAR     = 0x05
-	SUBTYPE_KEYBOARD_FUNCTKEY_WRITE     = 0x06
-	SUBTYPE_KEYBOARD_OTHERKEY_PRESS     = 0x07
-	SUBTYPE_KEYBOARD_OTHERKEY_RELEASE   = 0x08
-	SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL = 0xFD
-	SUBTYPE_KEYBOARD_SPECIAL_RESET      = 0xFE
-	SUBTYPE_KEYBOARD_SPECIAL_RESERVED   = 0xFF
-)
-
-// Response Codes
-const (
-	RESP_OK                = 0x00
-	RESP_UNKNOWN_OPR       = 0x01
-	RESP_INVALID_OPR_TYPE  = 0x02
-	RESP_INVALID_KEY_VALUE = 0x03
-	RESP_NOT_IMPLEMENTED   = 0x04
-
-	RESP_START_OF_DEBUG_MSG = 0xE0
-	RESP_END_OF_DEBUG_MSG   = 0xE1
-
-	RESP_START_OF_ERR_MSG = 0xEE
-	RESP_END_OF_ERR_MSG   = 0xEF
-)

remdeskd/www/index.html

@@ -17,5 +17,81 @@
 <body>
     <h1>Hello World</h1>
     <p>Welcome to my website!</p>
+    <button id="startButton">Start</button>
+    <button id="stopButton">Stop</button>
+    <script>
+        let socket;
+        let protocol = window.location.protocol === 'https:' ? 'wss' : 'ws';
+        let port = window.location.port ? window.location.port : (protocol === 'wss' ? 443 : 80);
+        let socketURL = `${protocol}://${window.location.hostname}:${port}/hid`;
+        document.getElementById('startButton').addEventListener('click', function() {
+            const socketUrl = socketURL;
+            socket = new WebSocket(socketUrl);
+
+            socket.addEventListener('open', function(event) {
+                console.log('WebSocket is connected.');
+            });
+
+            socket.addEventListener('message', function(event) {
+                console.log('Message from server ', event.data);
+            });
+
+            document.addEventListener('keydown', handleKeyDown);
+            document.addEventListener('keyup', handleKeyUp);
+        });
+
+        document.getElementById('stopButton').addEventListener('click', function() {
+            if (socket) {
+                socket.close();
+                console.log('WebSocket is disconnected.');
+            }
+
+            document.removeEventListener('keydown', handleKeyDown);
+            document.removeEventListener('keyup', handleKeyUp);
+        });
+
+        function isNumpadEvent(event) {
+            return event.location === 3;
+        }
+
+        function handleKeyDown(event) {
+            event.preventDefault();
+            const key = event.key;
+            if (socket){
+                if (key == "Shift" || key == "Control" || key == "Alt"){
+                    if (event.location == 1){
+                        socket.send(JSON.stringify({ t: 'kw', s: 'kd', d: "LEFT_" + key }));
+                    } else {
+                        socket.send(JSON.stringify({ t: 'kw', s: 'kd', d:  "RIGHT_" + key }));
+                    }
+                }else if (isNumpadEvent(event)){
+                    socket.send(JSON.stringify({ t: 'kw', s: 'kd', d: "NUMPAD_" + key }));
+                }else{
+                    socket.send(JSON.stringify({ t: 'kw', s: 'kd', d: key }));
+                }
+            }
+        }
+
+        function handleKeyUp(event) {
+            event.preventDefault();
+            const key = event.key;
+            if (socket) {
+                if (key == "Shift" || key == "Control" || key == "Alt") {
+                    if (event.location == 1) {
+                        socket.send(JSON.stringify({ t: 'kw', s: 'ku', d: "LEFT_" + key }));
+                    } else {
+                        socket.send(JSON.stringify({ t: 'kw', s: 'ku', d: "RIGHT_" + key }));
+                    }
+                }else if (isNumpadEvent(event)){
+                    socket.send(JSON.stringify({ t: 'kw', s: 'ku', d: "NUMPAD_" + key }));
+                
+                } else {
+                    socket.send(JSON.stringify({ t: 'kw', s: 'ku', d: key }));
+                }
+            }
+        }
+
+        
+    </script>
 </body>
 </html>

usbkvm/usbkvm_fw/keyboard_emu.ino

@@ -149,6 +149,119 @@ void keyboard_modifying_key_set(uint8_t key) {
   }
 }
 
+//Set a specific numpad key value
+void numpad_key_set(bool isPress, uint8_t value) {
+  if (isPress) {
+    switch (value) {
+      case PAYLOAD_NUMPAD_0:
+        Keyboard_press('\352');  //0
+        return;
+      case PAYLOAD_NUMPAD_1:
+        Keyboard_press('\341');  //1
+        return;
+      case PAYLOAD_NUMPAD_2:
+        Keyboard_press('\342');  //2
+        return;
+      case PAYLOAD_NUMPAD_3:
+        Keyboard_press('\343');  //3
+        return;
+      case PAYLOAD_NUMPAD_4:
+        Keyboard_press('\344');  //4
+        return;
+      case PAYLOAD_NUMPAD_5:
+        Keyboard_press('\345');  //5
+        return;
+      case PAYLOAD_NUMPAD_6:
+        Keyboard_press('\346');  //6
+        return;
+      case PAYLOAD_NUMPAD_7:
+        Keyboard_press('\347');  //7
+        return;
+      case PAYLOAD_NUMPAD_8:
+        Keyboard_press('\350');  //8
+        return;
+      case PAYLOAD_NUMPAD_9:
+        Keyboard_press('\351');  //9
+        return;
+      case PAYLOAD_NUMPAD_DOT:
+        Keyboard_press('\353');  //.
+        return;
+      case PAYLOAD_NUMPAD_TIMES:
+        Keyboard_press('\335');  //*
+        return;
+      case PAYLOAD_NUMPAD_DIV:
+        Keyboard_press('\334');  // /
+        return;
+      case PAYLOAD_NUMPAD_PLUS:
+        Keyboard_press('\337');  // +
+        return;
+      case PAYLOAD_NUMPAD_MINUS:
+        Keyboard_press('\336');  // -
+        return;
+      case PAYLOAD_NUMPAD_ENTER:
+        Keyboard_press('\340');  // Enter
+        return;
+      case PAYLOAD_NUMPAD_NUMLOCK:
+        Keyboard_press('\333');  // NumLock
+        return;
+    }
+  } else {
+    switch (value) {
+      case PAYLOAD_NUMPAD_0:
+        Keyboard_release('\352');  //0
+        return;
+      case PAYLOAD_NUMPAD_1:
+        Keyboard_release('\341');  //1
+        return;
+      case PAYLOAD_NUMPAD_2:
+        Keyboard_release('\342');  //2
+        return;
+      case PAYLOAD_NUMPAD_3:
+        Keyboard_release('\343');  //3
+        return;
+      case PAYLOAD_NUMPAD_4:
+        Keyboard_release('\344');  //4
+        return;
+      case PAYLOAD_NUMPAD_5:
+        Keyboard_release('\345');  //5
+        return;
+      case PAYLOAD_NUMPAD_6:
+        Keyboard_release('\346');  //6
+        return;
+      case PAYLOAD_NUMPAD_7:
+        Keyboard_release('\347');  //7
+        return;
+      case PAYLOAD_NUMPAD_8:
+        Keyboard_release('\350');  //8
+        return;
+      case PAYLOAD_NUMPAD_9:
+        Keyboard_release('\351');  //9
+        return;
+      case PAYLOAD_NUMPAD_DOT:
+        Keyboard_release('\353');  //.
+        return;
+      case PAYLOAD_NUMPAD_TIMES:
+        Keyboard_release('\335');  //*
+        return;
+      case PAYLOAD_NUMPAD_DIV:
+        Keyboard_release('\334');  // /
+        return;
+      case PAYLOAD_NUMPAD_PLUS:
+        Keyboard_release('\337');  // +
+        return;
+      case PAYLOAD_NUMPAD_MINUS:
+        Keyboard_release('\336');  // -
+        return;
+      case PAYLOAD_NUMPAD_ENTER:
+        Keyboard_release('\340');  // Enter
+        return;
+      case PAYLOAD_NUMPAD_NUMLOCK:
+        Keyboard_release('\333');  // NumLock
+        return;
+    }
+  }
+}
+
 //Entry point for keyboard emulation
 uint8_t keyboard_emulation(uint8_t subtype, uint8_t value) {
   //Check if the input is a supported ascii value
@@ -175,10 +288,15 @@ uint8_t keyboard_emulation(uint8_t subtype, uint8_t value) {
     case SUBTYPE_KEYBOARD_MODIFIER_CLEAR:
       keyboard_modifying_key_set(0x00);
       return resp_ok;
-    case SUBTYPE_KEYBOARD_FUNCTKEY_WRITE:
+    case SUBTYPE_KEYBOARD_FUNCTKEY_PRESS:
       if (!is_funckey(value))
         return resp_invalid_key_value;
-      Keyboard_write(value);
+      Keyboard_press(value);
+      return resp_ok;
+    case SUBTYPE_KEYBOARD_FUNCTKEY_RELEASE:
+      if (!is_funckey(value))
+        return resp_invalid_key_value;
+      Keyboard_release(value);
       return resp_ok;
     case SUBTYPE_KEYBOARD_OTHERKEY_PRESS:
       if (!is_validkeys(value))
@@ -190,13 +308,22 @@ uint8_t keyboard_emulation(uint8_t subtype, uint8_t value) {
         return resp_invalid_key_value;
       Keyboard_release(value);
       return resp_ok;
+    case SUBTYPE_KEYBOARD_NUMPAD_PRESS:
+      if (value > PAYLOAD_NUMPAD_NUMLOCK)
+        return resp_invalid_key_value;
+      numpad_key_set(true, value);
+      return resp_ok;
+    case SUBTYPE_KEYBOARD_NUMPAD_RELEASE:
+      if (value > PAYLOAD_NUMPAD_NUMLOCK)
+        return resp_invalid_key_value;
+      numpad_key_set(false, value);
+      return resp_ok;
     case SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL:
       // Press Ctrl + Alt + Del
       Keyboard_press(KEY_LEFT_CTRL);
       Keyboard_press(KEY_LEFT_ALT);
       Keyboard_press(KEY_DELETE);
       delay(100);  // Give a little longer time for all keys to be registered together
-
       // Release Ctrl + Alt + Del in reverse order
       Keyboard_release(KEY_DELETE);
       delay(MIN_KEY_EVENTS_DELAY);

usbkvm/usbkvm_fw/usbkvm_fw.h

@@ -31,13 +31,35 @@
 #define SUBTYPE_KEYBOARD_ASCII_RELEASE 0x03       // Release a key (ASCII 32-127)
 #define SUBTYPE_KEYBOARD_MODIFIER_SET 0x04        // Modifier key write (bit flags)
 #define SUBTYPE_KEYBOARD_MODIFIER_CLEAR 0x05      // Modifier key press (bit flags)
-#define SUBTYPE_KEYBOARD_FUNCTKEY_WRITE 0x06      //Function key write
-#define SUBTYPE_KEYBOARD_OTHERKEY_PRESS 0x07      //Other keys press
-#define SUBTYPE_KEYBOARD_OTHERKEY_RELEASE 0x08    //Other keys release
+#define SUBTYPE_KEYBOARD_FUNCTKEY_PRESS 0x06      //Function key press
+#define SUBTYPE_KEYBOARD_FUNCTKEY_RELEASE 0x07    //Function key release
+#define SUBTYPE_KEYBOARD_OTHERKEY_PRESS 0x08      //Other keys press
+#define SUBTYPE_KEYBOARD_OTHERKEY_RELEASE 0x09    //Other keys release
+#define SUBTYPE_KEYBOARD_NUMPAD_PRESS 0x0A        //Numpad numeric press
+#define SUBTYPE_KEYBOARD_NUMPAD_RELEASE 0x0B      //Numpad numeric release
 #define SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL 0xFD  //Ctrl + Alt + Del
 #define SUBTYPE_KEYBOARD_SPECIAL_RESET 0xFE       //Reset all keypress state
 #define SUBTYPE_KEYBOARD_SPECIAL_RESERVED 0xFF    //Reserved
 
+/* Numpad Buttons IDs */
+#define PAYLOAD_NUMPAD_0 0x00
+#define PAYLOAD_NUMPAD_1 0x01
+#define PAYLOAD_NUMPAD_2 0x02
+#define PAYLOAD_NUMPAD_3 0x03
+#define PAYLOAD_NUMPAD_4 0x04
+#define PAYLOAD_NUMPAD_5 0x05
+#define PAYLOAD_NUMPAD_6 0x06
+#define PAYLOAD_NUMPAD_7 0x07
+#define PAYLOAD_NUMPAD_8 0x08
+#define PAYLOAD_NUMPAD_9 0x09
+#define PAYLOAD_NUMPAD_DOT 0x0A
+#define PAYLOAD_NUMPAD_TIMES 0x0B
+#define PAYLOAD_NUMPAD_DIV 0x0C
+#define PAYLOAD_NUMPAD_PLUS 0x0D
+#define PAYLOAD_NUMPAD_MINUS 0x0E
+#define PAYLOAD_NUMPAD_ENTER 0x0F
+#define PAYLOAD_NUMPAD_NUMLOCK 0x10
+
 /* Mouse Subtypes */
 #define SUBTYPE_MOUSE_CLICK 0x01    //Mouse button click
 #define SUBTYPE_MOUSE_PRESS 0x02    //Mouse button press
@@ -45,7 +67,7 @@
 #define SUBTYPE_MOUSE_SETPOS 0x04   //Mouse presets position
 #define SUBTYPE_MOUSE_RESET 0x05    //Reset all mouse button states
 
-/* Mouse Buttons ID */
+/* Mouse Buttons IDs */
 #define PAYLOAD_MOUSE_BTN_LEFT 0x01
 #define PAYLOAD_MOUSE_BTN_RIGHT 0x02
 #define PAYLOAD_MOUSE_BTN_MID 0x03

usbkvm/usbkvm_fw/usbkvm_fw.ino

@@ -8,7 +8,7 @@
   remdeskvmd via a USB 2.0 connection.
 
   Upload Settings
-  CH552G 
+  CH552G 24Mhz
 */
 
 #ifndef USER_USB_RAM