C++ API for the HMTRP Serial RF Pro. More...

Detailed Description

ID: hmtrp
Name: Grove Serial RF Pro
Other Names: HMTRP-433 HMTRP-470 HMTRP-868 HMTRP-915
Category: wifi
Manufacturer: seeed
Connection: uart

UPM support for the HMTRP Serial RF Pro. This was tested specifically with the Grove Serial RF Pro module. In theory, this class should work with the following devices:

HM-TRP-433: 414000000-454000000Hz HM-TRP-470: 450000000-490000000Hz HM-TRP-868: 849000000-889000000Hz HM-TRP-915: 895000000-935000000Hz

The only difference being the transmit and receive frequencies supported.

By default, the device will simply send and receive any data presented on it's UART interface. It can be placed into a configuration mode by grounding the CONFIG pin on the module.

  // Instantiate a HMTRP radio device on uart 0
  upm::HMTRP* radio = new upm::HMTRP(0);
  // make sure port is initialized properly.  9600 baud is the default.
  if (!radio->setupTty(B9600))
    {
      cerr << "Failed to setup tty port parameters" << endl;
      return 1;
    }
  printUsage();
  // By default, this radio simply transmits data sent via writeData()
  // and reads any available data via readData().
  // It can be placed into a configuration mode by grounding the
  // CONFIG pin on the module.  When this is done, the various
  // configuration query and config methods can be used.  In this
  // example, by default, we just read any data available fom the
  // device, and periodically transmit "Hello World".
  // If any argument was specified on the command line, do a simple
  // configuration query and output the results.  The radio must be in 
  // CONFIG mode for this to work.
  if (argc > 1)
    {
      // config mode
      uint32_t freq;
      uint32_t dataRate;
      uint16_t rxBandwidth;
      uint8_t modulation;
      uint8_t txPower;
      uint32_t uartBaud;
      
      if (radio->getConfig(&freq, &dataRate, &rxBandwidth, &modulation,
                           &txPower, &uartBaud))
        {
          cout << "Radio configuration:" << endl;
          cout << "freq: " << freq << " dataRate: " << dataRate 
               << " rxBandwidth: " << rxBandwidth << "Khz" << endl;
          
          cout << "modulation: " << int(modulation) << "Khz txPower: " 
               << int(txPower) << " uartBaud: " << uartBaud << endl;
        }
      else
        {
          cerr << "getConfig() failed.  Make sure the radio is in "
               << "CONFIG mode." << endl;
        }
    }
  else
    {
      // normal read/write mode
      char radioBuffer[bufferLength];
      int counter = 0;
      cout << "Running in normal read/write mode." << endl;
      while (shouldRun)
        {
          // we don't want the read to block in this example, so always
          // check to see if data is available first.
          if (radio->dataAvailable())
            {
              int rv = radio->readData(radioBuffer, bufferLength);
              
              if (rv > 0)
                cout << "Received: " << radioBuffer << endl;
              
              if (rv < 0) // some sort of read error occured
                {
                  cerr << "Port read error." << endl;
                  break;
                }
              
              continue;
            }
          
          usleep(100000); // 100ms
          counter++;
          // every second, transmit "Hello World"
          if (counter > 10)
            {
              static const char *hello = "Hello World!";
              cout << "Transmitting hello world..." << endl;
              radio->writeData((char *)hello, strlen(hello) + 1);
              counter = 0;
            }
        }
    }

Public Types
enum	HMTRP_OPCODE_T { RESET = 0xf0, GET_CONFIG = 0xe1, SET_FREQUENCY = 0xd2, SET_RF_DATARATE = 0xc3, SET_RX_BW = 0xb4, SET_FREQ_MODULATION = 0xa5, SET_TX_POWER = 0x96, SET_UART_SPEED = 0x1e, GET_RF_SIGNAL_STR = 0xa7, GET_MOD_SIGNAL_STR = 0x78 }

Public Member Functions
	HMTRP (int uart=HMTRP_DEFAULT_UART)

	~HMTRP ()

bool	dataAvailable (unsigned int millis=0)

int	readData (char *buffer, size_t len, int millis=-1)

int	writeData (char *buffer, size_t len)

bool	setupTty (speed_t baud=B9600)

bool	checkOK ()

bool	reset ()

bool	getConfig (uint32_t freq, uint32_t dataRate, uint16_t rxBandwidth, uint8_t modulation, uint8_t txPower, uint32_t uartBaud)

