RH_E32.cpp

// RH_E32.cpp
//
// Copyright (C) 2017 Mike McCauley
// $Id: RH_E32.cpp,v 1.4 2018/11/15 01:10:48 mikem Exp $

#include <RadioHead.h>
#ifdef RH_HAVE_SERIAL // No serial

#include <RH_E32.h>
#include <Stream.h>

RH_E32::RH_E32(Stream *s, uint8_t m0_pin, uint8_t m1_pin, uint8_t aux_pin)
  :
  _s(s),
  _m0_pin(m0_pin),
  _m1_pin(m1_pin),
  _aux_pin(aux_pin)
{
  // Prevent glitches a startup
  pinMode(_aux_pin, INPUT);
  digitalWrite(_m0_pin, true);
  digitalWrite(_m1_pin, true);
  pinMode(_m0_pin, OUTPUT);
  pinMode(_m1_pin, OUTPUT);
}

bool RH_E32::init()
{
  // When a message is available, Aux will go low 5 msec before the first character is output
  // So if we ever wait more than this period of time after Aux low, can conclude there will be no data
  _s->setTimeout(10);

  // Wait until the module is connected
  waitAuxHigh();

  if (!getVersion())
      return false; // Could not communicate with module or wrong type of module
  
  setMode(RHModeRx);
  clearRxBuf();

  if (!setDataRate(DataRate5kbps))
    return false;

  if (!setPower(Power21dBm))
    return false;

  //  if (!setBaudRate(BaudRate9600, Parity8N1))
  //  return false;

  if (!setFrequency(433))
    return false;
  
  return true;
}

bool RH_E32::set_tx_header( uint8_t rx_ADDH, uint8_t rx_ADDL, uint8_t rx_freq, uint8_t tx_ADDH, uint8_t tx_ADDL, uint8_t tx_freq) {
  _rx_ADDH=rx_ADDH;
  _rx_ADDL=rx_ADDL;
  _rx_freq=rx_freq;
  _tx_ADDH=tx_ADDH;
  _tx_ADDL=tx_ADDL;
  _tx_freq=tx_freq;

  //verify
  if (_rx_ADDH==rx_ADDH && _rx_ADDL==rx_ADDL && _rx_freq==rx_freq && _tx_ADDH==tx_ADDH && _tx_ADDL==tx_ADDL && _tx_freq==tx_freq) {
    return 1;
  }
  else {
    return 0;
  }
}

bool RH_E32::print_tx_header () {
  // add spirintft in the end
  Serial.print (_rx_ADDH, DEC);
  Serial.print (_rx_ADDL, DEC);
  Serial.print (_rx_freq, DEC);
  Serial.print (_tx_ADDH, DEC);
  Serial.print (_tx_ADDL, DEC);
  Serial.print (_tx_freq, DEC);
  return 1;
}

bool RH_E32::reset()
{
  setOperatingMode(ModeSleep);
  uint8_t resetCommand[] = { RH_E32_COMMAND_RESET, RH_E32_COMMAND_RESET, RH_E32_COMMAND_RESET };
  size_t result = _s->write(resetCommand, sizeof(resetCommand));
  setOperatingMode(ModeNormal);
  return (result == sizeof(resetCommand));
}

bool RH_E32::readParameters(Parameters& params)
{
  setOperatingMode(ModeSleep);
  uint8_t readParamsCommand[] = { RH_E32_COMMAND_READ_PARAMS, RH_E32_COMMAND_READ_PARAMS, RH_E32_COMMAND_READ_PARAMS };
  _s->write(readParamsCommand, sizeof(readParamsCommand));
  size_t result = _s->readBytes((char*)&params, sizeof(params)); // default 1 sec timeout
  setOperatingMode(ModeNormal);
  return (result == sizeof(Parameters));
}

