From 0069fc2dc4b7c5d931b563c1d9388cd4930f8050 Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Tue, 28 Jan 2025 10:32:27 +0100
Subject: [PATCH 1/2] Updated SP-over-SLIP protocol.

Note: This is an incompatible protocol change. It requires a companion change in fujinet-firmware.

FujiNet makes use of command list bytes there weren't used so far. This only works with CBus because CBus alwaways tranports all possible command list bytes no matter what command is given. Now the SP-over-SLIP protocol shows exactly the same behavior CBus protocol.
---
 AppleWin-VS2022.vcxproj                 |  4 --
 AppleWin-VS2022.vcxproj.filters         |  2 -
 source/SmartPortOverSlip.cpp            | 83 +++++++++----------------
 source/SmartPortOverSlip.h              | 28 ++++-----
 source/devrelay/commands/Close.cpp      |  4 +-
 source/devrelay/commands/Close.h        |  2 +-
 source/devrelay/commands/Control.cpp    |  7 ++-
 source/devrelay/commands/Control.h      |  2 +-
 source/devrelay/commands/Format.cpp     |  4 +-
 source/devrelay/commands/Format.h       |  2 +-
 source/devrelay/commands/Init.cpp       |  4 +-
 source/devrelay/commands/Init.h         |  2 +-
 source/devrelay/commands/Open.cpp       |  4 +-
 source/devrelay/commands/Open.h         |  2 +-
 source/devrelay/commands/Read.cpp       |  5 +-
 source/devrelay/commands/Read.h         |  2 +-
 source/devrelay/commands/ReadBlock.cpp  |  5 +-
 source/devrelay/commands/ReadBlock.h    |  2 +-
 source/devrelay/commands/Reset.cpp      | 51 ---------------
 source/devrelay/commands/Reset.h        | 26 --------
 source/devrelay/commands/Status.cpp     |  6 +-
 source/devrelay/commands/Status.h       |  2 +-
 source/devrelay/commands/Write.cpp      |  5 +-
 source/devrelay/commands/Write.h        |  2 +-
 source/devrelay/commands/WriteBlock.cpp |  6 +-
 source/devrelay/commands/WriteBlock.h   |  2 +-
 source/devrelay/service/Listener.cpp    |  4 +-
 source/devrelay/types/Command.h         |  3 +-
 source/devrelay/types/Request.cpp       | 52 +++++++---------
 source/devrelay/types/Request.h         |  4 +-
 30 files changed, 121 insertions(+), 206 deletions(-)
 delete mode 100644 source/devrelay/commands/Reset.cpp
 delete mode 100644 source/devrelay/commands/Reset.h

diff --git a/AppleWin-VS2022.vcxproj b/AppleWin-VS2022.vcxproj
index 090328646..0eabce316 100644
--- a/AppleWin-VS2022.vcxproj
+++ b/AppleWin-VS2022.vcxproj
@@ -34,7 +34,6 @@
     <ClInclude Include="source\devrelay\commands\Open.h" />
     <ClInclude Include="source\devrelay\commands\Read.h" />
     <ClInclude Include="source\devrelay\commands\ReadBlock.h" />
-    <ClInclude Include="source\devrelay\commands\Reset.h" />
     <ClInclude Include="source\devrelay\commands\Status.h" />
     <ClInclude Include="source\devrelay\commands\Write.h" />
     <ClInclude Include="source\devrelay\commands\WriteBlock.h" />
@@ -195,9 +194,6 @@
     <ClCompile Include="source\devrelay\commands\ReadBlock.cpp">
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
     </ClCompile>
-    <ClCompile Include="source\devrelay\commands\Reset.cpp">
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-    </ClCompile>
     <ClCompile Include="source\devrelay\commands\Status.cpp">
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
     </ClCompile>
diff --git a/AppleWin-VS2022.vcxproj.filters b/AppleWin-VS2022.vcxproj.filters
index 30b5de531..1f0f7bc67 100644
--- a/AppleWin-VS2022.vcxproj.filters
+++ b/AppleWin-VS2022.vcxproj.filters
@@ -282,7 +282,6 @@
     <ClCompile Include="source\devrelay\commands\Open.cpp" />
     <ClCompile Include="source\devrelay\commands\Read.cpp" />
     <ClCompile Include="source\devrelay\commands\ReadBlock.cpp" />
-    <ClCompile Include="source\devrelay\commands\Reset.cpp" />
     <ClCompile Include="source\devrelay\commands\Status.cpp" />
     <ClCompile Include="source\devrelay\commands\Write.cpp" />
     <ClCompile Include="source\devrelay\commands\WriteBlock.cpp" />
@@ -647,7 +646,6 @@
     <ClInclude Include="source\devrelay\commands\Open.h" />
     <ClInclude Include="source\devrelay\commands\Read.h" />
     <ClInclude Include="source\devrelay\commands\ReadBlock.h" />
-    <ClInclude Include="source\devrelay\commands\Reset.h" />
     <ClInclude Include="source\devrelay\commands\Status.h" />
     <ClInclude Include="source\devrelay\commands\Write.h" />
     <ClInclude Include="source\devrelay\commands\WriteBlock.h" />
diff --git a/source/SmartPortOverSlip.cpp b/source/SmartPortOverSlip.cpp
index c9b783253..d47a8109a 100644
--- a/source/SmartPortOverSlip.cpp
+++ b/source/SmartPortOverSlip.cpp
@@ -45,7 +45,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include "devrelay/commands/Open.h"
 #include "devrelay/commands/ReadBlock.h"
 #include "devrelay/commands/Read.h"
