CC1101.cpp

Go to the documentation of this file.

#include "CC1101.hh"

#if !defined(BOARD_ATTINYX5)

#include "Cosa/Power.hh"
#include "Cosa/RTT.hh"

#if defined(BOARD_ATTINY)
#define PIN PINA
#else
#define PIN PINB
#endif

const uint8_t CC1101::config[CC1101::CONFIG_MAX] __PROGMEM = {
  0x47,         // GDO2 Output Pin Configuration
  0x2E,         // GDO1 Output Pin Configuration
  0x2E,         // GDO0 Output Pin Configuration
  0x07,         // RX FIFO and TX FIFO Thresholds
  0xC0,         // Synchronization word, high byte
  0x5A,         // Synchronization word, low byte
  0x3D,         // Packet Length, 61 bytes
  0x06,         // Packet Automation Control
  0x45,         // Packet Automation Control
  0xFF,         // Device Address
  0x00,         // Channel Number
  0x08,         // Frequency Synthesizer Control
  0x00,         // Frequency Synthesizer Control
  0x10,         // Frequency Control Word, High Byte
  0xA7,         // Frequency Control Word, Middle Byte
  0x62,         // Frequency Control Word, Low Byte
  0xCA,         // Modem Configuration
  0x83,         // Modem Configuration
  0x93,         // Modem Configuration
  0x22,         // Modem Configuration
  0xF8,         // Modem Configuration
  0x35,         // Modem Deviation Setting
  0x07,         // Main Radio Control State Machine Configuration
  0x30,         // Main Radio Control State Machine Configuration
  0x18,         // Main Radio Control State Machine Configuration
  0x16,         // Frequency Offset Compensation Configuration
  0x6C,         // Bit Synchronization Configuration
  0x43,         // AGC Control
  0x40,         // AGC Control
  0x91,         // AGC Control
  0x87,         // High Byte Event0 Timeout
  0x6B,         // Low Byte Event0 Timeout
  0xFB,         // Wake On Radio Control
  0x56,         // Front End RX Configuration
  0x10,         // Front End TX Configuration
  0xE9,         // Frequency Synthesizer Calibration
  0x2A,         // Frequency Synthesizer Calibration
  0x00,         // Frequency Synthesizer Calibration
  0x1F,         // Frequency Synthesizer Calibration
  0x41,         // RC Oscillator Configuration
  0x00          // RC Oscillator Configuration
};

void
CC1101::IRQPin::on_interrupt(uint16_t arg)
{
  UNUSED(arg);
  if (m_rf == 0) return;
  m_rf->m_avail = true;
}

CC1101::CC1101(uint16_t net, uint8_t dev,
               Board::DigitalPin csn,
               Board::ExternalInterruptPin irq) :
  SPI::Driver(csn, SPI::ACTIVE_LOW, SPI::DIV4_CLOCK, 0, SPI::MSB_ORDER, &m_irq),
  Wireless::Driver(net, dev),
  m_irq(irq, ExternalInterrupt::ON_FALLING_MODE, this),
  m_status(0)
{
}

void
CC1101::strobe(Command cmd)
{
  spi.acquire(this);
    spi.begin();
      loop_until_bit_is_clear(PIN, Board::MISO);
      m_status = spi.transfer(header_t(cmd, 0, 0));
    spi.end();
  spi.release();
}

void
CC1101::await(Mode mode)
{
  while (read_status().mode != mode) DELAY(100);
}

bool
CC1101::begin(const void* config)
{
  // Reset the device
  m_cs.pulse(30);
  DELAY(30);
  strobe(SRES);
  DELAY(300);

  // Upload the configuration. Check for default configuration
  spi.acquire(this);
    spi.begin();
    loop_until_bit_is_clear(PIN, Board::MISO);
    write_P(IOCFG2,
            config ? (const uint8_t*) config : CC1101::config,
            CONFIG_MAX);
    spi.end();

    // Adjust configuration with instance specific state
    uint16_t sync = hton(m_addr.network);
    spi.begin();
      loop_until_bit_is_clear(PIN, Board::MISO);
      write(PATABLE, 0x60);
      write(CHANNR, m_channel);
      write(ADDR, m_addr.device);
      write(SYNC1, &sync, sizeof(sync));
    spi.end();
  spi.release();

  // Initiate device driver state and enable interrupt handler
  strobe(SCAL);
  m_avail = false;
  spi.attach(this);
  m_irq.enable();
  return (true);
}