bool RH_E32::writeParameters(Parameters& params, bool save)
{
  setOperatingMode(ModeSleep);
  params.head = save ? RH_E32_COMMAND_WRITE_PARAMS_SAVE : RH_E32_COMMAND_WRITE_PARAMS_NOSAVE;
  //  printBuffer("writing now", (uint8_t*)&params, sizeof(params));
  size_t result = _s->write((uint8_t*)&params, sizeof(params));
  if (result != sizeof(params))
    return false;
  
  // Now we expect to get the same data back
  result = _s->readBytes((char*)&params, sizeof(params));
  if (result != sizeof(params))
    return false;
  //    printBuffer("additional read", (uint8_t*)&params, sizeof(params));
  // Without a little delay here, writing params often fails
  delay(20);
  
  setOperatingMode(ModeNormal);
  return result == sizeof(params);
}

void RH_E32::setOperatingMode(OperatingMode mode)
{
  waitAuxHigh();
  switch (mode)
    {
    case ModeNormal:
      digitalWrite(_m0_pin, false);
      digitalWrite(_m1_pin, false);
      break;
      
    case ModeWakeUp:
      digitalWrite(_m0_pin, true);
      digitalWrite(_m1_pin, false);
      break;
      
    case ModePowerSaving:
      digitalWrite(_m0_pin, false);
      digitalWrite(_m1_pin, true);
      break;
      
    case ModeSleep:
      digitalWrite(_m0_pin, true);
      digitalWrite(_m1_pin, true);
      break;
      
    }
  delay(10); // Takes a little while to start its response
  waitAuxHigh();
}

bool RH_E32::getVersion()
{
  setOperatingMode(ModeSleep);
  uint8_t readVersionCommand[] = { RH_E32_COMMAND_READ_VERSION, RH_E32_COMMAND_READ_VERSION, RH_E32_COMMAND_READ_VERSION };
  _s->write(readVersionCommand, sizeof(readVersionCommand));
  uint8_t version[4];
  size_t result = _s->readBytes((char *)version, sizeof(version)); // default 1 sec timeout
  setOperatingMode(ModeNormal);
  if (result == 4)
    {
      // Successful read
      printBuffer("read version", version, sizeof(version));
      if (version[0] != 0xc3 || version [1] != 0x32)
	{
	  // Not an E32
	  return false;
	}
      else
	{
	  // REVISIT: do something with it?
	}
    }
  else
    {
      // Read failed: no module? Wrong baud?
      return false;
    }
  return true;
}

void RH_E32::waitAuxHigh()
{
  // REVISIT: timeout needed?
  while (digitalRead(_aux_pin) == false)
    ;
}

void RH_E32::waitAuxLow()
{
  while (digitalRead(_aux_pin) == true)
    ;
}

// Check whether the latest received message is complete and uncorrupted
void RH_E32::validateRxBuf()
{
    if (_bufLen < RH_E32_RECV_HEADER_LEN)
	     return; // Too short to be a real message
    if (_bufLen != _buf[0]) {
      return; // Do we have all the message?
    } else {
      _rxGood++;
      _rxBufValid = true;
    }	 
}

void RH_E32::clearRxBuf()
{
    _rxBufValid = false;
    _bufLen = 0;
}

bool RH_E32::available()
{
    // Caution: long packets could be sent in several bursts
    if (!_rxBufValid)
    {
	if (_mode == RHModeTx)
	  return false;

	if (!_s->available())
	  return false;

	// Suck up all the characters we can
	uint8_t data;
	while (_s->readBytes((char *)&data, 1) == 1) // Not read timeout
	  {
	    _buf[_bufLen++] = data;
	  }
	// Now assess what we have
	if (_bufLen < RH_E32_RECV_HEADER_LEN)
	  {
	    	    Serial.println("Incomplete header");
	    return false;
	  }
	else if (_bufLen < _buf[0])
	  {
	    	    Serial.println("Incomplete message");
	    return false;
	  }
	else if (   _bufLen > _buf[0]
		 || _bufLen > RH_E32_MAX_PAYLOAD_LEN)
	  {
	    	    Serial.println("Overrun");
	    clearRxBuf();
	    _rxBad++;
	    return false;
	  }

	// Else it a partial or complete message, test it
	//	printBuffer("read success", _buf, _bufLen);
	validateRxBuf(); 
    }
    return _rxBufValid;
}

bool RH_E32::recv(uint8_t* buf, uint8_t* len)
{
    if (!available())
	return false;
    if (buf && len)
    {
	// Skip the 4 headers that are at the beginning of the rxBuf
	if (*len > _bufLen - RH_E32_RECV_HEADER_LEN)
	    *len = _bufLen - RH_E32_RECV_HEADER_LEN;
	memcpy(buf, _buf + RH_E32_RECV_HEADER_LEN, *len);
    }
    clearRxBuf(); // This message accepted and cleared
    return true;
}

bool RH_E32::send(const uint8_t* data, uint8_t len)
{
  if (len > RH_E32_MAX_MESSAGE_LEN)
    return false;

  waitPacketSent(); // Make sure we dont collide with previous message

  //E32 TTL messsage addresing frame
  _buf[0] = _rx_ADDH; 
  _buf[1] = _rx_ADDL;
  _buf[2] = _rx_freq;
  //verification buf_length
  //visible message data
  _buf[3] = len + RH_E32_RECV_HEADER_LEN; 
  _buf[4] = _tx_ADDH;
  _buf[5] = _tx_ADDL;
  _buf[6] = _tx_freq;


  // REVISIT: do we really have to do this? perhaps just write it after writing the header?
  memcpy(_buf+RH_E32_SEND_HEADER_LEN, data, len);

  _s->write(_buf, len + RH_E32_SEND_HEADER_LEN);

  setMode(RHModeTx);
  _txGood++;
  // Aux will return high when the TX buffer is empty
  
  return true;
}

uint8_t RH_E32::maxMessageLength()
{
  return RH_E32_MAX_MESSAGE_LEN;
}

bool RH_E32::waitPacketSent()
{
  if (_mode == RHModeTx)
    waitAuxHigh();
  setMode(RHModeRx);
  return true;
}

bool RH_E32::setDataRate(DataRate rate)
{
  Parameters params;
  if (!readParameters(params))
    return false;
  // The DataRate enums are the same values as the register bitmasks
  params.sped &= ~RH_E32_PARAM_SPED_DATARATE_MASK;
  params.sped |= (rate & RH_E32_PARAM_SPED_DATARATE_MASK);
  return writeParameters(params);
}

bool RH_E32::setPower(PowerLevel level)
{
  Parameters params;
  if (!readParameters(params))
    return false;
  // The DataRate enums are the same values as the register bitmasks
  params.option &= ~RH_E32_PARAM_OPTION_POWER_MASK;
  params.option |= (level & RH_E32_PARAM_OPTION_POWER_MASK);
  return writeParameters(params);
}

bool RH_E32::setBaudRate(BaudRate rate, Parity parity)
{
  Parameters params;
  if (!readParameters(params))
    return false;
  // The DataRate enums are the same values as the register bitmasks
  params.sped &= ~RH_E32_PARAM_SPED_UART_BAUD_MASK;
  params.sped |= (rate & RH_E32_PARAM_SPED_UART_BAUD_MASK);

  // Also set the parity
  params.sped &= ~RH_E32_PARAM_SPED_UART_MODE_MASK;
  params.sped |= (parity & RH_E32_PARAM_SPED_UART_MODE_MASK);
  
  return writeParameters(params);
}


bool RH_E32::setFrequency(uint16_t frequency)
{
  if (frequency < 410 || frequency > 441)
    return false;
  
  Parameters params;
  if (!readParameters(params))
    return false;
  params.chan = frequency - 410;
  return writeParameters(params);
  
}

#endif // RH_PLATFORM_ATTINY