bool	setFrequency (uint32_t freq)

bool	setRFDataRate (uint32_t rate)

bool	setRXBandwidth (uint16_t rxBand)

bool	setFrequencyModulation (uint8_t modulation)

bool	setTransmitPower (uint8_t power)

bool	setUARTSpeed (uint32_t speed)

bool	getRFSignalStrength (uint8_t *strength)

bool	getModSignalStrength (uint8_t *strength)

Constructor & Destructor Documentation

HMTRP ( int uart = HMTRP_DEFAULT_UART )

HMTRP Serial RF Pro module constructor

Parameters

uart	default uart to use (0 or 1)

~HMTRP ( )

HMTRP Serial RF Pro module Destructor

Member Function Documentation

bool dataAvailable ( unsigned int millis = 0 )

Check to see if there is data available for reading

Parameters

millis number of milliseconds to wait, 0 means no wait (default).

Returns: true if there is data available to be read

int readData	(	char *	buffer,
		size_t	len,
		int	millis = `-1`
	)

read any available data into a user-supplied buffer.

Parameters

buffer	the buffer to hold the data read
len	the length of the buffer
millis	maxim time in milliseconds to wait for input. -1 means wait forever (default).

Returns: the number of bytes read, 0 if timed out and millis >= 0

int writeData	(	char *	buffer,
		size_t	len
	)

write the data in buffer to the device

Parameters

buffer	the buffer to hold the data read
len	the length of the buffer

Returns: the number of bytes written

bool setupTty ( speed_t baud = B9600 )

setup the proper tty i/o modes and the baudrate. The default baud rate is 9600 (B9600).

Parameters

baud	the desired baud rate.

Returns: true if successful

bool checkOK ( )

Look for and verify an OK response. This will look like "OK\r\n"

Returns: true if OK received

bool reset ( )

reset the device to default parameters, except for UART baud rate

Returns: true if successful

bool getConfig	(	uint32_t *	freq,
		uint32_t *	dataRate,
		uint16_t *	rxBandwidth,
		uint8_t *	modulation,
		uint8_t *	txPower,
		uint32_t *	uartBaud
	)

Query the radio to determine it's configuration

Parameters

freq	operating frequency
dataRate	tx/rx bit rate
rxBandwidth	receiving bandwidth in Khz
modulation	modulation frequency in Khz
txPower	transmission power (1-7)
uartBaud	UART baud rate

Returns: true if successful

bool setFrequency ( uint32_t freq )

set the frequency. Note, this is limited depending on which HM-TRP device you are using. Consult the datasheet.

Parameters

freq	operating frequency

Returns: true if successful

bool setRFDataRate ( uint32_t rate )

set the RF data transmission rate. Valid values are between 1200-115200.

Parameters

rate	radio transmission rate in baud (1200-115200)

Returns: true if successful

bool setRXBandwidth ( uint16_t rxBand )

set the RX bandwidth. Valid values are between 30-620 (in Khz)

Parameters

rxBand set receive bandwidth (30-620) Khz

Returns: true if successful

bool setFrequencyModulation ( uint8_t modulation )

set the frequency modulation. Valid values are between 10-160 (in Khz)

Parameters

modulation frequency modulation to use (10-160) Khz

Returns: true if successful

bool setTransmitPower ( uint8_t power )

set the transmit power level. Valid values are between 0-7, with 7 being maximum power.

Parameters

power power level to use during transmit. Vaild values are between 0-7.

Returns: true if successful

bool setUARTSpeed ( uint32_t speed )

set the configured baud rate of the UART. It is strongly recommended that you do not change this or you may lose the ability to communicate with the module. Valid values are 1200-115200.

Parameters

speed desired baud rate to configure the device to use. Valid values are between 1200-115200.

Returns: true if successful

bool getRFSignalStrength ( uint8_t * strength )

get the RF signal strength.

Parameters

strength the returned strength

Returns: true if successful

bool getModSignalStrength ( uint8_t * strength )

get the Modulation signal strength.

Parameters

strength the returned strength

Returns: true if successful

The documentation for this class was generated from the following files:

/var/lib/jenkins/workspace/upm-doc-stable/src/hmtrp/hmtrp.h
/var/lib/jenkins/workspace/upm-doc-stable/src/hmtrp/hmtrp.cxx

Detailed Description

Public Types

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation