SerialExpanderLib.cpp

// SerialExpanderLib.cpp

#include "SerialExpanderLib.h"

SerialExpanderLib::SerialExpanderLib(HardwareSerial& serial_in, unsigned char r0Pin, unsigned char r1Pin, unsigned char _enablePin) :
	_physical_serial(serial_in),
	_r0Pin(r0Pin),
	_r1Pin(r1Pin),
	_enablePin(_enablePin ),
	_first_character_after_change_arrived(false ),
	_current_channel( nullptr ),
	_is_init( false ),
	_manual_mode( false ),
	_last_byte_at(0)
{
	// Configure the mux control pins.
	pinMode(_r0Pin, OUTPUT);
	pinMode(_r1Pin, OUTPUT);
	pinMode(_enablePin, OUTPUT);
	_set_physical_channel(1);
	disable();
}

void SerialExpanderLib::begin(bool enabled)
{
	_is_init = true;
	// Power up the mux.
	if (enabled)
		enable();

#ifdef DEBUG_EXPANDER
	Serial.println("SerialExpanderLib::begin()");
	__debug_print_channel_status();
#endif
}

void SerialExpanderLib::channel_loop()
{
	if (!_is_enabled)
	{
		return;
	}

	if (_current_channel == nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.println("SerialExpanderLib channel_loop() cant loop, _current_channel is null");
#endif
		return;
	}

	if (!_current_channel->is_init())
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib channel_loop(%d) cant loop, ->is_init() return false\n",_current_channel->channel());
#endif
		return;
	}

	_current_channel->loop();
}

void SerialExpanderLib::loop()
{
	if (!_is_enabled)
	{
		return;
	}

	if (_current_channel == nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.println("SerialExpanderLib loop() cant loop, _current_channel is null");
#endif
		return;
	}


	Stream& virtual_device_serial = _current_channel->expander_end();

	// If the channel allows writing to the device, flush its outgoing bytes.
	if (!_current_channel->read_only())
	{
		while (virtual_device_serial.available())
		{
			_physical_serial.write(virtual_device_serial.read());
		}
	}

	while (_physical_serial.available())
	{
		virtual_device_serial.write((char)_physical_serial.read());
		_last_byte_at = millis();

		if (!_first_character_after_change_arrived)
		{
#ifdef DEBUG_EXPANDER
			Serial.printf("SerialExpanderLib loop() first char from channel [%d] activated_at[%lu] inciated_at[%lu] now[%lu]\n", _current_channel->channel(),_channel_activated_at,_channel_inicialization_start_at,millis());
#endif
			// Restart the global timeout so the channel gets its full window.
			_channel_activated_at = millis();
			_channel_inicialization_start_at = millis();
			_first_character_after_change_arrived = true;
		}
	}

	// Decide whether the active channel should be rotated out.
	if (!_manual_mode &&
		(_current_channel->is_finish() || // channel reported it is done
		(_current_channel->is_init() && _fired_channel_timeout() ) ||  // channel time window elapsed
		(_current_channel->is_init() && _fired_first_character_timeout()) )) // no first byte in time
	{

#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib loop() should rotate from [%d] now[%lu]\n", _current_channel->channel(), millis());
#endif
		_rotate_next_channel();
		return;
	}
}

bool SerialExpanderLib::_fired_channel_timeout()
{
	uint16_t t = _current_channel->get_channel_timeout();
	if (t > 0 && millis() >= (_channel_activated_at + t))
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _fired_channel_timeout(%d) timeout fired! timeout[%lu] activated[%lu] now[%lu]\n", _current_channel->channel(), _current_channel->get_channel_timeout(), _channel_activated_at, millis());
#endif
		return true;
	}
	return false;
}

bool SerialExpanderLib::_fired_first_character_timeout()
{
	if (_first_character_after_change_arrived)
	{
		return false;
	}

	uint16_t t = _current_channel->get_first_character_timeout();
	if (t > 0 && millis() >= (_last_byte_at + t))
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _fired_first_character_timeout(%d) timeout fired! timeout[%lu] activated[%lu] now[%lu]\n", _current_channel->channel(), _current_channel->get_first_character_timeout(), _last_byte_at, millis());
#endif
		return true;
	}
	return false;
}

bool SerialExpanderLib::_fired_inicialization_timeout()
{
	uint16_t t = _current_channel->get_init_timeout();
	if (t > 0 && millis() >= (_channel_inicialization_start_at + t))
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _fired_inicialization_timeout(%d) timeout fired! timeout[%lu] activated[%lu] now[%lu]\n", _current_channel->channel(), _current_channel->get_init_timeout(), _channel_inicialization_start_at, millis());
#endif
		return true;
	}
	return false;
}