-#include "devrelay/commands/Reset.h"
 #include "devrelay/commands/Status.h"
 #include "devrelay/commands/WriteBlock.h"
 #include "devrelay/commands/Write.h"
@@ -70,7 +69,6 @@ SmartPortOverSlip::SmartPortOverSlip(const UINT slot) : Card(CT_SmartPortOverSli
 	active_instances++;
 
 	LogFileOutput("SmartPortOverSlip ctor, slot: %d\n", slot);
-	// SmartPortOverSlip::Reset(true);
 }
 
 SmartPortOverSlip::~SmartPortOverSlip()
@@ -82,15 +80,6 @@ SmartPortOverSlip::~SmartPortOverSlip()
 void SmartPortOverSlip::Reset(const bool powerCycle)
 {
 	LogFileOutput("SmartPortOverSlip Bridge Initialization, reset called\n");
-	if (powerCycle)
-	{
-		// send RESET to all devices
-		const auto connections = GetCommandListener().get_all_connections();
-		for (const auto &id_and_connection : connections)
-		{
-			reset(id_and_connection.first, id_and_connection.second);
-		}
-	}
 }
 
 void SmartPortOverSlip::handle_smartport_call()
@@ -146,38 +135,35 @@ void SmartPortOverSlip::handle_smartport_call()
 		break;
 	case CMD_READ_BLOCK:
 		// TODO: fix the fact params_loc has changed from +4 to +2
-		read_block(device_id, connection, sp_payload_loc, params_loc + 2);
+		read_block(device_id, connection, sp_payload_loc, param_count, params_loc + 2);
 		break;
 	case CMD_WRITE_BLOCK:
 		// TODO: fix the fact params_loc has changed from +4 to +2
-		write_block(device_id, connection, sp_payload_loc, params_loc + 2);
+		write_block(device_id, connection, sp_payload_loc, param_count, params_loc + 2);
 		break;
 	case CMD_FORMAT:
-		format(device_id, connection);
+		format(device_id, connection, param_count);
 		break;
 	case CMD_CONTROL:
 		// TODO: fix the fact params_loc has changed from +4 to +2
 		control(device_id, connection, sp_payload_loc, param_count, params_loc);
 		break;
 	case CMD_INIT:
-		init(device_id, connection);
+		init(device_id, connection, param_count);
 		break;
 	case CMD_OPEN:
-		open(device_id, connection);
+		open(device_id, connection, param_count);
 		break;
 	case CMD_CLOSE:
-		close(device_id, connection);
+		close(device_id, connection, param_count);
 		break;
 	case CMD_READ:
 		// TODO: fix the fact params_loc has changed from +4 to +2
-		read(device_id, connection, sp_payload_loc, params_loc + 2);
+		read(device_id, connection, sp_payload_loc, param_count, params_loc + 2);
 		break;
 	case CMD_WRITE:
 		// TODO: fix the fact params_loc has changed from +4 to +2
-		write(device_id, connection, sp_payload_loc, params_loc + 2);
-		break;
-	case CMD_RESET:
-		reset(device_id, connection);
+		write(device_id, connection, sp_payload_loc, param_count, params_loc + 2);
 		break;
 	default:
 		break;
@@ -334,7 +320,7 @@ void SmartPortOverSlip::handle_prodos_read(uint8_t drive_num, std::pair<int, int
 	auto id_connection = GetCommandListener().find_connection_with_device(device_id);
 
 	// Do a ReadRequest, and shove the 512 byte block into the required memory
-	ReadBlockRequest request(Requestor::next_request_number(), id_connection.first);
+	ReadBlockRequest request(Requestor::next_request_number(), 3, id_connection.first);
 	// $46-47 = Block Number
 	request.set_block_number_from_bytes(mem[0x46], mem[0x47], 0);
 	auto response = Requestor::send_request(request, id_connection.second.get());
@@ -360,7 +346,7 @@ void SmartPortOverSlip::handle_prodos_write(uint8_t drive_num, std::pair<int, in
 	auto device_id = drive_num == 1 ? disk_devices.first : disk_devices.second;
 	auto id_connection = GetCommandListener().find_connection_with_device(device_id);
 
-	WriteBlockRequest request(Requestor::next_request_number(), id_connection.first);
+	WriteBlockRequest request(Requestor::next_request_number(), 3, id_connection.first);
 	// $46-47 = Block Number
 	request.set_block_number_from_bytes(mem[0x46], mem[0x47], 0);
 	// put data into the request we're sending
@@ -418,9 +404,9 @@ void SmartPortOverSlip::device_count(const WORD sp_payload_loc)
 	set_processor_status(AF_ZERO);
 }
 
-void SmartPortOverSlip::read_block(const BYTE unit_number, Connection *connection, const WORD buffer_location, const WORD block_count_address)
+void SmartPortOverSlip::read_block(const BYTE unit_number, Connection *connection, const WORD buffer_location, const BYTE params_count, const WORD block_count_address)
 {
-	ReadBlockRequest request(Requestor::next_request_number(), unit_number);
+	ReadBlockRequest request(Requestor::next_request_number(), params_count, unit_number);
 	// Assume that (cmd_list_loc + 4 == block_count_address) holds 3 bytes for the block number. If it's in the payload, this is wrong and will have to be fixed.
 	request.set_block_number_from_ptr(mem, block_count_address);
 	auto response = Requestor::send_request(request, connection);
@@ -438,9 +424,9 @@ void SmartPortOverSlip::read_block(const BYTE unit_number, Connection *connectio
 	});
 }
 
