SLU compiles, minimal function

10.02_devices/2_src/dl11w.cpp

@@ -33,26 +33,25 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdint.h>
+#include <assert.h>
 #include <errno.h>
 #include <iostream>
 #include <netdb.h>
 #include <netinet/in.h>
 
+#include "utils.hpp"
+#include "gpios.hpp"
 #include "unibusadapter.hpp"
 #include "unibusdevice.hpp"	// definition of class device_c
 #include "unibus.h"
 #include "dl11w.hpp"
-#include "gpios.hpp"
 
 #include "rs232.hpp"
 
-char buffer[BUFLEN + 1];
-
 //-------------------------------------------------
 
-slu_c::slu_c() :
-		unibusdevice_c()  // super class constructor
-{
+slu_c::slu_c() : unibusdevice_c() {
+	set_workers_count(2); // receiver and transmitte have own threads
 
 	//ip_host.value = IP_HOST; // not used
 	//ip_port.value = IP_PORT; // not used
@@ -62,7 +61,8 @@ slu_c::slu_c() :
 	type_name.value = "slu_c";
 	log_label = "slu";
 
-	set_default_bus_params(SLU_ADDR, SLU_VECTOR + 4, SLU_LEVEL); // base addr, intr-vector, intr level
+	// SLU has 2 Interrupt vectors: base = RCV, base+= XMT
+	set_default_bus_params(SLU_ADDR, SLU_VECTOR, SLU_LEVEL); // base addr, intr-vector, intr level
 
 	// init parameters
 
@@ -71,33 +71,34 @@ slu_c::slu_c() :
 
 	reg_rcsr = &(this->registers[slu_idx_rcsr]); // @  base addr
 	strcpy(reg_rcsr->name, "RCSR"); // Receiver Status Register
-	reg_rcsr->active_on_dati = true;
+	reg_rcsr->active_on_dati = false;
 	reg_rcsr->active_on_dato = true;
-	reg_rcsr->reset_value = 0 & ! RCSR_RCVR_DONE;
+	reg_rcsr->reset_value = 0;
 	reg_rcsr->writable_bits = 0xff;
 
 	reg_rbuf = &(this->registers[slu_idx_rbuf]); // @  base addr
 	strcpy(reg_rbuf->name, "RBUF"); // Receiver Buffer Register
-	reg_rbuf->active_on_dati = true; // no controller state change
-	reg_rbuf->active_on_dato = true;
+	reg_rbuf->active_on_dati = true;
+	reg_rbuf->active_on_dato = true; // required for "active on dati""
 	reg_rbuf->reset_value = 0;
-	reg_rbuf->writable_bits = 0xff;
+	reg_rbuf->writable_bits = 0x00;
 
 	reg_xcsr = &(this->registers[slu_idx_xcsr]); // @  base addr
 	strcpy(reg_xcsr->name, "XCSR"); // Transmitter Status Register
-	reg_xcsr->active_on_dati = true;
+	reg_xcsr->active_on_dati = false;
 	reg_xcsr->active_on_dato = true;
 	reg_xcsr->reset_value = XCSR_XMIT_RDY; // set
 	reg_xcsr->writable_bits = 0xff;
 
 	reg_xbuf = &(this->registers[slu_idx_xbuf]); // @  base addr
 	strcpy(reg_xbuf->name, "XBUF"); //Transmitter Buffer Register
-	reg_xbuf->active_on_dati = true; // no controller state change
+	reg_xbuf->active_on_dati = false; // no controller state change
 	reg_xbuf->active_on_dato = true;
 	reg_xbuf->reset_value = 0;
 	reg_xbuf->writable_bits = 0xff;
 
 	// initialize serial format
+	serialport.value = "ttyS2"; // labeled "UART2" on PCB
 	baudrate.value = 9600;
 	mode.value = "8N1";
 }
@@ -107,24 +108,30 @@ slu_c::~slu_c() {
 
 bool slu_c::on_param_changed(parameter_c *param) {
 	if (param == &enabled) {
-		cport_nr = 2; /* UART2  */
 		if (enabled.new_value) {
-			// enable SLU: setup COM port
-			if (RS232_OpenComport(cport_nr, baudrate.value, mode.value.c_str())) {
-				ERROR("Can not open comport");
+			// enable SLU: setup COM serial port
+			// setup for BREAK and parity evaluation
+			if (rs232.OpenComport(serialport.value.c_str(), baudrate.value, mode.value.c_str(),
+			true)) {
+				ERROR("Can not open serial port %s", serialport.value.c_str());
 				return false; // reject "enable"
 			}
-			// lock serial format settings
+
+			// lock serial port and settings
+			serialport.readonly = true;
 			baudrate.readonly = true;
 			mode.readonly = true;
 
-			RS232_cputs(cport_nr, "Comport opened\n\r");
+			INFO("Serial port %s opened", serialport.value.c_str());
+			rs232.cputs("Serial port opened\n\r");
 		} else {
 			// disable SLU
-			RS232_CloseComport(cport_nr);
-			// lock serial format settings
+			rs232.CloseComport();
+			// unlock serial port and settings
+			serialport.readonly = false;
 			baudrate.readonly = false;
 			mode.readonly = false;
+			INFO("Serial port %s closed", serialport.value.c_str());
 		}
 	}
 	return unibusdevice_c::on_param_changed(param); // more actions (for enable)
@@ -132,54 +139,68 @@ bool slu_c::on_param_changed(parameter_c *param) {
 
 //--------------------------------------------
 
-// background worker.
-void slu_c::worker(void) {
-	timeout_c timeout;
-	char mychar;
-	int i, n;
-
-	while (!worker_terminate) {
-		timeout.wait_ms(SLU_MSRATE_MS);
-
-		/* read character from socket */
-		if (!(RCSR_RCVR_DONE & rcsr.value)) {
-			bzero(buffer, BUFLEN);
-#if 1
-			if (slu_maint.value) {
-				n = 1;
-				buffer[0] = rbuf.value;
-				buffer[1] = 0;
-			} else
-#endif
-			{
-				/* read serial data, if any */
-				n = RS232_PollComport(cport_nr, (unsigned char*) buffer, 1);
-			}
-			for (i = 0; i < n; i++) {
-				mychar = buffer[i];
-				// transmit chr to bus
-				rbuf.value = mychar;
-				set_register_dati_value(reg_rbuf, rbuf.value, __func__);
-
-				// signal data on bus ready to read
-				rcsr.value |= RCSR_RCVR_DONE;
-				set_register_dati_value(reg_rcsr, rcsr.value, __func__);
-			}
-		}
-
-		// transfer received character to socket
-		if (!(XCSR_XMIT_RDY & xcsr.value)) {
-			buffer[0] = get_register_dato_value(reg_xbuf);
-			RS232_SendByte(cport_nr, buffer[0]);
-
-			// signal data written
-			xcsr.value |= XCSR_XMIT_RDY;
-			set_register_dati_value(reg_xcsr, xcsr.value, __func__);
-		}
-
-	}
+// Update RCSR
+void slu_c::set_rcsr_dati_value(void) {
+	uint16_t val = (rcv_active ? RCSR_RCVR_ACT : 0) | (rcv_done ? RCSR_RCVR_DONE : 0)
+			| (rcv_intr_enable ? RCSR_RCVR_INT_ENB : 0);
+	set_register_dati_value(reg_rcsr, val, __func__);
 }
 
+// PDP-11 writes into RCSR
+void slu_c::eval_rcsr_dato_value(void) {
+	uint16_t val = get_register_dato_value(reg_rcsr);
+	bool old_rdr_enab = rcv_rdr_enb;
+	bool old_intr = rcv_done && rcv_intr_enable;
+
+	rcv_intr_enable = val & RCSR_RCVR_INT_ENB ? 1 : 0;
+	rcv_rdr_enb = val & RCSR_RDR_ENB ? 1 : 0;
+	if (!old_rdr_enab && rcv_rdr_enb)
+		rcv_done = 0; // raising edge clears rcv_done
+	// if rcvr_done and int enable goes high: INTR
+	bool new_intr = rcv_done && rcv_intr_enable;
+	if (!old_intr && new_intr) // raising edge
+		interrupt(intr_vector.value, intr_level.value);
+}
+
+// Update RBUF, readonly
+void slu_c::set_rbuf_dati_value(void) {
+	uint16_t val = (rcv_or_err ? RBUF_OR_ERR : 0) | (rcv_fr_err ? RBUF_FR_ERR : 0)
+			| (rcv_p_err ? RBUF_P_ERR : 0);
+	if (val) // set general error flag
+		val |= RBUF_ERROR;
+	val |= rcv_buffer; // received char in bits 7..0
+	set_register_dati_value(reg_rbuf, val, __func__);
+}
+
+// Update Transmit Status Register XCSR
+void slu_c::set_xcsr_dati_value(void) {
+	uint16_t val = (xmt_ready ? XCSR_XMIT_RDY : 0) | (xmt_intr_enable ? XCSR_XMIT_INT_ENB : 0)
+			| (xmt_maint ? XCSR_MAINT : 0) | (xmt_break ? XCSR_BREAK : 0);
+	set_register_dati_value(reg_xcsr, val, __func__);
+}
+
+void slu_c::eval_xcsr_dato_value(void) {
+	uint16_t val = get_register_dato_value(reg_xcsr);
+	bool old_intr = xmt_ready && xmt_intr_enable;
+	bool old_break = xmt_break;
+
+	xmt_intr_enable = val & XCSR_XMIT_INT_ENB ? 1 : 0;
+	xmt_maint = val & XCSR_MAINT ? 1 : 0;
+	xmt_break = val & XCSR_BREAK ? 1 : 0;
+	// if xmt_ready and int enable goes high: INTR
+	bool new_intr = xmt_ready && xmt_intr_enable;
+	if (!old_intr && new_intr) // raising edge
+		interrupt(intr_vector.value + 4, intr_level.value);
+	if (old_break != xmt_break)
+		rs232.SetBreak(xmt_break);
+}
+
+void slu_c::eval_xbuf_dato_value(void) {
+	// transmit data buffer contains only the character in bits 7..0
+	xmt_buffer = get_register_dato_value(reg_xbuf) & 0xff;
+}
+
+
 // process DATI/DATO access to one of my "active" registers
 // !! called asynchronuously by PRU, with SSYN asserted and blocking UNIBUS.
 // The time between PRU event and program flow into this callback
@@ -190,45 +211,47 @@ void slu_c::worker(void) {
 void slu_c::on_after_register_access(unibusdevice_register_t *device_reg,
 		uint8_t unibus_control) {
 
-	if (unibus_control == UNIBUS_CONTROL_DATO) // bus write
-		set_register_dati_value(device_reg, device_reg->active_dato_flipflops, __func__);
+//	if (unibus_control == UNIBUS_CONTROL_DATO) // bus write 
+//		set_register_dati_value(device_reg, device_reg->active_dato_flipflops, __func__);
 
 	switch (device_reg->index) {
 
 	case slu_idx_rcsr:
-		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write
-			rcvr_interrupt_enable.value = !!(reg_rcsr->active_dato_flipflops
-					& (RCSR_RCVR_INT_ENB));
-			rdr_enable.value = !!(reg_rcsr->active_dato_flipflops & (RCSR_RDR_ENB));
+		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write into RCSR
+			pthread_mutex_lock(&on_after_rcv_register_access_mutex); // signal changes atomic against UNIBUS accesses
+			eval_rcsr_dato_value(); // may generate INTR
+			set_rcsr_dati_value();
+			// ignore reader enable
+			pthread_mutex_unlock(&on_after_rcv_register_access_mutex);
 		}
 		break;
-
-	case slu_idx_xbuf:
-		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write
-			// signal data has been written to bus
-			xcsr.value &= ~ XCSR_XMIT_RDY;
-			set_register_dati_value(reg_xcsr, xcsr.value, __func__);
-			// get value from bus write and put it into rx buffer
-			xbuf.value = reg_xbuf->active_dato_flipflops;
-		}
+	case slu_idx_rbuf: { // DATI/DATO: is read only, but write also clears "rcvr_done"
+		// signal data has been read from bus
+		pthread_mutex_lock(&on_after_rcv_register_access_mutex);
+		rcv_done = 0;
+		set_rcsr_dati_value();
+		pthread_mutex_unlock(&on_after_rcv_register_access_mutex);
+	}
 		break;
-
 	case slu_idx_xcsr:
 		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write
-			xmit_interrupt_enable.value = !!(reg_xcsr->active_dato_flipflops
-					& (XCSR_XMIT_INT_ENB));
-			slu_maint.value = !!(reg_xcsr->active_dato_flipflops & (XCSR_MAINT));
+			pthread_mutex_lock(&on_after_xmt_register_access_mutex);
+			eval_xcsr_dato_value(); // may trigger INTR
+			set_xcsr_dati_value();
+			pthread_mutex_unlock(&on_after_xmt_register_access_mutex);
 		}
 		break;
-
-	case slu_idx_rbuf:
-		if (unibus_control == UNIBUS_CONTROL_DATI) { // bus read
-			// signal data has been read from bus
-			rcsr.value &= ~ RCSR_RCVR_DONE;
-			set_register_dati_value(reg_rcsr, rcsr.value, __func__);
+	case slu_idx_xbuf:
+		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write into XBUF
+			pthread_mutex_lock(&on_after_xmt_register_access_mutex);
+			eval_xbuf_dato_value();
+			xmt_ready = 0; // signal worker: xmt_data pending
+			set_xcsr_dati_value();
+			// on_after_register_access_cond used for xmt worker
+			pthread_cond_signal(&on_after_xmt_register_access_cond);
+			pthread_mutex_unlock(&on_after_xmt_register_access_mutex);
 		}
 		break;
-
 	default:
 		break;
 	}
@@ -245,10 +268,119 @@ void slu_c::on_init_changed(void) {
 	// write all registers to "reset-values"
 	if (init_asserted) {
 		reset_unibus_registers();
+		rcv_active = 0;
+		rcv_done = 0;
+		rcv_intr_enable = 0;
+		rcv_or_err = 0;
+		rcv_fr_err = 0;
+		rcv_p_err = 0;
+		rcv_buffer = 0;
+		xmt_ready = 1;
+		xmt_intr_enable = 0;
+		xmt_maint = 0;
+		xmt_break = 0;
 		INFO("slu_c::on_init()");
 	}
 }
 
+// background worker.
+void slu_c::worker_rcv(void) {
+	timeout_c timeout;
+	int n;
+	char buffer[BUFLEN + 1];
+
+	// 1. poll with frequency > baudrate, to see single bits
+	unsigned poll_periods_us = 1000000 / baudrate.value;
+
+	while (!workers_terminate) {
+		timeout.wait_us(poll_periods_us);
+		// "query
+		// rcv_active: can only be set by polling the UART inpit GPIiO pin?
+		// at the moments, it is onyl sen on maintenance loopback xmt
+		/* read serial data, if any */
+		if (rs232.PollComport((unsigned char*) buffer, 1)) {
+			pthread_mutex_lock(&on_after_rcv_register_access_mutex); // signal changes atomic against UNIBUS accesses
+			rcv_or_err = rcv_fr_err = rcv_p_err = 0;
+			if (rcv_done) // not yet cleared? overrun!
+				rcv_or_err = 1;
+			if (buffer[0] == 0xff) {
+				/* How to receive framing and parity errors:  see termios(3)
+				 If IGNPAR=0, PARMRK=1: error on <char> received as \377 \0 <char> 
+				 \377 received as \377 \377
+				 */
+				n = rs232.PollComport((unsigned char*) buffer, 1);
+				assert(n);	// next char after 0xff escape immediately available
+
+				if (buffer[0] == 0) { // error flags
+					rcv_fr_err = rcv_p_err = 1;
+					n = rs232.PollComport((unsigned char*) buffer, 1);
+					assert(n); // next char after 0xff 0 seq is data"
+					rcv_buffer = buffer[0];
+					rcv_done = 1;
+				} else if (buffer[0] == 0xff) { // enocoded 0xff
+					rcv_buffer = 0xff;
+				} else {
+					WARNING("Received 0xff <stray> seqeuence");
+					rcv_buffer = buffer[0];
+				}
+			} else
+				// received non escaped data byte
+				rcv_buffer = buffer[0];
+			rcv_done = 1;
+			set_rbuf_dati_value();
+			set_rcsr_dati_value(); // INTR!
+			pthread_mutex_unlock(&on_after_rcv_register_access_mutex); // signal changes atomic against UNIBUS accesses
+		}
+	}
+}
+
+void slu_c::worker_xmt(void) {
+	timeout_c timeout;
+	assert(!pthread_mutex_lock(&on_after_register_access_mutex));
+	while (!workers_terminate) {
+		// 1. wait for xmt signal
+		int res = pthread_cond_wait(&on_after_xmt_register_access_cond, &on_after_xmt_register_access_mutex);
+		// on_after_xmt_register_access_mutex remains locked all the time
+		if (res != 0) {
+			ERROR("SLU::worker_xmt() pthread_cond_wait = %d = %s>", res, strerror(res));
+			continue;
+		}
+
+		// 2. transmit
+		rs232.SendByte(xmt_buffer);
+		xmt_ready = 0;
+		set_xcsr_dati_value();
+		if (xmt_maint) { // loop back: simulate data byte coming in
+			pthread_mutex_lock(&on_after_rcv_register_access_mutex);
+			rcv_active = 1;
+			set_rcsr_dati_value();
+			pthread_mutex_unlock(&on_after_rcv_register_access_mutex);
+		}
+
+		// 3. wait for data byte being shifted out
+		pthread_mutex_unlock(&on_after_xmt_register_access_mutex);
+		timeout.wait_us(rs232.TransmissionTime_us);
+		pthread_mutex_lock(&on_after_xmt_register_access_mutex);
+		if (xmt_maint)
+			// put sent byte into rcv buffer, receiver will poll it
+			rs232.LoopbackByte(xmt_buffer);
+		xmt_ready = 1;
+		set_rcsr_dati_value(); // generates interrupt
+		set_xcsr_dati_value();
+		// has rcv or xmt interrupt priority on maintennace loop back
+	}
+	assert(!pthread_mutex_unlock(&on_after_xmt_register_access_mutex));
+}
+
+void slu_c::worker(unsigned instance) {
+	// 2 parallel worker() instances: 0 and 1 
+	if (instance == 0)
+		worker_rcv();
+	else
+		worker_xmt();
+
+}
+
 //--------------------------------------------------------------------------------------------------
 
 ltc_c::ltc_c() :
@@ -285,9 +417,10 @@ bool ltc_c::on_param_changed(parameter_c *param) {
 }
 
 // background worker.
-void ltc_c::worker(void) {
+void ltc_c::worker(unsigned instance) {
+	UNUSED(instance); // only one
 	timeout_c timeout;
-	while (!worker_terminate) {
+	while (!workers_terminate) {
 		if (ltc_input.value) {
 			//should really wait for LTC input trailing edge here
 			timeout.wait_ms(10000);
@@ -323,13 +456,7 @@ void ltc_c::on_after_register_access(unibusdevice_register_t *device_reg,
 		if (unibus_control == UNIBUS_CONTROL_DATO) { // bus write
 			lks.value = reg_lks->active_dato_flipflops;
 			ltc_interrupt_enable.value = !!(reg_lks->active_dato_flipflops & (LKS_INT_ENB));
-#if 0
-			if (reg_lks->active_dato_flipflops && 1)
-			{
-				interrupt();
-				//DEBUG("Interrupt!");
-			}
-#endif
+			interrupt(intr_vector.value, intr_level.value);
 		}
 		break;
 

10.02_devices/2_src/dl11w.hpp

@@ -34,6 +34,7 @@ using namespace std;
 #include "utils.hpp"
 #include "unibusdevice.hpp"
 #include "parameter.hpp"
+#include "rs232.hpp"
 
 // socket console settings
 //#define IP_PORT 5001
@@ -44,7 +45,7 @@ using namespace std;
 #if DL11A // console (teletype keyboard & printer)
 #define SLU_ADDR	0777560
 #define SLU_LEVEL	04
-#define SLU_VECTOR	060
+#define SLU_VECTOR	060	// RCV +0, XMT +4
 #elif DL11B // paper tape punch and reader
 #define SLU_ADDR	0777550
 #define SLU_LEVEL	04
@@ -98,25 +99,64 @@ enum ltc_reg_index {
 // ------------------------------------------ SLU -----------------------------
 class slu_c: public unibusdevice_c {
 private:
-	int cport_nr; // COM port handle for RS232 library
+	rs232_c rs232; /// COM port interface
 
 	unibusdevice_register_t *reg_rcsr;
 	unibusdevice_register_t *reg_rbuf;
 	unibusdevice_register_t *reg_xcsr;
 	unibusdevice_register_t *reg_xbuf;
 
+	/*** SLU is infact 2 independend devices: RCV and XMT ***/
+	pthread_cond_t on_after_rcv_register_access_cond = PTHREAD_COND_INITIALIZER;
+	pthread_mutex_t on_after_rcv_register_access_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+	// bits in registers
+	bool rcv_active; /// while a char is receive ... not available
+	bool rcv_done; // char received. INTR. cleared by rdr_enable, access to rbuf, init
+	bool rcv_overrun;bool rcv_intr_enable; // receiver interrupt enabled
+	bool rcv_or_err; // receiver overrun: rcv_done 1 on receive
+	bool rcv_fr_err; // framing error. high on received BREAK
+	bool rcv_p_err; // parity error
+	uint8_t rcv_buffer;bool rcv_rdr_enb; // reader enable. Cleared by receive or init
+
+	pthread_cond_t on_after_xmt_register_access_cond = PTHREAD_COND_INITIALIZER;
+	pthread_mutex_t on_after_xmt_register_access_mutex = PTHREAD_MUTEX_INITIALIZER;
+	bool xmt_ready;// transmitter ready. INTR,  cleared on XBUF access
+	bool xmt_intr_enable; // receiver interrupt enabled
+
+	bool xmt_maint; // set 1 for local loop back
+	bool xmt_break; // transmit continuous break
+	uint8_t xmt_buffer;
+
+	// convert between register ansd state variables	
+	void set_rcsr_dati_value(void);
+	void eval_rcsr_dato_value(void);
+	void set_rbuf_dati_value(void);
+	void set_xcsr_dati_value(void);
+	void eval_xcsr_dato_value(void);
+	void eval_xbuf_dato_value(void);
+
 public:
 
 	slu_c();
 	~slu_c();
 
 	//parameter_string_c   ip_host = parameter_string_c(  this, "SLU socket IP host", "host", /*readonly*/ false, "ip hostname");
-	//parameter_unsigned_c ip_port = parameter_unsigned_c(this, "SLU socket IP port", "port", /*readonly*/ false, "", "%d", "ip port", 32, 10);
+	//parameter_unsigned_c ip_port = parameter_unsigned_c(this, "SLU socket IP serialport", "serialport", /*readonly*/ false, "", "%d", "ip serialport", 32, 10);
+	parameter_string_c serialport = parameter_string_c(this, "serialport", "p", /*readonly*/
+			false, "Linux serial port: \"ttyS1\" or \"ttyS2\"");
+
 	parameter_unsigned_c baudrate = parameter_unsigned_c(this, "baudrate", "b", /*readonly*/
-			false, "", "%d", "Baudrate: 110, 300, ... 115200", 115200, 10);
+	false, "", "%d", "Baudrate: 110, 300, ... 38400", 38400, 10);
+	// 40kbaud -> 25us bit polling period needed
+
 	parameter_string_c mode = parameter_string_c(this, "mode", "m", /*readonly*/false,
 			"Mode: 8N1, 7E1, ... ");
 
+	parameter_bool_c break_enable = parameter_bool_c(this, "break", "b", /*readonly*/false,
+			"Enable BREAK transmission");
+
+#ifdef USED
 	// @David: duplicating device registers as parameters is not necessary ...
 	// they can be seen with "exam" anyhow.
 	parameter_unsigned_c rcsr = parameter_unsigned_c(this, "Receiver Status Register", "rcsr", /*readonly*/
@@ -136,9 +176,11 @@ public:
 			false, "1 = enable Maintenance mode enabled");
 	parameter_bool_c rdr_enable = parameter_bool_c(this, "RDR enable", "rdre",/*readonly*/false,
 			"1 = enable reader enable");
-
+#endif
 	// background worker function
-	void worker(void) override;
+	void worker(unsigned instance) override;
+	void worker_rcv(void);
+	void worker_xmt(void);
 
 	// called by unibusadapter on emulated register access
 	void on_after_register_access(unibusdevice_register_t *device_reg, uint8_t unibus_control)
@@ -161,16 +203,16 @@ public:
 	~ltc_c();
 
 	parameter_unsigned_c lks = parameter_unsigned_c(this, "Line Clock Status Register", "lks", /*readonly*/
-			false, "", "%o", "Internal state", 32, 8);
+	false, "", "%o", "Internal state", 32, 8);
 	parameter_bool_c lke = parameter_bool_c(this, "LKS timer enable", "lke",/*readonly*/false,
 			"1 = enable update of LKS_IMON by timer");
 	parameter_bool_c ltc_input = parameter_bool_c(this, "LTC input enable", "ltc",/*readonly*/
-			false, "1 = enable update of LKS_IMON by LTC Input");
+	false, "1 = enable update of LKS_IMON by LTC Input");
 	parameter_bool_c ltc_interrupt_enable = parameter_bool_c(this, "LTC interrupt enable",
 			"lie",/*readonly*/false, "1 = enable interrupt");
 
 	// background worker function
-	void worker(void) override;
+	void worker(unsigned instance) override;
 
 	// called by unibusadapter on emulated register access
 	void on_after_register_access(unibusdevice_register_t *device_reg, uint8_t unibus_control)

10.02_devices/2_src/rs232.hpp

@@ -1,47 +1,40 @@
 /*
-***************************************************************************
-*
-* Author: Teunis van Beelen
-*
-* Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Teunis van Beelen
-*
-* Email: teuniz@gmail.com
-*
-***************************************************************************
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-***************************************************************************
-*/
+ ***************************************************************************
+ *
+ * Author: Teunis van Beelen
+ *
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Teunis van Beelen
+ *
+ * Email: teuniz@gmail.com
+ *
+ ***************************************************************************
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ***************************************************************************
+ */
 
 /* Last revision: August 5, 2017 */
 
 /* For more info and how to use this library, visit: http://www.teuniz.net/RS-232/ */
 
-
 #ifndef rs232_INCLUDED
 #define rs232_INCLUDED
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include <stdio.h>
 #include <string.h>
 
-
-
 #if defined(__linux__) || defined(__FreeBSD__)
 
 #include <termios.h>
@@ -60,28 +53,38 @@ extern "C" {
 
 #endif
 
-int RS232_OpenComport(int, int, const char *);
-int RS232_PollComport(int, unsigned char *, int);
-int RS232_SendByte(int, unsigned char);
-int RS232_SendBuf(int, unsigned char *, int);
-void RS232_CloseComport(int);
-void RS232_cputs(int, const char *);
-int RS232_IsDCDEnabled(int);
-int RS232_IsCTSEnabled(int);
-int RS232_IsDSREnabled(int);
-void RS232_enableDTR(int);
-void RS232_disableDTR(int);
-void RS232_enableRTS(int);
-void RS232_disableRTS(int);
-void RS232_flushRX(int);
-void RS232_flushTX(int);
-void RS232_flushRXTX(int);
-int RS232_GetPortnr(const char *);
+#define RS232_PORTNR  38
 
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
+class rs232_c {
+private:
+
+	int Cport; // file handle of COM port
+	int error;
+
+	struct termios new_port_settings, old_port_settings;
+
+public:
+	rs232_c();
+	unsigned TransmissionTime_us;
+	int OpenComport(const char *devname, int baudrate, const char *mode, bool par_and_break);
+	int PollComport(unsigned char *buf, int size);
+	int SendByte(unsigned char byte);
+	void LoopbackByte(unsigned char byte);
+	int SendBuf(unsigned char *buf, int size);
+	void SetBreak(int break_state);
+	void CloseComport(void);
+	void cputs(const char *);
+	int IsDCDEnabled(void);
+	int IsCTSEnabled(void);
+	int IsDSREnabled(void);
+	void enableDTR(void);
+	void disableDTR(void);
+	void enableRTS(void);
+	void disableRTS(void);
+	void flushRX(void);
+	void flushTX(void);
+	void flushRXTX(void);
+};
 
 #endif
 
-