void SerialExpanderLib::rotate(void)
{
	if (_current_channel == nullptr)
	{
		return;
	}
	_current_channel->deactivate();
}

void SerialExpanderLib::add_channel(SerialExpanderChannel* channel)
{
	if (channel->channel() < 1 || channel->channel() > SERIAL_EXPANDER_NUM_CHANNELS)
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib ADD CHANNEL ERROR [CH%d] out of bounds, only %d channels\n", channel->channel(), SERIAL_EXPANDER_NUM_CHANNELS);
#endif
		return;
	}

	if (_available_channels[(channel->channel() - 1)] != nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib ADD CHANNEL ERROR [CH%d] already in use\n", channel->channel());
#endif
		return;
	}


	_available_channels[(channel->channel() - 1)] = channel;


	_update_channel_count();

	if (_ready_channel_count == 1)
	{
		// Open the UART for the first channel as it is added.
		_physical_serial.begin(channel->baudrate());
		_inicialize_channel((channel->channel() - 1));
	}

#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib ADD CHANNEL[%d] BAUDRATE[%d]\n", channel->channel(), channel->baudrate());
		__debug_print_channel_status();
#endif
}

#ifdef DEBUG_EXPANDER
void SerialExpanderLib::__debug_print_channel_status()
{
	for (int i = 0; i < SERIAL_EXPANDER_NUM_CHANNELS; i++)
	{
		Serial.printf("CH[%d] INIT[%d] [%p]\n", i + 1, _available_channels[i] == nullptr, _available_channels[i]);
	}
}
#endif

void SerialExpanderLib::channel(unsigned char channel)
{
	if (_current_channel == nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.println("SerialExpanderLib channel() cant do, _current_channel is null");
#endif
		return;
	}

	if ((uint8_t)channel == _current_channel->channel())
	{
#ifdef DEBUG_EXPANDER
		Serial.println("SerialExpanderLib channel() cant do, alredy on that channel");
#endif
		return;
	}

	if ((uint8_t)channel < 1 || (uint8_t)channel > SERIAL_EXPANDER_NUM_CHANNELS)
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib channel() [CH%d] out of bounds, only %d channels\n", channel, SERIAL_EXPANDER_NUM_CHANNELS);
#endif
		return;
	}

	if (_available_channels[channel-1] == nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib channel() [CH%d] not inicialized\n", channel);
#endif
		return;
	}

	_inicialize_channel(channel - 1);
}

void SerialExpanderLib::_update_channel_count()
{
	_ready_channel_count = SERIAL_EXPANDER_NUM_CHANNELS;
	for (uint8_t i = 0; i < SERIAL_EXPANDER_NUM_CHANNELS; i++)
	{
		if ( _available_channels[i] == nullptr || _available_channels[i]->broken() )
		{
			_ready_channel_count -= 1;
		}
#ifdef DEBUG_EXPANDER
		else
		{
			Serial.printf("SerialExpanderLib _update_channel_count() CH[%d] OK :)\n", i+1);
		}
#endif
	}

	if (_ready_channel_count == 0)
	{
#ifdef DEBUG_EXPANDER
		Serial.println("SerialExpanderLib _update_channel_count() no available channels DISABLING DEVICE! :(");
#endif
		disable();
		return;
	}

#ifdef DEBUG_EXPANDER
	Serial.printf("SerialExpanderLib _update_channel_count() %d ready :)\n", _ready_channel_count);
#endif
}

void SerialExpanderLib::_rotate_next_channel()
{
	// Current channel index in the array (physical number - 1, array is 0-based).
	uint8_t last_channel = _current_channel->channel()-1;
	// current_index is the slot we are probing now.
	uint8_t current_index = last_channel;
	SerialExpanderChannel* tmpch = nullptr;
	do {
		// Iterate channels starting from the one after the current.
		current_index += 1;
		// Wrap around (circular reference).
		if (current_index >= SERIAL_EXPANDER_NUM_CHANNELS)
		{
			current_index = 0;
		}
		tmpch = _available_channels[current_index];

		if (tmpch != nullptr && !tmpch->broken())
		{
			break;
		}
	}
	while (last_channel != current_index);

	// When the loop ends, current_index holds either the next valid channel
	// or the same channel we already had (no other valid channels left).
	_inicialize_channel(current_index);
}

void SerialExpanderLib::_set_physical_channel(uint8_t ch)
{
	switch (ch)
	{
	case 2:
		digitalWrite(_r0Pin, 1);
		digitalWrite(_r1Pin, 0);
		break;
	case 3:
		digitalWrite(_r0Pin, 0);
		digitalWrite(_r1Pin, 1);
		break;
	case 4:
		digitalWrite(_r0Pin, 1);
		digitalWrite(_r1Pin, 1);
		break;
	default://Channel 1
		digitalWrite(_r0Pin, 0);
		digitalWrite(_r1Pin, 0);
	}
}