-void SmartPortOverSlip::write_block(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const WORD params_loc)
+void SmartPortOverSlip::write_block(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc)
 {
-	WriteBlockRequest request(Requestor::next_request_number(), unit_number);
+	WriteBlockRequest request(Requestor::next_request_number(), params_count, unit_number);
 	// Assume that (cmd_list_loc + 4 == params_loc) holds 3 bytes for the block number. The payload contains the data to write
 	request.set_block_number_from_ptr(mem, params_loc);
 	request.set_block_data_from_ptr(mem, sp_payload_loc);
@@ -449,9 +435,9 @@ void SmartPortOverSlip::write_block(const BYTE unit_number, Connection *connecti
 	handle_simple_response<WriteBlockResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::read(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const WORD params_loc)
+void SmartPortOverSlip::read(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc)
 {
-	ReadRequest request(Requestor::next_request_number(), unit_number);
+	ReadRequest request(Requestor::next_request_number(), params_count, unit_number);
 	request.set_byte_count_from_ptr(mem, params_loc);
 	request.set_address_from_ptr(mem, params_loc + 2); // move along by byte_count size. would be better to get its size rather than hard code it here.
 	auto response = Requestor::send_request(request, connection);
@@ -472,9 +458,9 @@ void SmartPortOverSlip::read(const BYTE unit_number, Connection *connection, con
 	});
 }
 
-void SmartPortOverSlip::write(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const WORD params_loc)
+void SmartPortOverSlip::write(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc)
 {
-	WriteRequest request(Requestor::next_request_number(), unit_number);
+	WriteRequest request(Requestor::next_request_number(), params_count, unit_number);
 	request.set_byte_count_from_ptr(mem, params_loc);
 	request.set_address_from_ptr(mem, params_loc + 2); // move along by byte_count size. would be better to get its size rather than hard code it here.
 	const auto byte_count = request.get_byte_count();
@@ -489,7 +475,7 @@ void SmartPortOverSlip::status_sp(const BYTE unit_number, Connection *connection
 {
 	const BYTE status_code = mem[params_loc + 2];
 	const BYTE network_unit = params_count > 3 ? mem[params_loc + 3] : 0;
-	auto response = status(unit_number, connection, status_code, network_unit);
+	auto response = status(unit_number, connection, params_count, status_code, network_unit);
 	handle_response<StatusResponse>(std::move(response), [sp_payload_loc](const StatusResponse *sr) {
 		const auto response_size = sr->get_data().size();
 		memcpy(mem + sp_payload_loc, sr->get_data().data(), response_size);
@@ -506,16 +492,16 @@ void SmartPortOverSlip::status_sp(const BYTE unit_number, Connection *connection
 	});
 }
 
-std::unique_ptr<Response> SmartPortOverSlip::status(const BYTE unit_number, Connection *connection, const BYTE status_code, const BYTE network_unit)
+std::unique_ptr<Response> SmartPortOverSlip::status(const BYTE unit_number, Connection *connection, const BYTE params_count, const BYTE status_code, const BYTE network_unit)
 {
 	// see https://www.1000bit.it/support/manuali/apple/technotes/smpt/tn.smpt.2.html
-	const StatusRequest request(Requestor::next_request_number(), unit_number, status_code, network_unit);
+	const StatusRequest request(Requestor::next_request_number(), params_count, unit_number, status_code, network_unit);
 	return Requestor::send_request(request, connection);
 }
 
 std::unique_ptr<StatusResponse> SmartPortOverSlip::status_pd(const BYTE unit_number, Connection *connection, const BYTE status_code)
 {
-	auto response = status(unit_number, connection, status_code, 0);
+	auto response = status(unit_number, connection, status_code, 3, 0);
 
 	// Cast the Response to a StatusResponse. We need to release ownership. As ChatGPT explains:
 	/*
@@ -534,42 +520,35 @@ void SmartPortOverSlip::control(const BYTE unit_number, Connection *connection,
 	uint8_t *start_ptr = &mem[sp_payload_loc];
 	std::vector<uint8_t> payload(start_ptr, start_ptr + length);
 
-	const ControlRequest request(Requestor::next_request_number(), unit_number, control_code, network_unit, payload);
+	const ControlRequest request(Requestor::next_request_number(), params_count, unit_number, control_code, network_unit, payload);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<ControlResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::init(const BYTE unit_number, Connection *connection)
+void SmartPortOverSlip::init(const BYTE unit_number, Connection *connection, const BYTE params_count)
 {
-	const InitRequest request(Requestor::next_request_number(), unit_number);
+	const InitRequest request(Requestor::next_request_number(), params_count, unit_number);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<InitResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::open(const BYTE unit_number, Connection *connection)
+void SmartPortOverSlip::open(const BYTE unit_number, Connection *connection, const BYTE params_count)
 {
-	const OpenRequest request(Requestor::next_request_number(), unit_number);
+	const OpenRequest request(Requestor::next_request_number(), params_count, unit_number);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<OpenResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::close(const BYTE unit_number, Connection *connection)
+void SmartPortOverSlip::close(const BYTE unit_number, Connection *connection, const BYTE params_count)
 {
-	const CloseRequest request(Requestor::next_request_number(), unit_number);
+	const CloseRequest request(Requestor::next_request_number(), params_count, unit_number);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<CloseResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::reset(const BYTE unit_number, Connection *connection)
-{
-	const ResetRequest request(Requestor::next_request_number(), unit_number);
-	auto response = Requestor::send_request(request, connection);
-	handle_simple_response<ResetResponse>(std::move(response));
-}
-
-void SmartPortOverSlip::format(const BYTE unit_number, Connection *connection)
+void SmartPortOverSlip::format(const BYTE unit_number, Connection *connection, const BYTE params_count)
 {
-	const FormatRequest request(Requestor::next_request_number(), unit_number);
+	const FormatRequest request(Requestor::next_request_number(), params_count, unit_number);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<FormatResponse>(std::move(response));
 }
diff --git a/source/SmartPortOverSlip.h b/source/SmartPortOverSlip.h
index c30af6977..008a3cdb2 100644
--- a/source/SmartPortOverSlip.h
+++ b/source/SmartPortOverSlip.h
@@ -32,20 +32,20 @@ class SmartPortOverSlip : public Card
 	static void device_count(WORD sp_payload_loc);
 	void handle_smartport_call();
 	void handle_prodos_call();
-	void control(BYTE unit_number, Connection *connection, WORD sp_payload_loc, const BYTE params_count, const WORD params_loc);
-	void init(BYTE unit_number, Connection *connection);
-	void open(BYTE unit_number, Connection *connection);
-	void close(BYTE unit_number, Connection *connection);
-	void format(BYTE unit_number, Connection *connection);
-	void reset(BYTE unit_number, Connection *connection);
-	void read_block(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
-	void write_block(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
-	void read(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
-	void write(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
-
-	std::unique_ptr<Response> status(BYTE unit_number, Connection *connection, const BYTE status_code, const BYTE network_unit);
-	std::unique_ptr<StatusResponse> status_pd(const BYTE unit_number, Connection *connection, const BYTE status_code);
-	void status_sp(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc);
+	void control(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
+	void init(BYTE unit_number, Connection *connection, BYTE params_count);
+	void open(BYTE unit_number, Connection *connection, BYTE params_count);
+	void close(BYTE unit_number, Connection *connection, BYTE params_count);
+	void format(BYTE unit_number, Connection *connection, BYTE params_count);
+	void reset(BYTE unit_number, Connection *connection, BYTE params_count);
+	void read_block(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
+	void write_block(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
+	void read(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
+	void write(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
+
+	std::unique_ptr<Response> status(BYTE unit_number, Connection *connection, BYTE params_count, BYTE status_code, BYTE network_unit);
+	std::unique_ptr<StatusResponse> status_pd(BYTE unit_number, Connection *connection, BYTE status_code);
+	void status_sp(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE params_count, WORD params_loc);
 
 	void handle_prodos_status(uint8_t drive_num, std::pair<int, int> disk_devices);
 	void handle_prodos_read(uint8_t drive_num, std::pair<int, int> disk_devices);
diff --git a/source/devrelay/commands/Close.cpp b/source/devrelay/commands/Close.cpp
index 9d990af40..71dcc3fdd 100644
--- a/source/devrelay/commands/Close.cpp
+++ b/source/devrelay/commands/Close.cpp
@@ -3,14 +3,16 @@
 #include <iostream>
 #include "Close.h"
 
-CloseRequest::CloseRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_CLOSE, device_id) {}
+CloseRequest::CloseRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_CLOSE, param_count, device_id) {}
 
 std::vector<uint8_t> CloseRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Close.h b/source/devrelay/commands/Close.h
index 4e179b87a..bb41691d8 100644
--- a/source/devrelay/commands/Close.h
+++ b/source/devrelay/commands/Close.h
@@ -9,7 +9,7 @@
 class CloseRequest : public Request
 {
 public:
-	CloseRequest(uint8_t request_sequence_number, uint8_t device_id);
+	CloseRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	void create_command(uint8_t* output_data) const override;
diff --git a/source/devrelay/commands/Control.cpp b/source/devrelay/commands/Control.cpp
index 1b39307ca..f6d1d1eef 100644
--- a/source/devrelay/commands/Control.cpp
+++ b/source/devrelay/commands/Control.cpp
@@ -3,8 +3,8 @@
 #include <iostream>
 #include "Control.h"
 
-ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data)
-	: Request(request_sequence_number, CMD_CONTROL, device_id), control_code_(control_code), network_unit_(network_unit), data_(std::move(data))
+ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data)
+	: Request(request_sequence_number, CMD_CONTROL, param_count, device_id), control_code_(control_code), network_unit_(network_unit), data_(std::move(data))
 {
 }
 
@@ -13,9 +13,12 @@ std::vector<uint8_t> ControlRequest::serialize() const
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.push_back(this->get_control_code());
 	request_data.push_back(this->get_network_unit());
+	request_data.resize(11);
 	request_data.insert(request_data.end(), get_data().begin(), get_data().end());
 	return request_data;
 }
diff --git a/source/devrelay/commands/Control.h b/source/devrelay/commands/Control.h
index c4cf25dc3..95fc0d71e 100644
--- a/source/devrelay/commands/Control.h
+++ b/source/devrelay/commands/Control.h
@@ -9,7 +9,7 @@
 class ControlRequest : public Request
 {
 public:
-	ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data);
+	ControlRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
diff --git a/source/devrelay/commands/Format.cpp b/source/devrelay/commands/Format.cpp
index 06a8929f2..8935491d9 100644
--- a/source/devrelay/commands/Format.cpp
+++ b/source/devrelay/commands/Format.cpp
@@ -3,14 +3,16 @@
 #include <iostream>
 #include "Format.h"
 
-FormatRequest::FormatRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_FORMAT, device_id) {}
+FormatRequest::FormatRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_FORMAT, param_count, device_id) {}
 
 std::vector<uint8_t> FormatRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Format.h b/source/devrelay/commands/Format.h
index ca3f24ed8..1b56e38d2 100644
--- a/source/devrelay/commands/Format.h
+++ b/source/devrelay/commands/Format.h
@@ -9,7 +9,7 @@
 class FormatRequest : public Request
 {
 public:
-	FormatRequest(const uint8_t request_sequence_number, const uint8_t device_id);
+	FormatRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	void create_command(uint8_t* output_data) const override;
diff --git a/source/devrelay/commands/Init.cpp b/source/devrelay/commands/Init.cpp
index 071c21ce8..278b8cf0a 100644
--- a/source/devrelay/commands/Init.cpp
+++ b/source/devrelay/commands/Init.cpp
@@ -3,14 +3,16 @@
 #include <iostream>
 #include "Init.h"
 
-InitRequest::InitRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_INIT, device_id) {}
+InitRequest::InitRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_INIT, param_count, device_id) {}
 
 std::vector<uint8_t> InitRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Init.h b/source/devrelay/commands/Init.h
index b8b17e818..4a6b8b1dd 100644
--- a/source/devrelay/commands/Init.h
+++ b/source/devrelay/commands/Init.h
@@ -9,7 +9,7 @@
 class InitRequest : public Request
 {
 public:
-	InitRequest(uint8_t request_sequence_number, uint8_t device_id);
+	InitRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	void create_command(uint8_t* output_data) const override;
diff --git a/source/devrelay/commands/Open.cpp b/source/devrelay/commands/Open.cpp
index bf8a39fc0..90d35be01 100644
--- a/source/devrelay/commands/Open.cpp
+++ b/source/devrelay/commands/Open.cpp
@@ -3,14 +3,16 @@
 #include <iostream>
 #include "Open.h"
 
-OpenRequest::OpenRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_OPEN, device_id) {}
+OpenRequest::OpenRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_OPEN, param_count, device_id) {}
 
 std::vector<uint8_t> OpenRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Open.h b/source/devrelay/commands/Open.h
index 25685464a..e56eaeb6b 100644
--- a/source/devrelay/commands/Open.h
+++ b/source/devrelay/commands/Open.h
@@ -9,7 +9,7 @@
 class OpenRequest : public Request
 {
 public:
-	OpenRequest(uint8_t request_sequence_number, uint8_t device_id);
+	OpenRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	void create_command(uint8_t* output_data) const override;
diff --git a/source/devrelay/commands/Read.cpp b/source/devrelay/commands/Read.cpp
index 72b7ab02f..0155a05ff 100644
--- a/source/devrelay/commands/Read.cpp
+++ b/source/devrelay/commands/Read.cpp
@@ -3,16 +3,19 @@
 #include <iostream>
 #include "Read.h"
 
-ReadRequest::ReadRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_READ, device_id), byte_count_(), address_() {}
+ReadRequest::ReadRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_READ, param_count, device_id), byte_count_(), address_() {}
 
 std::vector<uint8_t> ReadRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.insert(request_data.end(), get_byte_count().begin(), get_byte_count().end());
 	request_data.insert(request_data.end(), get_address().begin(), get_address().end());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Read.h b/source/devrelay/commands/Read.h
index 8a0b64ff7..dea481f75 100644
--- a/source/devrelay/commands/Read.h
+++ b/source/devrelay/commands/Read.h
@@ -12,7 +12,7 @@
 class ReadRequest : public Request
 {
 public:
-	ReadRequest(uint8_t request_sequence_number, uint8_t device_id);
+	ReadRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
diff --git a/source/devrelay/commands/ReadBlock.cpp b/source/devrelay/commands/ReadBlock.cpp
index 326329e1d..2e51a38a0 100644
--- a/source/devrelay/commands/ReadBlock.cpp
+++ b/source/devrelay/commands/ReadBlock.cpp
@@ -3,15 +3,18 @@
 #include "ReadBlock.h"
 #include <iostream>
 
-ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_READ_BLOCK, device_id), block_number_{} {}
+ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_READ_BLOCK, param_count, device_id), block_number_{} {}
 
 std::vector<uint8_t> ReadBlockRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.insert(request_data.end(), block_number_.begin(), block_number_.end());
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/ReadBlock.h b/source/devrelay/commands/ReadBlock.h
index 6561f88f2..01e00f40a 100644
--- a/source/devrelay/commands/ReadBlock.h
+++ b/source/devrelay/commands/ReadBlock.h
@@ -11,7 +11,7 @@
 class ReadBlockRequest : public Request
 {
 public:
-	ReadBlockRequest(uint8_t request_sequence_number, uint8_t device_id);
+	ReadBlockRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	const std::array<uint8_t, 3> &get_block_number() const;
diff --git a/source/devrelay/commands/Reset.cpp b/source/devrelay/commands/Reset.cpp
deleted file mode 100644
index 85ef963c1..000000000
--- a/source/devrelay/commands/Reset.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifdef DEV_RELAY_SLIP
-
-#include <iostream>
-#include "Reset.h"
-
-ResetRequest::ResetRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_RESET, device_id) {}
-
-std::vector<uint8_t> ResetRequest::serialize() const
-{
-	std::vector<uint8_t> request_data;
-	request_data.push_back(this->get_request_sequence_number());
-	request_data.push_back(this->get_command_number());
-	request_data.push_back(this->get_device_id());
-	return request_data;
-}
-
-std::unique_ptr<Response> ResetRequest::deserialize(const std::vector<uint8_t> &data) const
-{
-	if (data.size() < 2)
-	{
-		std::cerr << "Not enough data to deserialize ResetResponse" << std::endl;
-		return nullptr;
-	}
-
-	auto response = std::make_unique<ResetResponse>(data[0], data[1]);
-	return response;
-}
-
-void ResetRequest::create_command(uint8_t* cmd_data) const
-{
-	init_command(cmd_data);
-}
-
-std::unique_ptr<Response> ResetRequest::create_response(uint8_t source, uint8_t status, const uint8_t* data, uint16_t num) const
-{
-	std::unique_ptr<ResetResponse> response = std::make_unique<ResetResponse>(get_request_sequence_number(), status);
-	return response;
-}
-
-ResetResponse::ResetResponse(const uint8_t request_sequence_number, const uint8_t status) : Response(request_sequence_number, status) {}
-
-std::vector<uint8_t> ResetResponse::serialize() const
-{
-	std::vector<uint8_t> data;
-	data.push_back(this->get_request_sequence_number());
-	data.push_back(this->get_status());
-	return data;
-}
-
-
-#endif
diff --git a/source/devrelay/commands/Reset.h b/source/devrelay/commands/Reset.h
deleted file mode 100644
index 51e532a0f..000000000
--- a/source/devrelay/commands/Reset.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-
-#include "../types/Request.h"
-#include "../types/Response.h"
-
-class ResetRequest : public Request
-{
-public:
-	ResetRequest(uint8_t request_sequence_number, uint8_t device_id);
-	std::vector<uint8_t> serialize() const override;
-	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
-	void create_command(uint8_t* output_data) const override;
-	void copy_payload(uint8_t* data) const override {}
-	size_t payload_size() const override { return 0; };
-	std::unique_ptr<Response> create_response(uint8_t source, uint8_t status, const uint8_t* data, uint16_t num) const override;
-};
-
-class ResetResponse : public Response
-{
-public:
-	explicit ResetResponse(uint8_t request_sequence_number, uint8_t status);
-	std::vector<uint8_t> serialize() const override;
-};
diff --git a/source/devrelay/commands/Status.cpp b/source/devrelay/commands/Status.cpp
index 52eaf008a..b6a5b4cfc 100644
--- a/source/devrelay/commands/Status.cpp
+++ b/source/devrelay/commands/Status.cpp
@@ -5,7 +5,7 @@
 
 #include "Status.h"
 
-StatusRequest::StatusRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t status_code, const uint8_t network_unit) : Request(request_sequence_number, CMD_STATUS, device_id), status_code_(status_code), network_unit_(network_unit)
+StatusRequest::StatusRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id, const uint8_t status_code, const uint8_t network_unit) : Request(request_sequence_number, CMD_STATUS, param_count, device_id), status_code_(status_code), network_unit_(network_unit)
 {
 }
 
@@ -14,10 +14,12 @@ std::vector<uint8_t> StatusRequest::serialize() const
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.push_back(this->get_status_code());
 	request_data.push_back(this->get_network_unit());
-
+	request_data.resize(11);
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/Status.h b/source/devrelay/commands/Status.h
index ebaa33af8..b012b1f9b 100644
--- a/source/devrelay/commands/Status.h
+++ b/source/devrelay/commands/Status.h
@@ -9,7 +9,7 @@
 class StatusRequest : public Request
 {
 public:
-	StatusRequest(uint8_t request_sequence_number, uint8_t device_id, uint8_t status_code, uint8_t network_unit);
+	StatusRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id, uint8_t status_code, uint8_t network_unit);
 	virtual std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
diff --git a/source/devrelay/commands/Write.cpp b/source/devrelay/commands/Write.cpp
index 68599238c..0fa5a9ecf 100644
--- a/source/devrelay/commands/Write.cpp
+++ b/source/devrelay/commands/Write.cpp
@@ -3,16 +3,19 @@
 #include <iostream>
 #include "Write.h"
 
-WriteRequest::WriteRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_WRITE, device_id), byte_count_(), address_() {}
+WriteRequest::WriteRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_WRITE, param_count, device_id), byte_count_(), address_() {}
 
 std::vector<uint8_t> WriteRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.insert(request_data.end(), get_byte_count().begin(), get_byte_count().end());
 	request_data.insert(request_data.end(), get_address().begin(), get_address().end());
+	request_data.resize(11);
 	request_data.insert(request_data.end(), get_data().begin(), get_data().end());
 	return request_data;
 }
diff --git a/source/devrelay/commands/Write.h b/source/devrelay/commands/Write.h
index a114959c4..3432256ee 100644
--- a/source/devrelay/commands/Write.h
+++ b/source/devrelay/commands/Write.h
@@ -11,7 +11,7 @@
 class WriteRequest : public Request
 {
 public:
-	WriteRequest(const uint8_t request_sequence_number, const uint8_t device_id);
+	WriteRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
diff --git a/source/devrelay/commands/WriteBlock.cpp b/source/devrelay/commands/WriteBlock.cpp
index a76d8d962..59b21a4b5 100644
--- a/source/devrelay/commands/WriteBlock.cpp
+++ b/source/devrelay/commands/WriteBlock.cpp
@@ -4,17 +4,19 @@
 #include <iostream>
 #include "WriteBlock.h"
 
-WriteBlockRequest::WriteBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_WRITE_BLOCK, device_id), block_number_{}, block_data_{} {}
+WriteBlockRequest::WriteBlockRequest(const uint8_t request_sequence_number, const uint8_t param_count, const uint8_t device_id) : Request(request_sequence_number, CMD_WRITE_BLOCK, param_count, device_id), block_number_{}, block_data_{} {}
 
 std::vector<uint8_t> WriteBlockRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
+	request_data.push_back(this->get_param_count());
 	request_data.push_back(this->get_device_id());
+	request_data.resize(6);
 	request_data.insert(request_data.end(), block_number_.begin(), block_number_.end());
+	request_data.resize(11);
 	request_data.insert(request_data.end(), block_data_.begin(), block_data_.end());
-
 	return request_data;
 }
 
diff --git a/source/devrelay/commands/WriteBlock.h b/source/devrelay/commands/WriteBlock.h
index 7c5b6ede6..00951b893 100644
--- a/source/devrelay/commands/WriteBlock.h
+++ b/source/devrelay/commands/WriteBlock.h
@@ -11,7 +11,7 @@
 class WriteBlockRequest : public Request
 {
 public:
-	WriteBlockRequest(uint8_t request_sequence_number, uint8_t device_id);
+	WriteBlockRequest(uint8_t request_sequence_number, uint8_t param_count, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	const std::array<uint8_t, 3> &get_block_number() const;
diff --git a/source/devrelay/service/Listener.cpp b/source/devrelay/service/Listener.cpp
index 822fc7634..69b641ebf 100644
--- a/source/devrelay/service/Listener.cpp
+++ b/source/devrelay/service/Listener.cpp
@@ -195,7 +195,7 @@ void Listener::create_connection(unsigned int socket)
 	while (still_scanning && connection_info_map_.size() < 254)
 	{
 		LogFileOutput("SmartPortOverSlip listener sending request for device_id: %d\n", device_id);
-		InitRequest request(Requestor::next_request_number(), device_id);
+		InitRequest request(Requestor::next_request_number(), 1, device_id);
 		const auto response = Requestor::send_request(request, conn.get());
 		const auto init_response = dynamic_cast<InitResponse *>(response.get());
 		if (init_response == nullptr)
@@ -294,7 +294,7 @@ std::pair<int, int> Listener::first_two_disk_devices(std::function<bool(const st
 		const uint8_t unit_number = id_and_connection.first;
 
 		// DIB request to get information block. We need the device id the target understands here, not the unit_number from the ids maintained by host
-		const StatusRequest request(Requestor::next_request_number(), id_and_connection.first, 3, 0); // no network unit here
+		const StatusRequest request(Requestor::next_request_number(), 3, id_and_connection.first, 3, 0); // no network unit here
 
 		std::unique_ptr<Response> response = Requestor::send_request(request, id_and_connection.second);
 
diff --git a/source/devrelay/types/Command.h b/source/devrelay/types/Command.h
index 9167f66ba..09a691169 100644
--- a/source/devrelay/types/Command.h
+++ b/source/devrelay/types/Command.h
@@ -14,8 +14,7 @@ enum
 	CMD_OPEN = 6,
 	CMD_CLOSE = 7,
 	CMD_READ = 8,
-	CMD_WRITE = 9,
-	CMD_RESET = 10
+	CMD_WRITE = 9
 };
 
 class Command
diff --git a/source/devrelay/types/Request.cpp b/source/devrelay/types/Request.cpp
index 2ef756fa4..df2adb810 100644
--- a/source/devrelay/types/Request.cpp
+++ b/source/devrelay/types/Request.cpp
@@ -11,15 +11,16 @@
 #include "../commands/Open.h"
 #include "../commands/Read.h"
 #include "../commands/ReadBlock.h"
-#include "../commands/Reset.h"
 #include "../commands/Status.h"
 #include "../commands/Write.h"
 #include "../commands/WriteBlock.h"
 
-Request::Request(const uint8_t request_sequence_number, const uint8_t command_number, const uint8_t device_id) : Command(request_sequence_number), command_number_(command_number), device_id_(device_id) {}
+Request::Request(const uint8_t request_sequence_number, const uint8_t command_number, const uint8_t param_count, const uint8_t device_id) : Command(request_sequence_number), command_number_(command_number), param_count_(param_count), device_id_(device_id) {}
 
 uint8_t Request::get_command_number() const { return command_number_; }
 
+uint8_t Request::get_param_count() const { return param_count_; }
+
 uint8_t Request::get_device_id() const { return device_id_; }
 
 // All Request subclasses when writing to the command data will first initialise it and set command value
@@ -35,76 +36,69 @@ std::unique_ptr<Request> Request::from_packet(const std::vector<uint8_t>& packet
   switch(command) {
 
   case CMD_STATUS: {
-    uint8_t network_unit = packet.size() > 4 ? packet[4] : 0;
-    request = std::make_unique<StatusRequest>(packet[0], packet[2], packet[3], network_unit);
+    request = std::make_unique<StatusRequest>(packet[0], packet[2], packet[3], packet[6], packet[7]);
     break;
   }
 
   case CMD_CONTROL: {
-    uint8_t network_unit = packet.size() > 4 ? packet[4] : 0;
-    // +7 = 3 for "header", 1 for control code, 1 for network unit, 2 for length bytes we need to skip
-    std::vector<uint8_t> payload(packet.begin() + 7, packet.end());
-    request = std::make_unique<ControlRequest>(packet[0], packet[2], packet[3], network_unit, payload);
+    // +2 for control list length bytes we need to skip
+    std::vector<uint8_t> payload(packet.begin() + 11+2, packet.end());
+    request = std::make_unique<ControlRequest>(packet[0], packet[2], packet[3], packet[6], packet[7], payload);
     break;
   }
 
   case CMD_READ_BLOCK: {
-    auto readBlockRequest = std::make_unique<ReadBlockRequest>(packet[0], packet[2]);
-    readBlockRequest->set_block_number_from_ptr(packet.data(), 3);
+    auto readBlockRequest = std::make_unique<ReadBlockRequest>(packet[0], packet[2], packet[3]);
+    readBlockRequest->set_block_number_from_ptr(packet.data(), 6);
     request = std::move(readBlockRequest);
     break;
   }
 
   case CMD_WRITE_BLOCK: {
-    auto writeBlockRequest = std::make_unique<WriteBlockRequest>(packet[0], packet[2]);
-    writeBlockRequest->set_block_number_from_ptr(packet.data(), 3);
-    writeBlockRequest->set_block_data_from_ptr(packet.data(), 6);
+    auto writeBlockRequest = std::make_unique<WriteBlockRequest>(packet[0], packet[2], packet[3]);
+    writeBlockRequest->set_block_number_from_ptr(packet.data(), 6);
+    writeBlockRequest->set_block_data_from_ptr(packet.data(), 11);
 		request = std::move(writeBlockRequest);
     break;
   }
 
   case CMD_FORMAT: {
-    request = std::make_unique<FormatRequest>(packet[0], packet[2]);
+    request = std::make_unique<FormatRequest>(packet[0], packet[2], packet[3]);
     break;
   }
 
   case CMD_INIT: {
-    request = std::make_unique<InitRequest>(packet[0], packet[2]);
+    request = std::make_unique<InitRequest>(packet[0], packet[2], packet[3]);
     break;
   }
 
   case CMD_OPEN: {
-    request = std::make_unique<OpenRequest>(packet[0], packet[2]);
+    request = std::make_unique<OpenRequest>(packet[0], packet[2], packet[3]);
     break;
   }
 
   case CMD_CLOSE: {
-    request = std::make_unique<CloseRequest>(packet[0], packet[2]);
+    request = std::make_unique<CloseRequest>(packet[0], packet[2], packet[3]);
     break;
   }
 
   case CMD_READ: {
-    auto readRequest = std::make_unique<ReadRequest>(packet[0], packet[2]);
-    readRequest->set_byte_count_from_ptr(packet.data(), 3);
-    readRequest->set_address_from_ptr(packet.data(), 5);
+    auto readRequest = std::make_unique<ReadRequest>(packet[0], packet[2], packet[3]);
+    readRequest->set_byte_count_from_ptr(packet.data(), 6);
+    readRequest->set_address_from_ptr(packet.data(), 8);
 		request = std::move(readRequest);
     break;
   }
 
   case CMD_WRITE: {
-    auto writeRequest = std::make_unique<WriteRequest>(packet[0], packet[2]);
-    writeRequest->set_byte_count_from_ptr(packet.data(), 3);
-    writeRequest->set_address_from_ptr(packet.data(), 5);
-    writeRequest->set_data_from_ptr(packet.data(), 8, packet.size() - 8);
+    auto writeRequest = std::make_unique<WriteRequest>(packet[0], packet[2], packet[3]);
+    writeRequest->set_byte_count_from_ptr(packet.data(), 6);
+    writeRequest->set_address_from_ptr(packet.data(), 8);
+    writeRequest->set_data_from_ptr(packet.data(), 11, packet.size() - 11);
     request = std::move(writeRequest);
 		break;
   }
 
-  case CMD_RESET: {
-    request = std::make_unique<ResetRequest>(packet[0], packet[2]);
-    break;
-  }
-
   default: {
     std::ostringstream oss;
     oss << "Unknown command: %d" << command;
diff --git a/source/devrelay/types/Request.h b/source/devrelay/types/Request.h
index e623cc39b..d4b033b86 100644
--- a/source/devrelay/types/Request.h
+++ b/source/devrelay/types/Request.h
@@ -13,12 +13,13 @@ class Response;
 class Request : public Command
 {
 public:
-	Request(const uint8_t request_sequence_number, const uint8_t command_number, const uint8_t device_id);
+	Request(const uint8_t request_sequence_number, const uint8_t command_number, const uint8_t param_count, const uint8_t device_id);
 
 	std::vector<uint8_t> serialize() const override = 0;
 	virtual std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const = 0;
 
 	uint8_t get_command_number() const;
+	uint8_t get_param_count() const;
 	uint8_t get_device_id() const;
 
 	// Create the subclass specific Request type from the packet data
@@ -37,5 +38,6 @@ class Request : public Command
 
 private:
 	uint8_t command_number_ = 0;
+	uint8_t param_count_ = 0;
 	uint8_t device_id_ = 0;
 };

From e78a290ce5df2c111dcc32513305ba382561f948 Mon Sep 17 00:00:00 2001
From: Oliver Schmidt <ol.sc@web.de>
Date: Wed, 29 Jan 2025 18:20:16 +0100
Subject: [PATCH 2/2] Removed SP-over-SLIP Reset command from Linux build.

---
 source/CMakeLists.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 6223dd4f4..8b803b83f 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -137,7 +137,6 @@ set(SOURCE_FILES
   devrelay/commands/Open.cpp
   devrelay/commands/ReadBlock.cpp
   devrelay/commands/Read.cpp
-  devrelay/commands/Reset.cpp
   devrelay/commands/Status.cpp
   devrelay/commands/WriteBlock.cpp
   devrelay/commands/Write.cpp
@@ -255,7 +254,6 @@ set(HEADER_FILES
   devrelay/commands/Open.h
   devrelay/commands/ReadBlock.h
   devrelay/commands/Read.h
-  devrelay/commands/Reset.h
   devrelay/commands/Status.h
   devrelay/commands/WriteBlock.h
   devrelay/commands/Write.h