EBYTE.cpp

/*
  The MIT License (MIT)
  Copyright (c) 2019 Kris Kasrpzak
  Permission is hereby granted, free of charge, to any person obtaining a copy of
  this software and associated documentation files (the "Software"), to deal in
  the Software without restriction, including without limitation the rights to
  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  the Software, and to permit persons to whom the Software is furnished to do so,
  subject to the following conditions:
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  On a personal note, if you develop an application or product using this library
  and make millions of dollars, I'm happy for you!
*/

/*
  Code by Kris Kasprzak kris.kasprzak@yahoo.com
  This library is intended to be used with EBYTE transcievers, small wireless units for MCU's such as
  Teensy and Arduino. This library let's users program the operating parameters and both send and recieve data.
  This company makes several modules with different capabilities, but most #defines here should be compatible with them
  All constants were extracted from several data sheets and listed in binary as that's how the data sheet represented each setting
  Hopefully, any changes or additions to constants can be a matter of copying the data sheet constants directly into these #defines
  Usage of this library consumes around 970 bytes
  Revision		Data		Author			Description
  1.0			3/6/2019	Kasprzak		Initial creation
  2.0			3/2/2020	Kasprzak		Added all functions to build the options bit (FEC, Pullup, and TransmissionMode
  3.0			3/27/2020	Kasprzak		Added more Get functions
  4.0			6/23/2020	Kasprzak		Added private method to clear the buffer to ensure read methods would not be filled with buffered data
  5.0			12/4/2020	Kasprzak		moved Reset to public, added Clear to SetMode to avoid buffer corruption during programming
*/

#include <EBYTE.h>
#include <Stream.h>

#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

/*
create the transciever object
*/

EBYTE::EBYTE(Stream *s, uint8_t PIN_M0, uint8_t PIN_M1, uint8_t PIN_AUX)

{

	_s = s;
	_M0 = PIN_M0;
	_M1 = PIN_M1;
	_AUX = PIN_AUX;


}

/*
Initialize the unit--basicall this reads the modules parameters and stores the parameters
for potential future module programming
*/

bool EBYTE::init() {

	bool ok = true;

	pinMode(_AUX, INPUT);
	pinMode(_M0, OUTPUT);
	pinMode(_M1, OUTPUT);

	SetMode(MODE_NORMAL);

	// first get the module data (must be called first for some odd reason

	// ok = ReadModelData();

	// if (!ok) {
	// 	return false;
	// }
	// now get parameters to put unit defaults into the class variables

	ok = ReadParameters();
	if (!ok) {
		return false;
	}

	return true;
}


/*
Method to indicate availability
*/

bool EBYTE::available() {

	return _s->available();

}

/*
Method to indicate availability
*/

void EBYTE::flush() {

	_s->flush();

}

/*
Method to write a single byte...not sure how useful this really is. If you need to send
more that one byte, put the data into a data structure and send it in a big chunk
*/

void EBYTE::SendByte( uint8_t TheByte) {

	_s->write(TheByte);

}


/*
Method to get a single byte...not sure how useful this really is. If you need to get
more that one byte, put the data into a data structure and send/receive it in a big chunk
*/

uint8_t EBYTE::GetByte() {

	return _s->read();

}


/*
Method to send a chunk of data provided data is in a struct--my personal favorite as you
need not parse or worry about sprintf() inability to handle floats
TTP: put your structure definition into a .h file and include in both the sender and reciever
sketches
NOTE: of your sender and receiver MCU's are different (Teensy and Arduino) caution on the data
types each handle ints floats differently
*/

bool EBYTE::SendStruct(const void *TheStructure, uint16_t size_) {


		_buf = _s->write((uint8_t *) TheStructure, size_);

		CompleteTask(1000);

		return (_buf == size_);

}


/*
Method to get a chunk of data provided data is in a struct--my personal favorite as you
need not parse or worry about sprintf() inability to handle floats
TTP: put your structure definition into a .h file and include in both the sender and reciever
sketches
NOTE: of your sender and receiver MCU's are different (Teensy and Arduino) caution on the data
types each handle ints floats differently
*/


bool EBYTE::GetStruct(const void *TheStructure, uint16_t size_) {

	_buf = _s->readBytes((uint8_t *) TheStructure, size_);

	CompleteTask(1000);

	return (_buf == size_);
}


/*
Utility method to wait until module is doen tranmitting
a timeout is provided to avoid an infinite loop
*/

