From 15826f63185211ff3974b29370d04b8082be9c53 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 15 Aug 2020 13:45:23 +0200
Subject: Add VISCA documentation, fix some issues

---
 backends/visca.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 backends/visca.md

(limited to 'backends/visca.md')

diff --git a/backends/visca.md b/backends/visca.md
new file mode 100644
index 0000000..26e523a
--- /dev/null
+++ b/backends/visca.md
@@ -0,0 +1,50 @@
+### The `visca` backend
+
+The VISCA backend provides control of compatible PTZ (Pan, Tilt, Zoom) controllable cameras
+via the network. This protocol has, with some variations, been implemented by multiple manufacturers
+in their camera equipment. There may be some specific limits on the command set depending on make
+and model of your equpipment.
+
+This backend can connect to both UDP and TCP based cameras.
+
+#### Global configuration
+
+The `visca` backend does not take any global configuration.
+
+#### Instance configuration
+
+| Option	| Example value		| Default value 	| Description							|
+|---------------|-----------------------|-----------------------|---------------------------------------------------------------|
+| `id`		| `5`			| `1`			| VISCA Camera address (normally 1 for network communication	|
+| `connect`	| `10.10.10.1 5678`	| none			| Camera network address and port. Default connection is TCP, when optionally suffixed with the `udp` keyword, connection will be UDP |
+| `device`	| `/dev/ttyUSB0`	| none			| (Linux only) Device node for a serial port adapter connecting to the camera |
+
+#### Channel specification
+
+Each instance exposes the following channels
+
+* `pan`: Pan axis
+* `tilt`: Tilt axis
+* `panspeed`: Pan speed
+* `tiltspeed`: Tilt speed
+* `zoom`: Zoom position
+* `focus`: Focus position
+* `memory<n>`: Call memory <n> (if incoming event value is greater than 0.9)
+
+Example mappings:
+
+```
+control.pan > visca.pan
+control.tilt > visca.tilt
+control.btn1 > visca.memory1
+```
+
+#### Known bugs / problems
+
+Value readback / Inquiry is not yet implemented. This backend currently only does output.
+
+Some manufacturers use VISCA, but require special framing for command flow control. This may be implemented
+in the future if there is sufficient interest.
+
+Please file a ticket if you can confirm this backend working/nonworking with a new make or model
+of camera so we can add it to the compatability list!
-- 
cgit v1.2.3


From 5bf8fcd4cd4e5ccabb46e830dffa19fd6f7a2f11 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 15 Aug 2020 22:19:22 +0200
Subject: Update visca documentation

---
 backends/visca.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.md b/backends/visca.md
index 26e523a..6d978e2 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -1,11 +1,11 @@
 ### The `visca` backend
 
-The VISCA backend provides control of compatible PTZ (Pan, Tilt, Zoom) controllable cameras
-via the network. This protocol has, with some variations, been implemented by multiple manufacturers
-in their camera equipment. There may be some specific limits on the command set depending on make
-and model of your equpipment.
+The `visca` backend provides control of compatible PTZ (Pan, Tilt, Zoom) controllable cameras
+via the network. The VISCA protocol has, with some variations, been implemented by multiple manufacturers
+in their camera equipment. There may be some specific limits on the command set depending on the make
+and model of your equipment.
 
-This backend can connect to both UDP and TCP based cameras.
+This backend can connect to both UDP and TCP based camera control interfaces.
 
 #### Global configuration
 
-- 
cgit v1.2.3


From 9f2deded624e1a934b52ac0d4d33e3612a7fb469 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 12 Sep 2020 19:34:26 +0200
Subject: Fix VISCA dialect

---
 backends/visca.c  | 88 ++++++++++++++++++++++++++++++++++++++++++++-----------
 backends/visca.h  | 24 ++++++++-------
 backends/visca.md |  1 +
 3 files changed, 86 insertions(+), 27 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.c b/backends/visca.c
index 619211d..d408b80 100644
--- a/backends/visca.c
+++ b/backends/visca.c
@@ -7,6 +7,7 @@
 
 /* TODO
  *	VISCA server
+ *	Rate limiting
  */
 
 MM_PLUGIN_API int init(){
@@ -128,8 +129,8 @@ static channel* ptz_channel(instance* inst, char* spec, uint8_t flags){
 	}
 
 	//store the memory to be called above the command type
-	if(ident == call){
-		ident |= (strtoul(spec + strlen(ptz_channels[call].name), NULL, 10) << 8);
+	if(ident == call || ident == store){
+		ident |= (strtoul(spec + strlen(ptz_channels[ident].name), NULL, 10) << 8);
 	}
 
 	return mm_channel(inst, ident, 1);
@@ -137,20 +138,27 @@ static channel* ptz_channel(instance* inst, char* spec, uint8_t flags){
 
 static size_t ptz_set_pantilt(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
-	uint32_t* x = (uint32_t*) (msg + 6);
-	uint32_t* y = (uint32_t*) (msg + 10);
-	
+
 	if(c->ident == pan){
-		data->x = ((ptz_channels[pan].max - ptz_channels[pan].min) * v->normalised) + ptz_channels[pan].min;
+		data->x = ((ptz_channels[pan].max - ptz_channels[pan].min) * v->normalised) + ptz_channels[pan].min - ptz_channels[pan].offset;
 	}
 	else{
-		data->y = ((ptz_channels[tilt].max - ptz_channels[tilt].min) * v->normalised) + ptz_channels[tilt].min;
+		data->y = ((ptz_channels[tilt].max - ptz_channels[tilt].min) * v->normalised) + ptz_channels[tilt].min - ptz_channels[tilt].offset;
 	}
 
 	msg[4] = data->panspeed;
 	msg[5] = data->tiltspeed;
-	*x = htobe32(data->x);
-	*y = htobe32(data->y);
+
+	//either i'm doing this wrong or visca is just weird.
+	msg[6] = ((data->x & 0xF000) >> 12);
+	msg[7] = ((data->x & 0x0F00) >> 8);
+	msg[8] = ((data->x & 0xF0) >> 4);
+	msg[9] = (data->x & 0x0F);
+
+	msg[10] = ((data->y & 0xF000) >> 12);
+	msg[11] = ((data->y & 0x0F00) >> 8);
+	msg[12] = ((data->y & 0xF0) >> 4);
+	msg[13] = (data->y & 0x0F);
 
 	return ptz_channels[pan].bytes;
 }
@@ -158,24 +166,30 @@ static size_t ptz_set_pantilt(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
 	if(c->ident == panspeed){
-		data->panspeed = ((ptz_channels[panspeed].max - ptz_channels[panspeed].min) * v->normalised) + ptz_channels[panspeed].min;
+		data->panspeed = ((ptz_channels[panspeed].max - ptz_channels[panspeed].min) * v->normalised) + ptz_channels[panspeed].min - ptz_channels[panspeed].offset;
 	}
 	else{
-		data->tiltspeed = ((ptz_channels[tiltspeed].max - ptz_channels[tiltspeed].min) * v->normalised) + ptz_channels[tiltspeed].min;
+		data->tiltspeed = ((ptz_channels[tiltspeed].max - ptz_channels[tiltspeed].min) * v->normalised) + ptz_channels[tiltspeed].min - ptz_channels[tiltspeed].offset;
 	}
 
 	return 0;
 }
 
 static size_t ptz_set_zoom(instance* inst, channel* c, channel_value* v, uint8_t* msg){
-	uint32_t* position = (uint32_t*) (msg + 4);
-	*position = htobe32(((ptz_channels[zoom].max - ptz_channels[zoom].min) * v->normalised) + ptz_channels[zoom].min);
+	uint16_t position = ((ptz_channels[zoom].max - ptz_channels[zoom].min) * v->normalised) + ptz_channels[zoom].min - ptz_channels[zoom].offset;
+	msg[4] = ((position & 0xF000) >> 12);
+	msg[5] = ((position & 0x0F00) >> 8);
+	msg[6] = ((position & 0xF0) >> 4);
+	msg[7] = (position & 0x0F);
 	return ptz_channels[zoom].bytes;
 }
 
 static size_t ptz_set_focus(instance* inst, channel* c, channel_value* v, uint8_t* msg){
-	uint32_t* position = (uint32_t*) (msg + 4);
-	*position = htobe32(((ptz_channels[focus].max - ptz_channels[focus].min) * v->normalised) + ptz_channels[focus].min);
+	uint16_t position = ((ptz_channels[focus].max - ptz_channels[focus].min) * v->normalised) + ptz_channels[focus].min - ptz_channels[focus].offset;
+	msg[4] = ((position & 0xF000) >> 12);
+	msg[5] = ((position & 0x0F00) >> 8);
+	msg[6] = ((position & 0xF0) >> 4);
+	msg[7] = (position & 0x0F);
 	return ptz_channels[focus].bytes;
 }
 
@@ -188,6 +202,15 @@ static size_t ptz_set_memory(instance* inst, channel* c, channel_value* v, uint8
 	return ptz_channels[call].bytes;
 }
 
+static size_t ptz_set_memory_store(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+	if(v->normalised < 0.9){
+		return 0;
+	}
+
+	msg[5] = (c->ident >> 8);
+	return ptz_channels[store].bytes;
+}
+
 static int ptz_set(instance* inst, size_t num, channel** c, channel_value* v){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
 	size_t n = 0, bytes = 0;
@@ -215,12 +238,43 @@ static int ptz_set(instance* inst, size_t num, channel** c, channel_value* v){
 }
 
 static int ptz_handle(size_t num, managed_fd* fds){
-	//no events generated here
+	uint8_t recv_buf[VISCA_BUFFER_LENGTH];
+	size_t u;
+	ssize_t bytes_read;
+	instance* inst = NULL;
+
+	//read and ignore any responses for now
+	for(u = 0; u < num; u++){
+		inst = (instance*) fds[u].impl;
+		bytes_read = recv(fds[u].fd, recv_buf, sizeof(recv_buf), 0);
+		if(bytes_read <= 0){
+			LOGPF("Failed to receive on signaled fd for instance %s", inst->name);
+			//TODO handle failure
+		}
+		else{
+			DBGPF("Ignored %" PRIsize_t " incoming bytes for instance %s", bytes_read, inst->name);
+		}
+	}
+
 	return 0;
 }
 
 static int ptz_start(size_t n, instance** inst){
-	//no startup needed yet
+	size_t u, fds = 0;
+	ptz_instance_data* data = NULL;
+
+	for(u = 0; u < n; u++){
+		data = (ptz_instance_data*) inst[u]->impl;
+		if(data->fd >= 0){
+			if(mm_manage_fd(data->fd, BACKEND_NAME, 1, inst[u])){
+				LOGPF("Failed to register descriptor for instance %s", inst[u]->name);
+				return 1;
+			}
+			fds++;
+		}
+	}
+
+	LOGPF("Registered %" PRIsize_t " descriptors to core", fds);
 	return 0;
 }
 
diff --git a/backends/visca.h b/backends/visca.h
index 54c80f7..09c9057 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -15,8 +15,8 @@ static int ptz_shutdown(size_t n, instance** inst);
 typedef struct /*_ptz_instance_data*/ {
 	int fd;
 	uint8_t cam_address;
-	uint32_t x;
-	uint32_t y;
+	uint16_t x;
+	uint16_t y;
 	uint8_t panspeed;
 	uint8_t tiltspeed;
 } ptz_instance_data;
@@ -29,6 +29,7 @@ enum /*ptz_channels*/ {
 	zoom,
 	focus,
 	call,
+	store,
 	sentinel
 };
 
@@ -38,20 +39,23 @@ static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_zoom(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_focus(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_memory(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+static size_t ptz_set_memory_store(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 
 static struct {
 	char* name;
 	size_t bytes;
 	uint8_t pattern[VISCA_BUFFER_LENGTH];
-	size_t min;
+	size_t min; //channel range = max - min
 	size_t max;
+	size_t offset; //channel value = normalised * range - offset
 	ptz_channel_set set;
 } ptz_channels[] = {
-	[pan] = {"pan", 14, {0x80, 0x01, 0x06, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF}, 0, 4000, ptz_set_pantilt},
-	[tilt] = {"tilt", 14, {0x80, 0x01, 0x06, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF}, 0, 4000, ptz_set_pantilt},
-	[panspeed] = {"panspeed", 0, {0}, 0x01, 0x18, ptz_set_ptspeed},
-	[tiltspeed] = {"tiltspeed", 0, {0}, 0x01, 0x14, ptz_set_ptspeed},
-	[zoom] = {"zoom", 9, {0x80, 0x01, 0x04, 0x47, 0, 0, 0, 0, 0xFF}, 0, 4000, ptz_set_zoom},
-	[focus] = {"focus", 9, {0x80, 0x01, 0x04, 0x48, 0, 0, 0, 0, 0xFF}, 0, 4000, ptz_set_focus},
-	[call] = {"memory", 7, {0x80, 0x01, 0x04, 0x3F, 0x02, 0, 0xFF}, 0, 254, ptz_set_memory}
+	[pan] = {"pan", 15, {0x80, 0x01, 0x06, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF}, 0, 0x990 * 2, 0x990, ptz_set_pantilt},
+	[tilt] = {"tilt", 15, {0x80, 0x01, 0x06, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF}, 0, 0x510 * 2, 0x510, ptz_set_pantilt},
+	[panspeed] = {"panspeed", 0, {0}, 0x01, 0x18, 0, ptz_set_ptspeed},
+	[tiltspeed] = {"tiltspeed", 0, {0}, 0x01, 0x14, 0, ptz_set_ptspeed},
+	[zoom] = {"zoom", 9, {0x80, 0x01, 0x04, 0x47, 0, 0, 0, 0, 0xFF}, 0, 0x4000, 0, ptz_set_zoom},
+	[focus] = {"focus", 9, {0x80, 0x01, 0x04, 0x48, 0, 0, 0, 0, 0xFF}, 0, 0x4000, 0, ptz_set_focus},
+	[call] = {"memory", 7, {0x80, 0x01, 0x04, 0x3F, 0x02, 0, 0xFF}, 0, 254, 0, ptz_set_memory},
+	[store] = {"store", 7, {0x80, 0x01, 0x04, 0x3F, 0x01, 0, 0xFF}, 0, 254, 0, ptz_set_memory_store}
 };
diff --git a/backends/visca.md b/backends/visca.md
index 6d978e2..4fe1933 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -30,6 +30,7 @@ Each instance exposes the following channels
 * `zoom`: Zoom position
 * `focus`: Focus position
 * `memory<n>`: Call memory <n> (if incoming event value is greater than 0.9)
+* `store<n>`: Store current pan/tilt/zoom setup to memory <n> (if incoming event value is greater than 0.9)
 
 Example mappings:
 
-- 
cgit v1.2.3


From d45ca2422fd5bedf48d68a3a537bae924b0cbae7 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 18 Sep 2020 20:12:53 +0200
Subject: Implement additional VISCA channels

---
 backends/visca.c  | 28 ++++++++++++++++++++++++++++
 backends/visca.h  | 21 ++++++++++++++++++++-
 backends/visca.md | 16 ++++++++++++++--
 3 files changed, 62 insertions(+), 3 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.c b/backends/visca.c
index d408b80..32f11c9 100644
--- a/backends/visca.c
+++ b/backends/visca.c
@@ -8,6 +8,7 @@
 /* TODO
  *	VISCA server
  *	Rate limiting
+ *	Inquiry
  */
 
 MM_PLUGIN_API int init(){
@@ -175,6 +176,13 @@ static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint
 	return 0;
 }
 
+static size_t ptz_set_stop(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
+	msg[4] = data->panspeed;
+	msg[5] = data->tiltspeed;
+	return ptz_channels[stop].bytes;
+}
+
 static size_t ptz_set_zoom(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	uint16_t position = ((ptz_channels[zoom].max - ptz_channels[zoom].min) * v->normalised) + ptz_channels[zoom].min - ptz_channels[zoom].offset;
 	msg[4] = ((position & 0xF000) >> 12);
@@ -193,6 +201,24 @@ static size_t ptz_set_focus(instance* inst, channel* c, channel_value* v, uint8_
 	return ptz_channels[focus].bytes;
 }
 
+static size_t ptz_set_focus_mode(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+	msg[4] = (v->normalised > 0.9) ? 2 : 3;
+	return ptz_channels[focus_mode].bytes;
+}
+
+static size_t ptz_set_wb_mode(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+	msg[4] = (v->normalised > 0.9) ? 0 : 5;
+	return ptz_channels[wb_mode].bytes;
+}
+
+static size_t ptz_set_wb(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+	uint8_t command = c->ident & 0xFF;
+	uint8_t value = ((ptz_channels[command].max - ptz_channels[command].min) * v->normalised) + ptz_channels[command].min - ptz_channels[command].offset;
+	msg[6] = value >> 4;
+	msg[7] = value & 0x0F;
+	return ptz_channels[command].bytes;
+}
+
 static size_t ptz_set_memory(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	if(v->normalised < 0.9){
 		return 0;
@@ -223,6 +249,8 @@ static int ptz_set(instance* inst, size_t num, channel** c, channel_value* v){
 
 		if(ptz_channels[command].bytes){
 			memcpy(tx, ptz_channels[command].pattern, ptz_channels[command].bytes);
+			//if no handler function set, assume a parameterless command and send verbatim
+			bytes = ptz_channels[command].bytes;
 		}
 		tx[0] = 0x80 | (data->cam_address & 0xF);
 
diff --git a/backends/visca.h b/backends/visca.h
index 09c9057..481f5c7 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -28,8 +28,14 @@ enum /*ptz_channels*/ {
 	tiltspeed,
 	zoom,
 	focus,
+	focus_mode,
+	wb_red,
+	wb_blue,
+	wb_mode,
 	call,
 	store,
+	home,
+	stop,
 	sentinel
 };
 
@@ -38,9 +44,15 @@ static size_t ptz_set_pantilt(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_zoom(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_focus(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+static size_t ptz_set_focus_mode(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+static size_t ptz_set_wb_mode(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+static size_t ptz_set_wb(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_memory(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_memory_store(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 
+//relative move test
+static size_t ptz_set_stop(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+
 static struct {
 	char* name;
 	size_t bytes;
@@ -56,6 +68,13 @@ static struct {
 	[tiltspeed] = {"tiltspeed", 0, {0}, 0x01, 0x14, 0, ptz_set_ptspeed},
 	[zoom] = {"zoom", 9, {0x80, 0x01, 0x04, 0x47, 0, 0, 0, 0, 0xFF}, 0, 0x4000, 0, ptz_set_zoom},
 	[focus] = {"focus", 9, {0x80, 0x01, 0x04, 0x48, 0, 0, 0, 0, 0xFF}, 0, 0x4000, 0, ptz_set_focus},
+	[focus_mode] = {"autofocus", 6, {0x80, 0x01, 0x04, 0x38, 0, 0xFF}, 0, 1, 0, ptz_set_focus_mode},
+	[wb_mode] = {"wb.auto", 6, {0x80, 0x01, 0x04, 0x35, 0, 0xFF}, 0, 1, 0, ptz_set_wb_mode},
+	[wb_red] = {"wb.red", 9, {0x80, 0x01, 0x04, 0x43, 0x00, 0x00, 0, 0, 0xFF}, 0, 255, 0, ptz_set_wb},
+	[wb_blue] = {"wb.blue", 9, {0x80, 0x01, 0x04, 0x44, 0x00, 0x00, 0, 0, 0xFF}, 0, 255, 0, ptz_set_wb},
 	[call] = {"memory", 7, {0x80, 0x01, 0x04, 0x3F, 0x02, 0, 0xFF}, 0, 254, 0, ptz_set_memory},
-	[store] = {"store", 7, {0x80, 0x01, 0x04, 0x3F, 0x01, 0, 0xFF}, 0, 254, 0, ptz_set_memory_store}
+	[store] = {"store", 7, {0x80, 0x01, 0x04, 0x3F, 0x01, 0, 0xFF}, 0, 254, 0, ptz_set_memory_store},
+	[home] = {"home", 5, {0x80, 0x01, 0x06, 0x04, 0xFF}, 0, 0, 0, NULL},
+	//relative move test
+	[stop] = {"stop", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0x03, 0x03, 0xFF}, 0, 0, 0, ptz_set_stop}
 };
diff --git a/backends/visca.md b/backends/visca.md
index 4fe1933..d4fc432 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -29,6 +29,10 @@ Each instance exposes the following channels
 * `tiltspeed`: Tilt speed
 * `zoom`: Zoom position
 * `focus`: Focus position
+* `autofocus`: Switch between autofocus (events > 0.9) and manual focus drive mode
+* `wb.auto`: Switch between automatic white balance mode (events > 0.9) and manual white balance mode
+* `wb.red`, `wb.blue`: Red/Blue channel white balance gain values
+* `home`: Return to home position
 * `memory<n>`: Call memory <n> (if incoming event value is greater than 0.9)
 * `store<n>`: Store current pan/tilt/zoom setup to memory <n> (if incoming event value is greater than 0.9)
 
@@ -40,12 +44,20 @@ control.tilt > visca.tilt
 control.btn1 > visca.memory1
 ```
 
+#### Compatability list
+
+| Manufacturer	| Exact model(s) tested		| Compatible models				| Result / Notes					|
+|---------------|-------------------------------|-----------------------------------------------|-------------------------------------------------------|
+| ValueHD	| VHD-V61			| Probably all ValueHD Visca-capable devices	| Everything works except for absolute focus control	|
+| PTZOptics	| 				| Probably all of their PTZ cameras		| See ValueHD						|
+
 #### Known bugs / problems
 
 Value readback / Inquiry is not yet implemented. This backend currently only does output.
 
 Some manufacturers use VISCA, but require special framing for command flow control. This may be implemented
-in the future if there is sufficient interest.
+in the future if there is sufficient interest. Some commands may not work with some manufacturer's cameras due to
+different value ranges or command ordering.
 
 Please file a ticket if you can confirm this backend working/nonworking with a new make or model
-of camera so we can add it to the compatability list!
+of camera so we can add it to the compatibility list!
-- 
cgit v1.2.3


From e96ca85d8febf559817b43066ba16c8441ba391b Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 19 Sep 2020 00:20:11 +0200
Subject: Add local serial note for VISCA

---
 backends/visca.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.md b/backends/visca.md
index d4fc432..1dd516e 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -5,7 +5,8 @@ via the network. The VISCA protocol has, with some variations, been implemented
 in their camera equipment. There may be some specific limits on the command set depending on the make
 and model of your equipment.
 
-This backend can connect to both UDP and TCP based camera control interfaces.
+This backend can connect to both UDP and TCP based camera control interfaces. On Linux, it can also control
+devices attached to a serial/RS485 adapter.
 
 #### Global configuration
 
-- 
cgit v1.2.3


From 588503226ff61c2a440f19e050691af93cef0f5f Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 9 Oct 2020 23:17:41 +0200
Subject: Implement VISCA relative movement

---
 backends/visca.c  | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 backends/visca.h  | 20 ++++++++++----
 backends/visca.md |  6 +++--
 3 files changed, 96 insertions(+), 9 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.c b/backends/visca.c
index 8465c14..2e82515 100644
--- a/backends/visca.c
+++ b/backends/visca.c
@@ -2,6 +2,7 @@
 #define DEBUG
 
 #include <string.h>
+#include <math.h>	
 #include "visca.h"
 #include "libmmbackend.h"
 
@@ -87,6 +88,10 @@ static int ptz_configure_instance(instance* inst, char* option, char* value){
 		return 0;
 		#endif
 	}
+	else if(!strcmp(option, "deadzone")){
+		data->deadzone = strtod(value, NULL);
+		return 0;
+	}
 
 	LOGPF("Unknown instance configuration parameter %s for instance %s", option, inst->name);
 	return 1;
@@ -104,6 +109,8 @@ static int ptz_instance(instance* inst){
 	//start with maximum speeds
 	data->panspeed = ptz_channels[panspeed].max;
 	data->tiltspeed = ptz_channels[tiltspeed].max;
+	//start with a bit of slack/deadzone in relative movement axes
+	data->deadzone = 0.1;
 
 	inst->impl = data;
 	return 0;
@@ -135,6 +142,32 @@ static channel* ptz_channel(instance* inst, char* spec, uint8_t flags){
 		command |= (strtoul(spec + strlen(ptz_channels[command].name), NULL, 10) << 8);
 	}
 
+	//store relative move direction
+	else if(command == relmove){
+		if(!strcmp(spec + strlen(ptz_channels[relmove].name), ".up")
+				|| !strcmp(spec + strlen(ptz_channels[relmove].name), ".y")){
+			command |= (rel_up << 8);
+		}
+		else if(!strcmp(spec + strlen(ptz_channels[relmove].name), ".left")
+				|| !strcmp(spec + strlen(ptz_channels[relmove].name), ".x")){
+			command |= (rel_left << 8);
+		}
+
+		if(!strcmp(spec + strlen(ptz_channels[relmove].name), ".down")
+				|| !strcmp(spec + strlen(ptz_channels[relmove].name), ".y")){
+			command |= (rel_down << 8);
+		}
+		else if(!strcmp(spec + strlen(ptz_channels[relmove].name), ".right")
+				|| !strcmp(spec + strlen(ptz_channels[relmove].name), ".x")){
+			command |= (rel_right << 8);
+		}
+
+		if(command >> 8 == 0){
+			LOGPF("Could not parse relative movement command %s", spec);
+			return NULL;
+		}
+	}
+
 	return mm_channel(inst, command, 1);
 }
 
@@ -177,11 +210,53 @@ static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint
 	return 0;
 }
 
-static size_t ptz_set_stop(instance* inst, channel* c, channel_value* v, uint8_t* msg){
+static size_t ptz_set_relmove(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
+
+	uint8_t direction = c->ident >> 8;
+	double speed_factor = v->normalised;
+
+	if(direction == rel_x
+			|| direction == rel_y){
+		//select only one move event
+		direction &= (speed_factor > 0.5) ? (rel_up | rel_left) : (rel_down | rel_right);
+
+		//scale event value to full axis
+		speed_factor = fabs((speed_factor - 0.5) * 2);
+
+		//clamp to deadzone
+		speed_factor = (speed_factor < 2 * data->deadzone) ? 0 : speed_factor;
+	}
+
+	//clear modified axis
+	if(direction & rel_x){
+		data->relative_movement &= ~rel_x;
+	}
+	else{
+		data->relative_movement &= ~rel_y;
+	}
+
+	if(speed_factor){
+		data->relative_movement |= direction;
+	}
+
+	//set stored axis speed
 	msg[4] = data->panspeed;
 	msg[5] = data->tiltspeed;
-	return ptz_channels[stop].bytes;
+
+	//update motor control from movement data
+	msg[6] |= (data->relative_movement & (rel_left | rel_right)) >> 2;
+	msg[7] |= data->relative_movement & (rel_up | rel_down);
+
+	//stop motors if unset
+	msg[6] = msg[6] ? msg[6] : 3;
+	msg[7] = msg[7] ? msg[7] : 3;
+
+	DBGPF("Moving axis %d with factor %f, total movement now %02X, commanding %d / %d, %d / %d",
+			direction, speed_factor, data->relative_movement,
+			msg[6], msg[4], msg[7], msg[5]);
+
+	return ptz_channels[relmove].bytes;
 }
 
 static size_t ptz_set_zoom(instance* inst, channel* c, channel_value* v, uint8_t* msg){
diff --git a/backends/visca.h b/backends/visca.h
index 160398d..47ada19 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -12,6 +12,15 @@ static int ptz_shutdown(size_t n, instance** inst);
 
 #define VISCA_BUFFER_LENGTH 50
 
+enum /*_ptz_relmove_channel */ {
+	rel_up = 1,
+	rel_down = 2,
+	rel_left = 4,
+	rel_right = 8,
+	rel_x = 3,
+	rel_y = 12
+};
+
 typedef struct /*_ptz_instance_data*/ {
 	int fd;
 	uint8_t cam_address;
@@ -19,6 +28,8 @@ typedef struct /*_ptz_instance_data*/ {
 	uint16_t y;
 	uint8_t panspeed;
 	uint8_t tiltspeed;
+	uint8_t relative_movement;
+	double deadzone;
 } ptz_instance_data;
 
 enum /*ptz_channels*/ {
@@ -38,6 +49,7 @@ enum /*ptz_channels*/ {
 	store,
 	home,
 	stop,
+	relmove,
 	sentinel
 };
 
@@ -51,9 +63,7 @@ static size_t ptz_set_wb_mode(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_wb(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_memory(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 static size_t ptz_set_memory_store(instance* inst, channel* c, channel_value* v, uint8_t* msg);
-
-//relative move test
-static size_t ptz_set_stop(instance* inst, channel* c, channel_value* v, uint8_t* msg);
+static size_t ptz_set_relmove(instance* inst, channel* c, channel_value* v, uint8_t* msg);
 
 static struct {
 	char* name;
@@ -77,6 +87,6 @@ static struct {
 	[call] = {"memory", 7, {0x80, 0x01, 0x04, 0x3F, 0x02, 0, 0xFF}, 0, 254, 0, ptz_set_memory},
 	[store] = {"store", 7, {0x80, 0x01, 0x04, 0x3F, 0x01, 0, 0xFF}, 0, 254, 0, ptz_set_memory_store},
 	[home] = {"home", 5, {0x80, 0x01, 0x06, 0x04, 0xFF}, 0, 0, 0, NULL},
-	//relative move test
-	[stop] = {"stop", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0x03, 0x03, 0xFF}, 0, 0, 0, ptz_set_stop}
+	[relmove] = {"move", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0, 0, 0xFF}, 0, 1, 0, ptz_set_relmove},
+	[stop] = {"stop", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0x03, 0x03, 0xFF}, 0, 0, 0, ptz_set_relmove}
 };
diff --git a/backends/visca.md b/backends/visca.md
index 1dd516e..cf5906d 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -19,13 +19,14 @@ The `visca` backend does not take any global configuration.
 | `id`		| `5`			| `1`			| VISCA Camera address (normally 1 for network communication	|
 | `connect`	| `10.10.10.1 5678`	| none			| Camera network address and port. Default connection is TCP, when optionally suffixed with the `udp` keyword, connection will be UDP |
 | `device`	| `/dev/ttyUSB0`	| none			| (Linux only) Device node for a serial port adapter connecting to the camera |
+| `deadzone`	| `0.1`			| `0.1`			| Amount of event value variation to be ignored for relative movement commands |
 
 #### Channel specification
 
 Each instance exposes the following channels
 
-* `pan`: Pan axis
-* `tilt`: Tilt axis
+* `pan`: Pan axis (absolute)
+* `tilt`: Tilt axis (absolute)
 * `panspeed`: Pan speed
 * `tiltspeed`: Tilt speed
 * `zoom`: Zoom position
@@ -36,6 +37,7 @@ Each instance exposes the following channels
 * `home`: Return to home position
 * `memory<n>`: Call memory <n> (if incoming event value is greater than 0.9)
 * `store<n>`: Store current pan/tilt/zoom setup to memory <n> (if incoming event value is greater than 0.9)
+* `move.left`, `move.right`, `move.up`, `move.down`: Relative movement with the currently set `panspeed` and `tiltspeed`
 
 Example mappings:
 
-- 
cgit v1.2.3


From db76143dfff9aa69318273010fe2922c1e60ea4c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 16 May 2021 17:09:23 +0200
Subject: Fix VISCA serial output (Fixes #91)

---
 backends/visca.c  | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
 backends/visca.h  |  1 +
 backends/visca.md |  2 +-
 3 files changed, 56 insertions(+), 4 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.c b/backends/visca.c
index ba81f8d..611d142 100644
--- a/backends/visca.c
+++ b/backends/visca.c
@@ -2,7 +2,10 @@
 #define DEBUG
 
 #include <string.h>
-#include <math.h>	
+#include <math.h>
+#include <sys/ioctl.h>
+#include <asm/termbits.h>
+
 #include "visca.h"
 #include "libmmbackend.h"
 
@@ -81,11 +84,41 @@ static int ptz_configure_instance(instance* inst, char* option, char* value){
 		LOG("Direct device connections are not possible on Windows");
 		return 1;
 		#else
-		data->fd = open(value, O_NONBLOCK);
+
+		struct termios2 device_config;
+
+		options = strchr(value, ' ');
+		if(options){
+			//terminate port name
+			*options = 0;
+			options++;
+		}
+
+		data->fd = open(value, O_RDWR | O_NONBLOCK);
 		if(data->fd < 0){
 			LOGPF("Failed to connect instance %s to device %s", inst->name, value);
 			return 1;
 		}
+		data->direct_device = 1;
+
+		//configure baudrate
+		if(options){
+			//get current port config
+			if(ioctl(data->fd, TCGETS2, &device_config)){
+				LOGPF("Failed to get port configuration data for %s: %s", value, strerror(errno));
+				return 0;
+			}
+
+			device_config.c_cflag &= ~CBAUD;
+			device_config.c_cflag |= BOTHER;
+			device_config.c_ispeed = strtoul(options, NULL, 10);
+			device_config.c_ospeed = strtoul(options, NULL, 10);
+
+			//set updated config
+			if(ioctl(data->fd, TCSETS2, &device_config)){
+				LOGPF("Failed to set port configuration data for %s: %s", value, strerror(errno));
+			}
+		}
 		return 0;
 		#endif
 	}
@@ -315,6 +348,21 @@ static size_t ptz_set_memory_store(instance* inst, channel* c, channel_value* v,
 	return ptz_channels[store].bytes;
 }
 
+static int ptz_write_serial(int fd, uint8_t* data, size_t bytes){
+	ssize_t total = 0, sent;
+
+	while(total < bytes){
+		sent = write(fd, data + total, bytes - total);
+		if(sent < 0){
+			LOGPF("Failed to write to serial port: %s", strerror(errno));
+			return 1;
+		}
+		total += sent;
+	}
+
+	return 0;
+}
+
 static int ptz_set(instance* inst, size_t num, channel** c, channel_value* v){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
 	size_t n = 0, bytes = 0;
@@ -336,7 +384,10 @@ static int ptz_set(instance* inst, size_t num, channel** c, channel_value* v){
 			bytes = ptz_channels[command].set(inst, c[n], v + n, tx);
 		}
 
-		if(bytes && mmbackend_send(data->fd, tx, bytes)){
+		if(data->direct_device && bytes && ptz_write_serial(data->fd, tx, bytes)){
+			LOGPF("Failed to write %s command on instance %s", ptz_channels[command].name, inst->name);	
+		}
+		else if(!data->direct_device && bytes && mmbackend_send(data->fd, tx, bytes)){
 			LOGPF("Failed to push %s command on instance %s", ptz_channels[command].name, inst->name);
 		}
 	}
diff --git a/backends/visca.h b/backends/visca.h
index 1004076..1b8c0e5 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -30,6 +30,7 @@ typedef struct /*_ptz_instance_data*/ {
 	uint8_t tiltspeed;
 	uint8_t relative_movement;
 	double deadzone;
+	uint8_t direct_device;
 } ptz_instance_data;
 
 enum /*ptz_channels*/ {
diff --git a/backends/visca.md b/backends/visca.md
index cf5906d..101aa20 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -18,7 +18,7 @@ The `visca` backend does not take any global configuration.
 |---------------|-----------------------|-----------------------|---------------------------------------------------------------|
 | `id`		| `5`			| `1`			| VISCA Camera address (normally 1 for network communication	|
 | `connect`	| `10.10.10.1 5678`	| none			| Camera network address and port. Default connection is TCP, when optionally suffixed with the `udp` keyword, connection will be UDP |
-| `device`	| `/dev/ttyUSB0`	| none			| (Linux only) Device node for a serial port adapter connecting to the camera |
+| `device`	| `/dev/ttyUSB0 115200`	| none			| (Linux only) Device node for a serial port adapter connecting to the camera, optionally followed by the baudrate |
 | `deadzone`	| `0.1`			| `0.1`			| Amount of event value variation to be ignored for relative movement commands |
 
 #### Channel specification
-- 
cgit v1.2.3


From 9be900acd86e03c73266c552db133562005f5607 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Mon, 28 Jun 2021 21:46:55 +0200
Subject: Enhance visca relative movement

---
 backends/visca.c  | 42 ++++++++++++++++++++++++++----------------
 backends/visca.h  |  8 ++++----
 backends/visca.md |  6 +++++-
 3 files changed, 35 insertions(+), 21 deletions(-)

(limited to 'backends/visca.md')

diff --git a/backends/visca.c b/backends/visca.c
index a43d74f..a36b139 100644
--- a/backends/visca.c
+++ b/backends/visca.c
@@ -1,5 +1,5 @@
 #define BACKEND_NAME "visca"
-#define DEBUG
+//#define DEBUG
 
 #include <string.h>
 #include <math.h>
@@ -17,6 +17,8 @@
  *	Command output rate limiting / deduplication
  *	Inquiry
  *	Reconnect on connection close
+ *	Speed updates should send motor outputs
+ *
  */
 
 MM_PLUGIN_API int init(){
@@ -144,8 +146,8 @@ static int ptz_instance(instance* inst){
 	data->fd = -1;
 	data->cam_address = 1;
 	//start with maximum speeds
-	data->panspeed = ptz_channels[panspeed].max;
-	data->tiltspeed = ptz_channels[tiltspeed].max;
+	data->max_pan = ptz_channels[panspeed].max;
+	data->max_tilt = ptz_channels[tiltspeed].max;
 	//start with a bit of slack/deadzone in relative movement axes
 	data->deadzone = 0.1;
 
@@ -218,8 +220,9 @@ static size_t ptz_set_pantilt(instance* inst, channel* c, channel_value* v, uint
 		data->y = ((ptz_channels[tilt].max - ptz_channels[tilt].min) * v->normalised) + ptz_channels[tilt].min - ptz_channels[tilt].offset;
 	}
 
-	msg[4] = data->panspeed;
-	msg[5] = data->tiltspeed;
+	//absolute movements happen with maximum speed
+	msg[4] = data->max_pan;
+	msg[5] = data->max_tilt;
 
 	//either i'm doing this wrong or visca is just weird.
 	msg[6] = ((data->x & 0xF000) >> 12);
@@ -238,10 +241,10 @@ static size_t ptz_set_pantilt(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
 	if(c->ident == panspeed){
-		data->panspeed = ((ptz_channels[panspeed].max - ptz_channels[panspeed].min) * v->normalised) + ptz_channels[panspeed].min - ptz_channels[panspeed].offset;
+		data->max_pan = ((ptz_channels[panspeed].max - ptz_channels[panspeed].min) * v->normalised) + ptz_channels[panspeed].min - ptz_channels[panspeed].offset;
 	}
 	else{
-		data->tiltspeed = ((ptz_channels[tiltspeed].max - ptz_channels[tiltspeed].min) * v->normalised) + ptz_channels[tiltspeed].min - ptz_channels[tiltspeed].offset;
+		data->max_tilt = ((ptz_channels[tiltspeed].max - ptz_channels[tiltspeed].min) * v->normalised) + ptz_channels[tiltspeed].min - ptz_channels[tiltspeed].offset;
 	}
 
 	return 0;
@@ -250,7 +253,7 @@ static size_t ptz_set_ptspeed(instance* inst, channel* c, channel_value* v, uint
 static size_t ptz_set_relmove(instance* inst, channel* c, channel_value* v, uint8_t* msg){
 	ptz_instance_data* data = (ptz_instance_data*) inst->impl;
 
-	uint8_t direction = c->ident >> 8;
+	uint8_t direction = c->ident >> 8, movement = data->relative_movement;
 	double speed_factor = v->normalised;
 
 	if(direction == rel_x
@@ -267,24 +270,31 @@ static size_t ptz_set_relmove(instance* inst, channel* c, channel_value* v, uint
 
 	//clear modified axis
 	if(direction & rel_x){
-		data->relative_movement &= ~rel_x;
+		movement &= ~rel_x;
+		data->factor_tilt = speed_factor;
 	}
 	else{
-		data->relative_movement &= ~rel_y;
+		movement &= ~rel_y;
+		data->factor_pan = speed_factor;
 	}
 
 	if(speed_factor){
-		data->relative_movement |= direction;
+		movement |= direction;
 	}
 
+	//only transmit if something actually changed
+	if(!movement && !data->relative_movement){
+		return 0;
+	}
+	data->relative_movement = movement;
+
 	//set stored axis speed
-	//TODO find a way to do relative axis speed via speed_factor, without overwriting a set absolute speed
-	msg[4] = data->panspeed;
-	msg[5] = data->tiltspeed;
+	msg[4] = data->max_pan * data->factor_pan;
+	msg[5] = data->max_tilt * data->factor_tilt;
 
 	//update motor control from movement data
-	msg[6] |= (data->relative_movement & (rel_left | rel_right)) >> 2;
-	msg[7] |= data->relative_movement & (rel_up | rel_down);
+	msg[6] |= (movement & (rel_left | rel_right)) >> 2;
+	msg[7] |= movement & (rel_up | rel_down);
 
 	//stop motors if unset
 	msg[6] = msg[6] ? msg[6] : 3;
diff --git a/backends/visca.h b/backends/visca.h
index 1b8c0e5..37f21b1 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -17,8 +17,8 @@ enum /*_ptz_relmove_channel */ {
 	rel_down = 2,
 	rel_left = 4,
 	rel_right = 8,
-	rel_x = 3,
-	rel_y = 12
+	rel_x = rel_up | rel_down,
+	rel_y = rel_left | rel_right
 };
 
 typedef struct /*_ptz_instance_data*/ {
@@ -26,8 +26,8 @@ typedef struct /*_ptz_instance_data*/ {
 	uint8_t cam_address;
 	uint16_t x;
 	uint16_t y;
-	uint8_t panspeed;
-	uint8_t tiltspeed;
+	uint8_t max_pan, max_tilt;
+	double factor_pan, factor_tilt;
 	uint8_t relative_movement;
 	double deadzone;
 	uint8_t direct_device;
diff --git a/backends/visca.md b/backends/visca.md
index 101aa20..7b1bcc3 100644
--- a/backends/visca.md
+++ b/backends/visca.md
@@ -37,7 +37,9 @@ Each instance exposes the following channels
 * `home`: Return to home position
 * `memory<n>`: Call memory <n> (if incoming event value is greater than 0.9)
 * `store<n>`: Store current pan/tilt/zoom setup to memory <n> (if incoming event value is greater than 0.9)
-* `move.left`, `move.right`, `move.up`, `move.down`: Relative movement with the currently set `panspeed` and `tiltspeed`
+* `move.left`, `move.right`, `move.up`, `move.down`: Move relative to the current position. Set speed is multiplied by the event value.
+* `move.x`, `move.y`: Move relative to the current position along the specified axis. Set speed is multiplied by the event value scaled to the full range (ie. `0.0` to `0.5` moves in one direction, `0.5` to `1.0` in the other).
+
 
 Example mappings:
 
@@ -45,6 +47,8 @@ Example mappings:
 control.pan > visca.pan
 control.tilt > visca.tilt
 control.btn1 > visca.memory1
+control.stick_x > visca.move.x
+control.stick_y > visca.move.y
 ```
 
 #### Compatability list
-- 
cgit v1.2.3