src/serial/RS232Raw.cc at main · doomsdayone/openmsx

◆ main openmsx / src / serial / RS232Raw.cc

9.8 KiB · C++ · last changed chore(): initial commit 1 month ago source blame history raw

#include "RS232Raw.hh"

#include "RS232Connector.hh"

#include "CliComm.hh"
#include "CommandController.hh"
#include "EventDistributor.hh"
#include "ImGuiCpp.hh"
#include "ImGuiUtils.hh"
#include "PlugException.hh"
#include "Scheduler.hh"
#include "serialize.hh"

#include "checked_cast.hh"

#include <imgui.h>

#include <cassert>
#include <chrono>
#include <string>
#include <vector>

namespace openmsx {

RS232Raw::RS232Raw(EventDistributor& eventDistributor_,
                   Scheduler& scheduler_,
                   CommandController& commandController)
	: eventDistributor(eventDistributor_), scheduler(scheduler_)
	, cliComm(commandController.getCliComm())
	, rs232RawPortSetting(
	        commandController, "rs232-raw-port",
	        "Serial port name for RS232 raw pluggable",
#ifdef _WIN32
	        "COM1"
#else
	        "/dev/ttyS0"
#endif
        )
{
	eventDistributor.registerEventListener(EventType::RS232_RAW, *this);
	rs232RawPortSetting.attach(*this);
}

RS232Raw::~RS232Raw()
{
	tearDown();
	rs232RawPortSetting.detach(*this);
	eventDistributor.unregisterEventListener(EventType::RS232_RAW, *this);
}

static serial::SerialParams buildParamsImpl(unsigned baud, SerialDataInterface::DataBits dataBits, SerialDataInterface::StopBits stopBits, bool parityEnabled, SerialDataInterface::Parity parity)
{
	serial::SerialParams p;
	p.baudRate = baud;
	p.dataBits = static_cast<int>(dataBits);
	switch (stopBits) {
	using enum SerialDataInterface::StopBits;
	case S1:   p.stopBits = 1; break;
	case S1_5: p.stopBits = 1; break;
	case S2:   p.stopBits = 2; break;
	default:   p.stopBits = 1; break;
	}
	if (parityEnabled) {
		p.parity = (parity == SerialDataInterface::Parity::ODD) ? 1 : 2;
	} else {
		p.parity = 0;
	}
	return p;
}

void RS232Raw::applyParams()
{
#ifdef _WIN32
	if (!handle && !thread.joinable()) return;
	tearDown();
	{
		std::scoped_lock lock(mutex);
		queue.clear();
	}
	auto portName = rs232RawPortSetting.getString();
	if (portName.empty()) return;
	setup(std::string(portName), buildParams());
#else
	// POSIX: nothing to reconfigure while the worker is still opening the
	// port (the open uses the parameters it was spawned with). Also
	// deliberately no tear down + reopen here: that would re-assert the
	// modem lines and might cause misbehavior on the connected device due
	// to the unexpected state change.
	if (!handle) return;
	auto p = buildParams();
	(void)handle->set_params(p);
	(void)handle->set_dtr(DTR);
	(void)handle->set_rts(RTS);
#endif
}

// Pluggable
void RS232Raw::plugHelper(Connector& connector_, EmuTime /*time*/)
{
	auto portName = rs232RawPortSetting.getString();
	if (portName.empty()) {
		throw PlugException("No serial port specified");
	}

	auto& rs232Connector = checked_cast<RS232Connector&>(connector_);
	directConn = &rs232Connector;

	// Initialize the modem-line state BEFORE the worker opens the port, so
	// the lines are applied in their final state (DTR/RTS asserted) and never
	// toggle afterwards: a transition resets ESP32-style auto-reset circuits.
	DCD = false;
	RI  = false;
	CTS = false;
	DSR = true;
	DTR = true;
	RTS = true;

	setup(std::string(portName), buildParams());

	rs232Connector.setDataBits(currentDataBits);
	rs232Connector.setStopBits(currentStopBits);
	rs232Connector.setParityBit(currentParityEnabled, currentParity);

	setConnector(&connector_);
}

void RS232Raw::unplugHelper(EmuTime /*time*/)
{
	tearDown();
	directConn = nullptr;
}

zstring_view RS232Raw::getName() const
{
	return "rs232-raw";
}

zstring_view RS232Raw::getDescription() const
{
	return "RS232 raw serial port pluggable. Connects the RS232 port to "
	       "a host serial port, selected with the 'rs232-raw-port' setting.";
}

void RS232Raw::handleImGuiExtraMenuItems()
{
	if (auto cur = rs232RawPortSetting.getString(); cur != currentPort) {
		ports = serial::list_ports();
		currentPort = std::string(cur);
	}
	im::Indent([&]{
		ImGui::SetNextItemWidth(ImGui::GetFontSize() * 12.0f);
		im::Combo("##rs232-raw-port", currentPort.c_str(), [this]{
			for (const auto& p : ports) {
				bool selected = (p == currentPort);
				if (ImGui::Selectable(p.c_str(), selected)) {
					rs232RawPortSetting.setString(p);
					currentPort = p;
				}
				if (selected) {
					ImGui::SetItemDefaultFocus();
				}
			}
		});
		simpleToolTip("Select the host serial port for RS232 raw");
		ImGui::SameLine();
		if (ImGui::SmallButton("Refresh")) {
			ports = serial::list_ports();
		}
	});
}

// Stops the worker thread and closes the port. Safe to call in any state.
void RS232Raw::tearDown()
{
	if (thread.joinable()) {
		poller->abort();
	}
	handle.reset(); // closes the port: unblocks the worker's pending read
	if (thread.joinable()) {
		thread.join();
	}
	poller.reset();
}

// Spawns the worker thread: it opens the port (retrying briefly) and then
// runs the read loop. The retry delays sleep the worker thread, never the
// emulation thread.
void RS232Raw::setup(std::string portName, serial::SerialParams params)
{
	poller.emplace();
	thread = std::thread([this, pn = std::move(portName), pm = std::move(params)]() mutable {
		openAndRun(std::move(pn), std::move(pm));
	});
}

serial::SerialParams RS232Raw::buildParams() const
{
	return buildParamsImpl(currentBaud, currentDataBits, currentStopBits,
	                       currentParityEnabled, currentParity);
}

// Opens the port (retrying briefly) and then runs the read loop. Runs on
// the worker thread: the retry delays sleep this host thread, never the
// emulation thread (a just-closed Windows COM port can stay owned by the
// OS for a few ms, so an immediate reopen can transiently fail).
void RS232Raw::openAndRun(std::string portName, serial::SerialParams params)
{
	auto h = serial::open(portName, params);
	for (int attempt = 0; !h.has_value() && attempt < 4 && !poller->aborted();
	     ++attempt) {
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
		h = serial::open(portName, params);
	}
	if (poller->aborted()) {
		return; // unplugged while opening: drop the port (h closes it)
	}
	if (!h.has_value()) {
		cliComm.printWarning("Failed to open serial port ", portName, ": ",
		                     serial::to_string(h.error()));
		return;
	}
	(void)h->set_params(params);
	(void)h->set_dtr(DTR);
	(void)h->set_rts(RTS);
	handle = std::move(*h);
	run();
}

void RS232Raw::run()
{
	auto* conn = directConn;
	bool direct = conn && conn->directByteDelivery();

	while (handle && !poller->aborted()) {
#ifndef _WIN32
		if (poller->poll(handle->native_handle())) {
			break;
		}
#endif

		uint8_t b;
		auto r = handle->read(std::span<uint8_t>(&b, 1));
		if (!r.has_value()) {
			handle.reset();
		} else if (*r == 0) {
#ifdef _WIN32
			std::this_thread::sleep_for(std::chrono::milliseconds(1));
#endif
		} else if (direct) {
			conn->recvByte(b, EmuTime::zero());
		} else {
			assert(isPluggedIn());
			{
				std::scoped_lock lock(mutex);
				queue.push_back(b);
			}
			eventDistributor.distributeEvent(Rs232RawEvent());
		}
	}
}

// input
void RS232Raw::signal(EmuTime time)
{
	if (!handle) return;

	auto* conn = checked_cast<RS232Connector*>(getConnector());

	if (!conn->acceptsData()) {
		return;
	}

	if (!conn->ready() || !RTS) return;

	std::scoped_lock lock(mutex);
	if (queue.empty()) return;
	auto b = queue.pop_front();
	conn->recvByte(b, time);
}

// EventListener
bool RS232Raw::signalEvent(const Event& /*event*/)
{
	if (isPluggedIn()) {
		signal(scheduler.getCurrentTime());
	} else {
		std::scoped_lock lock(mutex);
		queue.clear();
	}
	return false;
}

// output
void RS232Raw::recvByte(uint8_t value, EmuTime /*time*/)
{
	if (!handle) return;

	if (!handle->write(std::span<const uint8_t>(&value, 1)).has_value()) {
		handle.reset();
	}
}

// Control lines

std::optional<bool> RS232Raw::getDSR(EmuTime /*time*/) const
{
	if (!handle) return {};
	return DSR.load();
}

std::optional<bool> RS232Raw::getCTS(EmuTime /*time*/) const
{
	if (!handle) return {};
	return CTS.load();
}

std::optional<bool> RS232Raw::getDCD(EmuTime /*time*/) const
{
	if (!handle) return {};
	return DCD.load();
}

std::optional<bool> RS232Raw::getRI(EmuTime /*time*/) const
{
	if (!handle) return {};
	return RI.load();
}

void RS232Raw::setDTR(bool status, EmuTime /*time*/)
{
	if (DTR == status) return;
	DTR = status;
	if (handle) {
		(void)handle->set_dtr(status);
	}
}

void RS232Raw::setRTS(bool status, EmuTime /*time*/)
{
	if (RTS == status) return;
	RTS = status;
	if (handle) {
		(void)handle->set_rts(status);
		if (RTS) {
			std::scoped_lock lock(mutex);
			if (!queue.empty()) {
				eventDistributor.distributeEvent(Rs232RawEvent());
			}
		}
	}
}

// Serial params

void RS232Raw::setDataBits(DataBits bits)
{
	if (currentDataBits.load() == bits) return;
	currentDataBits.store(bits);
	applyParams();
}

void RS232Raw::setStopBits(StopBits bits)
{
	if (currentStopBits.load() == bits) return;
	currentStopBits.store(bits);
	applyParams();
}

void RS232Raw::setParityBit(bool enable, Parity parity)
{
	if (currentParityEnabled.load() == enable && currentParity.load() == parity) return;
	currentParityEnabled.store(enable);
	currentParity.store(parity);
	applyParams();
}

void RS232Raw::setBaudRate(unsigned baud)
{
	if (currentBaud.load() == baud) return;
	currentBaud.store(baud);
	applyParams();
}

void RS232Raw::update(const Setting& /*setting*/) noexcept
{
	tearDown();
	{
		std::scoped_lock lock(mutex);
		queue.clear();
	}

	auto portName = rs232RawPortSetting.getString();
	if (!portName.empty() && isPluggedIn()) {
		setup(std::string(portName), buildParams());
	}
}

template<typename Archive>
void RS232Raw::serialize(Archive& /*ar*/, unsigned /*version*/)
{
	if constexpr (Archive::IS_LOADER) {
		if (!isPluggedIn()) return;

		auto* conn = dynamic_cast<RS232Connector*>(getConnector());
		if (!conn) return;
		directConn = conn;

		auto portName = rs232RawPortSetting.getString();
		if (portName.empty()) return;

		setup(std::string(portName), buildParams());
	}
}
INSTANTIATE_SERIALIZE_METHODS(RS232Raw);
REGISTER_POLYMORPHIC_INITIALIZER(Pluggable, RS232Raw, "RS232Raw");

} // namespace openmsx

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	#include "RS232Raw.hh"
2
3	#include "RS232Connector.hh"
4
5	#include "CliComm.hh"
6	#include "CommandController.hh"
7	#include "EventDistributor.hh"
8	#include "ImGuiCpp.hh"
9	#include "ImGuiUtils.hh"
10	#include "PlugException.hh"
11	#include "Scheduler.hh"
12	#include "serialize.hh"
13
14	#include "checked_cast.hh"
15
16	#include <imgui.h>
17
18	#include <cassert>
19	#include <chrono>
20	#include <string>
21	#include <vector>
22
23	namespace openmsx {
24
25	RS232Raw::RS232Raw(EventDistributor& eventDistributor_,
26	Scheduler& scheduler_,
27	CommandController& commandController)
28	: eventDistributor(eventDistributor_), scheduler(scheduler_)
29	, cliComm(commandController.getCliComm())
30	, rs232RawPortSetting(
31	commandController, "rs232-raw-port",
32	"Serial port name for RS232 raw pluggable",
33	#ifdef _WIN32
34	"COM1"
35	#else
36	"/dev/ttyS0"
37	#endif
38	)
39	{
40	eventDistributor.registerEventListener(EventType::RS232_RAW, *this);
41	rs232RawPortSetting.attach(*this);
42	}
43
44	RS232Raw::~RS232Raw()
45	{
46	tearDown();
47	rs232RawPortSetting.detach(*this);
48	eventDistributor.unregisterEventListener(EventType::RS232_RAW, *this);
49	}
50
51	static serial::SerialParams buildParamsImpl(unsigned baud, SerialDataInterface::DataBits dataBits, SerialDataInterface::StopBits stopBits, bool parityEnabled, SerialDataInterface::Parity parity)
52	{
53	serial::SerialParams p;
54	p.baudRate = baud;
55	p.dataBits = static_cast<int>(dataBits);
56	switch (stopBits) {
57	using enum SerialDataInterface::StopBits;
58	case S1: p.stopBits = 1; break;
59	case S1_5: p.stopBits = 1; break;
60	case S2: p.stopBits = 2; break;
61	default: p.stopBits = 1; break;
62	}
63	if (parityEnabled) {
64	p.parity = (parity == SerialDataInterface::Parity::ODD) ? 1 : 2;
65	} else {
66	p.parity = 0;
67	}
68	return p;
69	}
70
71	void RS232Raw::applyParams()
72	{
73	#ifdef _WIN32
74	if (!handle && !thread.joinable()) return;
75	tearDown();
76	{
77	std::scoped_lock lock(mutex);
78	queue.clear();
79	}
80	auto portName = rs232RawPortSetting.getString();
81	if (portName.empty()) return;
82	setup(std::string(portName), buildParams());
83	#else
84	// POSIX: nothing to reconfigure while the worker is still opening the
85	// port (the open uses the parameters it was spawned with). Also
86	// deliberately no tear down + reopen here: that would re-assert the
87	// modem lines and might cause misbehavior on the connected device due
88	// to the unexpected state change.
89	if (!handle) return;
90	auto p = buildParams();
91	(void)handle->set_params(p);
92	(void)handle->set_dtr(DTR);
93	(void)handle->set_rts(RTS);
94	#endif
95	}
96
97	// Pluggable
98	void RS232Raw::plugHelper(Connector& connector_, EmuTime /time/)
99	{
100	auto portName = rs232RawPortSetting.getString();
101	if (portName.empty()) {
102	throw PlugException("No serial port specified");
103	}
104
105	auto& rs232Connector = checked_cast<RS232Connector&>(connector_);
106	directConn = &rs232Connector;
107
108	// Initialize the modem-line state BEFORE the worker opens the port, so
109	// the lines are applied in their final state (DTR/RTS asserted) and never
110	// toggle afterwards: a transition resets ESP32-style auto-reset circuits.
111	DCD = false;
112	RI = false;
113	CTS = false;
114	DSR = true;
115	DTR = true;
116	RTS = true;
117
118	setup(std::string(portName), buildParams());
119
120	rs232Connector.setDataBits(currentDataBits);
121	rs232Connector.setStopBits(currentStopBits);
122	rs232Connector.setParityBit(currentParityEnabled, currentParity);
123
124	setConnector(&connector_);
125	}
126
127	void RS232Raw::unplugHelper(EmuTime /time/)
128	{
129	tearDown();
130	directConn = nullptr;
131	}
132
133	zstring_view RS232Raw::getName() const
134	{
135	return "rs232-raw";
136	}
137
138	zstring_view RS232Raw::getDescription() const
139	{
140	return "RS232 raw serial port pluggable. Connects the RS232 port to "
141	"a host serial port, selected with the 'rs232-raw-port' setting.";
142	}
143
144	void RS232Raw::handleImGuiExtraMenuItems()
145	{
146	if (auto cur = rs232RawPortSetting.getString(); cur != currentPort) {
147	ports = serial::list_ports();
148	currentPort = std::string(cur);
149	}
150	im::Indent([&]{
151	ImGui::SetNextItemWidth(ImGui::GetFontSize() * 12.0f);
152	im::Combo("##rs232-raw-port", currentPort.c_str(), [this]{
153	for (const auto& p : ports) {
154	bool selected = (p == currentPort);
155	if (ImGui::Selectable(p.c_str(), selected)) {
156	rs232RawPortSetting.setString(p);
157	currentPort = p;
158	}
159	if (selected) {
160	ImGui::SetItemDefaultFocus();
161	}
162	}
163	});
164	simpleToolTip("Select the host serial port for RS232 raw");
165	ImGui::SameLine();
166	if (ImGui::SmallButton("Refresh")) {
167	ports = serial::list_ports();
168	}
169	});
170	}
171
172	// Stops the worker thread and closes the port. Safe to call in any state.
173	void RS232Raw::tearDown()
174	{
175	if (thread.joinable()) {
176	poller->abort();
177	}
178	handle.reset(); // closes the port: unblocks the worker's pending read
179	if (thread.joinable()) {
180	thread.join();
181	}
182	poller.reset();
183	}
184
185	// Spawns the worker thread: it opens the port (retrying briefly) and then
186	// runs the read loop. The retry delays sleep the worker thread, never the
187	// emulation thread.
188	void RS232Raw::setup(std::string portName, serial::SerialParams params)
189	{
190	poller.emplace();
191	thread = std::thread([this, pn = std::move(portName), pm = std::move(params)]() mutable {
192	openAndRun(std::move(pn), std::move(pm));
193	});
194	}
195
196	serial::SerialParams RS232Raw::buildParams() const
197	{
198	return buildParamsImpl(currentBaud, currentDataBits, currentStopBits,
199	currentParityEnabled, currentParity);
200	}
201
202	// Opens the port (retrying briefly) and then runs the read loop. Runs on
203	// the worker thread: the retry delays sleep this host thread, never the
204	// emulation thread (a just-closed Windows COM port can stay owned by the
205	// OS for a few ms, so an immediate reopen can transiently fail).
206	void RS232Raw::openAndRun(std::string portName, serial::SerialParams params)
207	{
208	auto h = serial::open(portName, params);
209	for (int attempt = 0; !h.has_value() && attempt < 4 && !poller->aborted();
210	++attempt) {
211	std::this_thread::sleep_for(std::chrono::milliseconds(10));
212	h = serial::open(portName, params);
213	}
214	if (poller->aborted()) {
215	return; // unplugged while opening: drop the port (h closes it)
216	}
217	if (!h.has_value()) {
218	cliComm.printWarning("Failed to open serial port ", portName, ": ",
219	serial::to_string(h.error()));
220	return;
221	}
222	(void)h->set_params(params);
223	(void)h->set_dtr(DTR);
224	(void)h->set_rts(RTS);
225	handle = std::move(*h);
226	run();
227	}
228
229	void RS232Raw::run()
230	{
231	auto* conn = directConn;
232	bool direct = conn && conn->directByteDelivery();
233
234	while (handle && !poller->aborted()) {
235	#ifndef _WIN32
236	if (poller->poll(handle->native_handle())) {
237	break;
238	}
239	#endif
240
241	uint8_t b;
242	auto r = handle->read(std::span<uint8_t>(&b, 1));
243	if (!r.has_value()) {
244	handle.reset();
245	} else if (*r == 0) {
246	#ifdef _WIN32
247	std::this_thread::sleep_for(std::chrono::milliseconds(1));
248	#endif
249	} else if (direct) {
250	conn->recvByte(b, EmuTime::zero());
251	} else {
252	assert(isPluggedIn());
253	{
254	std::scoped_lock lock(mutex);
255	queue.push_back(b);
256	}
257	eventDistributor.distributeEvent(Rs232RawEvent());
258	}
259	}
260	}
261
262	// input
263	void RS232Raw::signal(EmuTime time)
264	{
265	if (!handle) return;
266
267	auto* conn = checked_cast<RS232Connector*>(getConnector());
268
269	if (!conn->acceptsData()) {
270	return;
271	}
272
273	if (!conn->ready() \|\| !RTS) return;
274
275	std::scoped_lock lock(mutex);
276	if (queue.empty()) return;
277	auto b = queue.pop_front();
278	conn->recvByte(b, time);
279	}
280
281	// EventListener
282	bool RS232Raw::signalEvent(const Event& /event/)
283	{
284	if (isPluggedIn()) {
285	signal(scheduler.getCurrentTime());
286	} else {
287	std::scoped_lock lock(mutex);
288	queue.clear();
289	}
290	return false;
291	}
292
293	// output
294	void RS232Raw::recvByte(uint8_t value, EmuTime /time/)
295	{
296	if (!handle) return;
297
298	if (!handle->write(std::span<const uint8_t>(&value, 1)).has_value()) {
299	handle.reset();
300	}
301	}
302
303	// Control lines
304
305	std::optional<bool> RS232Raw::getDSR(EmuTime /time/) const
306	{
307	if (!handle) return {};
308	return DSR.load();
309	}
310
311	std::optional<bool> RS232Raw::getCTS(EmuTime /time/) const
312	{
313	if (!handle) return {};
314	return CTS.load();
315	}
316
317	std::optional<bool> RS232Raw::getDCD(EmuTime /time/) const
318	{
319	if (!handle) return {};
320	return DCD.load();
321	}
322
323	std::optional<bool> RS232Raw::getRI(EmuTime /time/) const
324	{
325	if (!handle) return {};
326	return RI.load();
327	}
328
329	void RS232Raw::setDTR(bool status, EmuTime /time/)
330	{
331	if (DTR == status) return;
332	DTR = status;
333	if (handle) {
334	(void)handle->set_dtr(status);
335	}
336	}
337
338	void RS232Raw::setRTS(bool status, EmuTime /time/)
339	{
340	if (RTS == status) return;
341	RTS = status;
342	if (handle) {
343	(void)handle->set_rts(status);
344	if (RTS) {
345	std::scoped_lock lock(mutex);
346	if (!queue.empty()) {
347	eventDistributor.distributeEvent(Rs232RawEvent());
348	}
349	}
350	}
351	}
352
353	// Serial params
354
355	void RS232Raw::setDataBits(DataBits bits)
356	{
357	if (currentDataBits.load() == bits) return;
358	currentDataBits.store(bits);
359	applyParams();
360	}
361
362	void RS232Raw::setStopBits(StopBits bits)
363	{
364	if (currentStopBits.load() == bits) return;
365	currentStopBits.store(bits);
366	applyParams();
367	}
368
369	void RS232Raw::setParityBit(bool enable, Parity parity)
370	{
371	if (currentParityEnabled.load() == enable && currentParity.load() == parity) return;
372	currentParityEnabled.store(enable);
373	currentParity.store(parity);
374	applyParams();
375	}
376
377	void RS232Raw::setBaudRate(unsigned baud)
378	{
379	if (currentBaud.load() == baud) return;
380	currentBaud.store(baud);
381	applyParams();
382	}
383
384	void RS232Raw::update(const Setting& /setting/) noexcept
385	{
386	tearDown();
387	{
388	std::scoped_lock lock(mutex);
389	queue.clear();
390	}
391
392	auto portName = rs232RawPortSetting.getString();
393	if (!portName.empty() && isPluggedIn()) {
394	setup(std::string(portName), buildParams());
395	}
396	}
397
398	template<typename Archive>
399	void RS232Raw::serialize(Archive& /ar/, unsigned /version/)
400	{
401	if constexpr (Archive::IS_LOADER) {
402	if (!isPluggedIn()) return;
403
404	auto* conn = dynamic_cast<RS232Connector*>(getConnector());
405	if (!conn) return;
406	directConn = conn;
407
408	auto portName = rs232RawPortSetting.getString();
409	if (portName.empty()) return;
410
411	setup(std::string(portName), buildParams());
412	}
413	}
414	INSTANTIATE_SERIALIZE_METHODS(RS232Raw);
415	REGISTER_POLYMORPHIC_INITIALIZER(Pluggable, RS232Raw, "RS232Raw");
416
417	} // namespace openmsx

Keyboard