void EBYTE::CompleteTask(unsigned long timeout) {

	unsigned long t = millis();

	// make darn sure millis() is not about to reach max data type limit and start over
	if (((unsigned long) (t + timeout)) == 0){
		t = 0;
	}

	// if AUX pin was supplied and look for HIGH state
	// note you can omit using AUX if no pins are available, but you will have to use delay() to let module finish
	if (_AUX != -1) {

		while (digitalRead(_AUX) == LOW) {

			if ((millis() - t) > timeout){
				break;
			}
		}
	}
	else {
		// if you can't use aux pin, use 4K7 pullup with Arduino
		// you may need to adjust this value if transmissions fail
		delay(1000);

	}


	// per data sheet control after aux goes high is 2ms so delay for at least that long)
	// some MCU are slow so give 50 ms

	delay(PIN_RECOVER);
}

/*
method to set the mode (program, normal, etc.)
*/

void EBYTE::SetMode(uint8_t mode) {

	// data sheet claims module needs some extra time after mode setting (2ms)
	// most of my projects uses 10 ms, but 40ms is safer

	delay(PIN_RECOVER);

	if (mode == MODE_NORMAL) {

		digitalWrite(_M0, LOW);
		digitalWrite(_M1, LOW);
	}
	else if (mode == MODE_WAKEUP) {

		digitalWrite(_M0, HIGH);
		digitalWrite(_M1, LOW);

	}
	else if (mode == MODE_POWERDOWN) {
		digitalWrite(_M0, LOW);
		digitalWrite(_M1, HIGH);
	}
	else if (mode == MODE_PROGRAM) {
		digitalWrite(_M0, HIGH);
		digitalWrite(_M1, HIGH);
	}

	// data sheet says 2ms later control is returned, let's give just a bit more time
	// these modules can take time to activate pins
	delay(PIN_RECOVER);

	// clear out any junk
	// added rev 5
	// i've had some issues where after programming, the returned model is 0, and all settings appear to be corrupt
	// i imagine the issue is due to the internal buffer full of junk, hence clearing
	// Reset() *MAY* work but this seems better.
	ClearBuffer();

	// wait until aux pin goes back low
	CompleteTask(4000);

}



void EBYTE::SetSpeed(uint8_t val) {
	_Speed = val;
}
uint8_t EBYTE::GetSpeed() {
	return _Speed ;
}

void EBYTE::SetTrans(uint8_t val) {
	_Trans = val;
}
uint8_t EBYTE::GetTrans() {
	return _Trans;
}

void EBYTE::SetOptions(uint8_t val) {
	_Options = val;
}
uint8_t EBYTE::GetOptions() {
	return _Options;
}



void EBYTE::SetAddressH(uint8_t val) {
	_AddressHigh = val;
}

uint8_t EBYTE::GetAddressH() {
	return _AddressHigh;
}


void EBYTE::SetAddressL(uint8_t val) {
	_AddressLow = val;
}


uint8_t EBYTE::GetAddressL() {
	return _AddressLow;
}



void EBYTE::SetChannel(uint8_t val) {
	_Channel = val;
}
uint8_t EBYTE::GetChannel() {
	return _Channel;
}



void EBYTE::SetAirDataRate(uint8_t val) {
	_AirDataRate = val;
	BuildSpeedByte();
}

uint8_t EBYTE::GetAirDataRate() {
	return _AirDataRate;
}


void EBYTE::SetParityBit(uint8_t val) {
	_ParityBit = val;
	BuildSpeedByte();
}
uint8_t EBYTE::GetParityBit() {
	return _ParityBit;
}


void EBYTE::SetTransmissionMode(uint8_t val) {
	_OptionTransMode = val;
	BuildOptionByte();
}
uint8_t EBYTE::GetTransmissionMode( ) {
	return _OptionTransMode;
}


void EBYTE::SetTransmitRSSI(uint8_t val) {
	_OptionTransRSSI = val;
	BuildOptionByte();
}
uint8_t EBYTE::GetTransmitRSSI( ) {
	return _OptionTransRSSI;
}


void EBYTE::SetTransmitPower(uint8_t val) {
	_TransPower = val;
	BuildOptionByte();

}
uint8_t EBYTE::GetTransmitPower() {
	return _TransPower;
}


void EBYTE::SetAddress(uint16_t Val) {
	_AddressHigh = ((Val & 0xFFFF) >> 8);
	_AddressLow = (Val & 0xFF);
}
uint16_t EBYTE::GetAddress() {
	return (_AddressHigh << 8) | (_AddressLow );
}