void SerialExpanderLib::_inicialize_channel(uint8_t ch)
{
#ifdef DEBUG_EXPANDER
	Serial.printf("SerialExpanderLib _inicialize_channel ch[%d] _current_channel[%p]\n", ch + 1, _current_channel);
#endif

	if (_available_channels[ch] == nullptr)
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _inicialize_channel ERROR [CH%d] is null\n", ch + 1);
#endif
		return;
	}


	if (_current_channel != nullptr && ch == (_current_channel->channel() - 1) && _current_channel->is_init())
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _inicialize_channel[CH%d] already selected and init, reseting timeouts\n", ch+1);
#endif
		_channel_activated_at = millis();
		_last_byte_at = millis();
		_first_character_after_change_arrived = false;
		_current_channel->activate();
		return;
	}

	if (_available_channels[ch]->broken())
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _inicialize_channel ERROR [CH%d] is BROKEN\n", ch + 1);
#endif
		// A broken channel is treated as if it did not exist.
		_rotate_next_channel();
		return;
	}

	_set_physical_channel(_available_channels[ch]->channel());

	if (_current_channel != nullptr)
	{
#ifdef PROFILE_CHANNELS
		Serial.printf("\nSerialExpanderLib in CH[%d] for [%lu]ms now on CH[%d]\n\n", _current_channel->channel(), (millis() - _channel_activated_at), _available_channels[ch]->channel());
#endif
		_current_channel->deactivate();

		// Re-open the UART only if the new channel uses a different baud rate.
		if (_current_channel->baudrate() != _available_channels[ch]->baudrate())
		{
			_physical_serial.end();
			_physical_serial.begin(_available_channels[ch]->baudrate());
		}
	}
	_current_channel = _available_channels[ch];
	
	delay(10);
	while (_physical_serial.available()) { _physical_serial.read(); };
	_physical_serial.flush();

	_channel_activated_at = millis();
	_last_byte_at = millis();
	_first_character_after_change_arrived = false;
	_current_channel->activate();

	if ( !_current_channel->is_init() && !_begin_virtual_channel())
	{
		// If the channel just became broken during this begin attempt it cannot
		// be used, so recompute the available channel count.
		if (_current_channel->broken())
		{
			_update_channel_count();
		}
		// It did not init: deactivate it and try again later if appropriate.
		_current_channel->deactivate();
	}
}


bool SerialExpanderLib::_begin_virtual_channel()
{
#ifdef DEBUG_EXPANDER
	Serial.printf("SerialExpanderLib _begin_channel(%d) iniciando canal now[%lu]\n", _current_channel->channel(), millis());
#endif

#ifdef DEBUG_EXPANDER
	uint32_t start_t = millis();
#endif
	
	_channel_inicialization_start_at = millis();
	_last_byte_at = millis();
	_first_character_after_change_arrived = false;
	while (!_current_channel->begin() && !_fired_inicialization_timeout() && !_fired_first_character_timeout())
	{
		loop();
	}

	if (_current_channel->is_init())
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _begin_channel(%d) Inicializacion OK in [%lu]ms now[%lu]\n", _current_channel->channel(),(uint32_t)((millis()-start_t)), millis());
#endif
		// Reset the channel activity timestamp so the channel timeout is not
		// triggered by the time spent initializing.
		while (_physical_serial.read() >= 0);
		_channel_activated_at = millis();
		_last_byte_at = millis();
		_first_character_after_change_arrived = false;
		_current_channel->reset_tries();
		return true;
	}
	else
	{
#ifdef DEBUG_EXPANDER
		Serial.printf("SerialExpanderLib _begin_channel(%d) Inicializacion FAILED in [%lu]ms now[%lu]\n", _current_channel->channel(), (uint32_t)((millis() - start_t)), millis());
#endif
		_current_channel->increment_try();
		return false;
	}
}

void SerialExpanderLib::enable()
{
	// Enable the mux chip (enable pin is active low).
	digitalWrite(_enablePin, 0);
	_is_enabled = true;
	// Reset the channel and first-character timers.
	_channel_activated_at = millis();
	_last_byte_at = millis();
	_first_character_after_change_arrived = false;
}

SerialExpanderChannel* SerialExpanderLib::currentChannel()
{
	return _current_channel;
}

unsigned char SerialExpanderLib::munChannels()
{
	return SERIAL_EXPANDER_NUM_CHANNELS;
}

void SerialExpanderLib::disable()
{
	_is_enabled = false;
	digitalWrite(_enablePin, 1);
}

bool SerialExpanderLib::isEnabled()
{
	return _is_enabled;
}