bool
CC1101::end()
{
  // Fix: Should be state-based disable/enable
  m_irq.disable();
  powerdown();
  return (true);
}

int
CC1101::send(uint8_t dest, uint8_t port, const iovec_t* vec)
{
  // Sanity check the payload size
  if (UNLIKELY(vec == NULL)) return (EINVAL);
  size_t len = iovec_size(vec);
  if (UNLIKELY(len > PAYLOAD_MAX)) return (EMSGSIZE);

  // Write frame length and header(dest, src, port) and payload buffers
  spi.acquire(this);
    spi.begin();
      loop_until_bit_is_clear(PIN, Board::MISO);
      m_status = spi.transfer(header_t(TXFIFO, 1, 0));
      spi.transfer(len + 3);
      spi.transfer(dest);
      spi.transfer(m_addr.device);
      spi.transfer(port);
      spi.write(vec);
    spi.end();
  spi.release();

  // Trigger transmission and wait for completion
  strobe(STX);
  await(IDLE_MODE);

  return (len);
}

int
CC1101::send(uint8_t dest, uint8_t port, const void* buf, size_t len)
{
  iovec_t vec[2];
  iovec_t* vp = vec;
  iovec_arg(vp, buf, len);
  iovec_end(vp);
  return (send(dest, port, vec));
}

int
CC1101::recv(uint8_t& src, uint8_t& port, void* buf, size_t len, uint32_t ms)
{
  uint32_t start = RTT::millis();
  uint8_t size;

  // Put in receive mode and wait for incoming message
  strobe(SFRX);
  strobe(SRX);
  m_avail = false;
  do {
    while (!m_avail && ((ms == 0) || (RTT::since(start) < ms))) yield();
    if (!m_avail) {
      strobe(SIDLE);
      return (ETIME);
    }
    // Check the received frame size
    spi.acquire(this);
      spi.begin();
        loop_until_bit_is_clear(PIN, Board::MISO);
        size = read(RXBYTES);
      spi.end();
    spi.release();
  } while ((size & BYTES_MASK) == 0);

  // Put in idle mode and read the payload
  strobe(SIDLE);

  // Read the payload size and check against buffer length
  spi.acquire(this);
    spi.begin();
      loop_until_bit_is_clear(PIN, Board::MISO);
      m_status = spi.transfer(header_t(RXFIFO, 1, 1));
      size = spi.transfer(0) - 3;
      if (size > len) {
        spi.end();
        spi.release();
        strobe(SFRX);
        return (EMSGSIZE);
      }

      // Read the frame header(dest, src, port), payload and link quality status
      m_dest = spi.transfer(0);
      src = spi.transfer(0);
      port = spi.transfer(0);
      spi.read(buf, size);
      spi.read(&m_recv_status, sizeof(m_recv_status));
    spi.end();
  spi.release();

  // Fix: Add address checking for robustness
  return (size);
}

void
CC1101::powerdown()
{
  await(IDLE_MODE);
  strobe(SPWD);
}

void
CC1101::wakeup_on_radio()
{
  await(IDLE_MODE);
  strobe(SWOR);
}

void
CC1101::output_power_level(int8_t dBm)
{
  uint8_t pa = 0xC0;
  if      (dBm < -20) pa = 0x12;
  else if (dBm < -15) pa = 0x0E;
  else if (dBm < -10) pa = 0x1D;
  else if (dBm < 0)   pa = 0x34;
  else if (dBm < 5)   pa = 0x60;
  else if (dBm < 7)   pa = 0x84;
  else if (dBm < 10)  pa = 0xC4;
  spi.acquire(this);
    spi.begin();
      loop_until_bit_is_clear(PIN, Board::MISO);
      write(PATABLE, pa);
    spi.end();
  spi.release();
}

int
CC1101::input_power_level()
{
  int rssi = m_recv_status.rssi;
  return (((rssi < 128) ? rssi : rssi - 256) / 2 - 74);
}
#endif