uint8_t EBYTE::GetUARTBaudRate() {
	return _UARTDataRate;
}
void EBYTE::SetUARTBaudRate(uint8_t val) {
	_UARTDataRate = val;
	BuildSpeedByte();
}



// method to build the byte for programming (notice it's a collection of a few variables)
void EBYTE::BuildSpeedByte() {
	_Speed = 0;
	_Speed = ((_UARTDataRate & 0xFF) << 5) | ((_ParityBit & 0xFF) << 3) | (_AirDataRate & 0xFF);
}


//method to build the trans byte for programming (notice it's a collection of a few variables)
void EBYTE::BuildTransByte() {
	_Trans = 0;
	// _Trans = ((00 & 0XFF) << 6) | ((_RSSIAmbientNoise & 0XFF) << 5) | ((000 & 0XFF) << 2) | (_TransPower & 0xFF);
	_Trans = ((_RSSIAmbientNoise & 0XFF) << 5) | (_TransPower & 0xFF);
}

// method to build the option byte for programming (notice it's a collection of a few variables)
void EBYTE::BuildOptionByte() {
	_Options = 0;
	_Options = ((_OptionTransRSSI & 0xFF) << 7) | ((_OptionTransMode & 0xFF) << 6) | ((_OptionLBT & 0xFF) << 4) | (_OptionWORCycle & 0xFF);
}


bool EBYTE::GetAux() {
	return digitalRead(_AUX);
}


/*
method to save parameters to the module
*/

void EBYTE::SaveParameters() {

	SetMode(MODE_PROGRAM);

	// ClearBuffer();

	/*
	Serial.print("val: ");
	Serial.println(val);

	Serial.print("_AddressHigh: ");
	Serial.println(_AddressHigh);

	Serial.print("_AddressLow: ");
	Serial.println(_AddressLow);

	Serial.print("_Speed: ");
	Serial.println(_Speed);

	Serial.print("_Channel: ");
	Serial.println(_Channel);

	Serial.print("_Options: ");
	Serial.println(_Options);
	*/


	_s->write(0xC0);  // write register
	_s->write((byte)0x00);  // starting address, the reason for the (byte) is that the compiler thinks that 0x00 is an integer
	_s->write(0x08);  // length
	_s->write(_AddressHigh);
	_s->write(_AddressLow);
	_s->write(_Speed);
	_s->write(_Trans);
	_s->write(_Channel);
	_s->write(_Options);
	_s->write((byte)0x00);
	_s->write((byte)0x00);

	delay(PIN_RECOVER);

	CompleteTask(4000);

	SetMode(MODE_NORMAL);


}


/*
method to print parameters, this can be called anytime after init(), because init gets parameters
and any method updates the variables
*/

void printSetting(String s, uint8_t val) {
	Serial.print(s);
	Serial.print(val, HEX);
	Serial.print(F("/"));
	Serial.print(val, DEC);
	Serial.print(F("/"));
	Serial.println(val, BIN);
}

void EBYTE::PrintParameters() {

	// _ParityBit = (_Speed & 0XC0) >> 6;
	// _UARTDataRate = (_Speed & 0X38) >> 3;
	// _AirDataRate = _Speed & 0X07;

	// _OptionTrans = (_Options & 0X80) >> 7;
	// _OptionPullup = (_Options & 0X40) >> 6;
	// _OptionWakeup = (_Options & 0X38) >> 3;
	// _OptionFEC = (_Options & 0X07) >> 2;
	// _OptionPower = (_Options & 0X03);




	Serial.println("----------------------------------------");
	Serial.print(F("Model no.: "));  Serial.println(_Model, HEX);
	Serial.print(F("Version  : "));  Serial.println(_Version, HEX);
	Serial.print(F("Features : "));  Serial.println(_Features, HEX);
	Serial.println(F(" "));
	printSetting("Mode (HEX/DEC/BIN): ", _Save);
	printSetting("AddH (HEX/DEC/BIN): ", _AddressHigh);
	printSetting("AddL (HEX/DEC/BIN): ", _AddressLow);
	printSetting("Sped (HEX/DEC/BIN): ", _Speed);
	printSetting("Chan (HEX/DEC/BIN): ", _Channel);
	printSetting("Tran (HEX/DEC/BIN): ", _Trans);
	printSetting("Optn (HEX/DEC/BIN): ", _Options);
	printSetting("Addr (HEX/DEC/BIN): ", GetAddress());
	Serial.println(F(" "));
	printSetting("SpeedParityBit (HEX/DEC/BIN): ", _ParityBit);
	printSetting("SpeedUARTDataRate (HEX/DEC/BIN): ", _UARTDataRate);
	printSetting("SpeedAirDataRate (HEX/DEC/BIN): ", _AirDataRate);
	// printSetting("OptionTrans (HEX/DEC/BIN): ", _OptionTransMode);
	// printSetting("OptionRSSI (HEX/DEC/BIN): ", _OptionRSSI);
	Serial.println(F(" "));
	// printSetting("TransPower (HEX/DEC/BIN): ", _TransPower);
	// printSetting("TransRSSINoise (HEX/DEC/BIN): ", _TransRSSINoise);

	Serial.println("----------------------------------------");

}

/*
method to read parameters,
*/

bool EBYTE::ReadParameters() {

	_Params[0] = 0;
	_Params[1] = 0;
	_Params[2] = 0;
	_Params[3] = 0;
	_Params[4] = 0;
	_Params[5] = 0;
	_Params[6] = 0;
	_Params[7] = 0;

	SetMode(MODE_PROGRAM);

	_s->write(0xC1);  // read register
	_s->write((byte)0x00);  // starting address, the reason for the (byte) is that the compiler thinks that 0x00 is an integer
	_s->write(0x08);  // parameters to read

	_s->readBytes((uint8_t*)&_Params, (uint8_t) sizeof(_Params));

	SetMode(MODE_NORMAL);

	_AddressHigh = _Params[3];
	_AddressLow = _Params[4];
	_Speed = _Params[5];
	_Trans = _Params[6];
	_Channel = _Params[7];
	_Options = _Params[8];

	_Address =  (_AddressHigh) | (_AddressLow >> 8);

	_UARTDataRate = _Speed >> 5;  // First three bits
	_ParityBit = ((_Speed << 3) >> 6) & 0X03; // Two bits
	_AirDataRate = _Speed & 0x07;  // Last 3 bits


	// TODO: Add Sub Packet Setting
	_RSSIAmbientNoise = (_Trans >> 5) & 0x01;
	_TransPower = _Trans & 0x03;


	_OptionTransRSSI = _Options >> 7;
	_OptionTransMode = (_Options >> 6) & 0x1;
	_OptionLBT = (_Options >> 4) & 0x1;
	_OptionWORCycle = _Options & 0x7;
	// TODO: Add encryption setting


	if (_Params[0] != 0xC1){
		return false;
	}

	return true;
}


bool EBYTE::ReadModelData() {

	_Params[0] = 0;
	_Params[1] = 0;
	_Params[2] = 0;
	_Params[3] = 0;
	_Params[4] = 0;
	_Params[5] = 0;

	bool found = false;
	int i = 0;

	SetMode(MODE_PROGRAM);

	_s->write(0xC3);

	_s->write(0xC3);

	_s->write(0xC3);

	_s->readBytes((uint8_t*)& _Params, (uint8_t) sizeof(_Params));

	_Save = _Params[0];
	_Model = _Params[1];
	_Version = _Params[2];
	_Features = _Params[3];

	if (0xC3 != _Params[0]) {

		for (i = 0; i < 5; i++){
			Serial.print("trying: "); Serial.println(i);
			_Params[0] = 0;
			_Params[1] = 0;
			_Params[2] = 0;
			_Params[3] = 0;
			_Params[4] = 0;
			_Params[5] = 0;
			delay(100);

			_s->write(0xC3);

			_s->write(0xC3);

			_s->write(0xC3);

			_s->readBytes((uint8_t*)& _Params, (uint8_t) sizeof(_Params));

			if (0xC3 == _Params[0]){
				found = true;
				break;
			}

		}
	}
	else {
		found = true;
	}

	SetMode(MODE_NORMAL);

	CompleteTask(1000);

	return found;

}

/*
method to get module model and E50-TTL-100 will return 50
*/

uint8_t EBYTE::GetModel() {

	return _Model;

}

/*
method to get module version (undocumented as to the value)
*/

uint8_t EBYTE::GetVersion() {

	return _Version;

}

/*
method to get module version (undocumented as to the value)
*/


uint8_t EBYTE::GetFeatures() {

	return _Features;

}

/*
method to clear the serial buffer

without clearing the buffer, i find getting the parameters very unreliable after programming.
i suspect stuff in the buffer affects rogramming
hence, let's clean it out
this is called as part of the setmode

*/
void EBYTE::ClearBuffer(){

	unsigned long amt = millis();

	while(_s->available()) {
		_s->read();
		if ((millis() - amt) > 5000) {
          Serial.println("runaway");
          break;
        }
	}

}