ti1101.c

#include "main-header.h"
#include "ti1101-settings.h"
#include "led.h"
#include "ti1101-pinconfig.h"
#include "networkif.h"
#include "ti1101.h"
#include "irq_router.h"
#include "metrics/metrics.h"
 
#define ENDMARK (0)
#define TI1101_BURST 0x40
#define TI1101_READ 0x80
 
static long forwardto = 0;
static struct network_context *nctx;
static byte ti1101_enabled = 1;
static byte overflowed = 0;
static byte ti1101_failed = 0;
static byte need_reset;
static byte ti1101_isready = 0;
static byte laststatus;
static byte last_irq_error = 0;
static byte last_packet_rssi = 0;
volatile byte ti1101_in_read_loop = 0;
volatile byte ti1101_locked = 0;
 
const char *decode_marcstate(int state);
static int ti1101_reset();
int ti1101_compare_config();
static void ti1101_select();
static void ti1101_deselect();
static int ti1101_read_register(byte offset);
static int ti1101_read_status_register(byte offset);
static void ti1101_config_init();
static byte ti1101_debug = 0;
 
// see page 93 cc1101 reference manual
const char *statetable[] = {
  "SLEEP",
  "IDLE",
  "XOFF",
  "VCOON_MC",
  "REGON_MC",
  "MANCAL",
  "VCOON",
  "REGON",
  "STARTCAL",
  "BWBOOST",
  "FS_LOCK",
  "IFADCON",
  "ENDCAL",
  "RX",
  "RX_END",
  "RX_RST",
  "TXRX_SWITCH",
  "RXFIFO_OVERFLOW",
  "FSTXON",
  "TX",
  "TX_END",
  "RXTX_SWITCH",
  "TXFIFO_UNDERFLOW",
  NULL
};
 
static int config_entries;
static byte current_config[102];
 
#define CHECK_TI1101_FAILURE if (ti1101_failed) { ti1101_failure(); return; }
#define CHECK_TI1101_FAILURE_S if (ti1101_failed) { ti1101_failure(); printf("TI1101 failed\r\n"); return; }
#define CHECK_TI1101_FAILURE_V if (ti1101_failed) { ti1101_failure(); return 0; }
void ti1101_failure() {
  ;
}
void ti1101_set_debug(byte b) {
  ti1101_debug = b;
  printf("TI1101: debug enabled\r\n");
}
static void lock_failure() {
  printf("TI1101 lock() timeout!!\r\n");
}
 
static byte tx = 0;
static int ti1101_write_and_read(int data) {
  if (!ti1101_enabled) {
    return 0;
  }
  tx = 1;
  uint16_t res;
 
  mculib_spi_write_and_read(nctx->mculib_handle, ti1101_spiport(), data, &res); // ti1101-spi port
  tx = 0;
  return res;
}
static int spi_is_transmitting() {
  return tx;
}
 
static int ti1101_write(byte data) {
  if (!ti1101_enabled) {
    return 0;
  }
  tx = 1;
  if (mculib_spi_write_only(nctx->mculib_handle, ti1101_spiport(), data) != 0) {
    tx = 0;
    return -1;
  }
  tx = 0;
  return 0;
}
 
 
int ti1101_lock() {
  long started = mculib_get_seconds_since_boot();
 
  while (ti1101_in_read_loop) {
    if ((mculib_get_seconds_since_boot() - started) > 5) {
      // more than 5 seconds passed when trying to lock it!
      lock_failure();
      return 0;
    }
    // wait
    //mculib_pin_toggle(LED_YELLOW);
  }
  ti1101_locked = 1;
  return 1;
}
void ti1101_unlock() {
  ti1101_locked = 0;
}
 
/*
 * \brief high-level function to reset the ti1101
 *
 * configures all the registers.
 * returns 0 if ok, otherwise an errorcode
 */
int internal_ti1101_init(struct network_context *onctx) {
  int r;
 
  nctx = onctx;
  ti1101_config_init();
  if ((r = mculib_spi_master_enable(nctx->mculib_handle, ti1101_spiport(), 1, SPI_DIR_RW))) {
    printf("Could not enable spi: %i\r\n", r);
    return 2;
  }
  if ((r = mculib_pin_out(nctx->mculib_handle, ti1101_cssns(), HAL_PIN_SLOWEST))) {
    printf("Could not enable CSSNS pin: %i\r\n", r);
    return 2;
  }
 
 
  int er = 0;
 
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 1);
  ti1101_failed = 0;
  need_reset = 1;
  if (!ti1101_lock()) {
    printf("Failed to lock ti1101 (init) - exit");
    ti1101_failed = 1;
    need_reset = 1;
    return 12;
  }
  ti1101_in_read_loop = 0;
  ti1101_isready = 0;
  IPLOG("ti1101_on...");
  ti1101_deselect(); // disable it (re-enable when reading/writing)
  ti1101_on();
  IPLOG("OK.");
  //ti1101_compare_config();
  er = ti1101_reset();
  ti1101_unlock();
  if ((er) || (ti1101_failed)) {
    printf("ti1101 failed on spi %i, cssns pin %i\r\n", ti1101_spiport(), ti1101_cssns());
    return 1;
  }
  return 0;
}
 
// switch the CSn/NSS for the CC1101 off
void ti1101_select() {
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 0);
  /* see page29 of cc1101 reference manual:
   * "When CSn is pulled low, the MCU must wait
   * until CC1101 SO pin goes low before starting to
   * transfer the header byte."
   */
  //Delay(10); // wait for S0 to go low. do i really need another pin for that???
}
 
// switch the CSn/NSS for the CC1101 on
void ti1101_deselect() {
  CHECK_TI1101_FAILURE
 
  // always wait for transmission to end before we deselect our chip
  long secs = mculib_get_seconds_since_boot();
 
  while (spi_is_transmitting()) {
    if ((mculib_get_seconds_since_boot() - secs) > 2) {
      ti1101_failed = 1;
      break;
    }
  }
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 1);
}
 
int ti1101_tx() {
  CHECK_TI1101_FAILURE_V
  return ti1101_write(0x35);                   // strobe STX
}
void ti1101_rx() {
  CHECK_TI1101_FAILURE
  ti1101_write(0x3a);                           // strobe flush RX
  ti1101_write(0x36);                           // strobe SIDLE
  ti1101_write(0x34);                           // strobe SRX
}
 
/*
 * \brief low-level function to reset the ti1101
 *
 * configures all the registers.
 * Note that we check the configuration afterwards.
 * if all registers are 0, we consider this an error,
 * because usually it means there's nothing connected
 * returns 0 if ok, otherwise an errorcode
 */
static int ti1101_reset() {
  if (config_get_ti1101disable()) {
    return 0;
  }
  if (!ti1101_enabled) {
    return 0;
  }
  ti1101_disable_irq(nctx);
 
  ti1101_failed = 0;
  if (!ti1101_lock()) {
    printf("Failed to lock ti1101 (reset)- exit");
    ti1101_failed = 1;
    return 12;
  }
 
  need_reset = 1;
  overflowed = 0;
  IPLOG("Resetting ti1101...\r\n");
  int i = 0;
 
  ti1101_select();
  i = mculib_spi_write_only(nctx->mculib_handle, ti1101_spiport(), 0x30);   // strobe reset
  if (i != 0) {
    printf("Failed to write to spi: %i\r\n", i);
    ti1101_failed = 1;
    return 16;
  }
  Delay(20);
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 1);
  printf("Strobe reset done\r\n");
  // ti1101_deselect(); // hangs because it keeps transmitting?? weird.
  Delay(10);                            // no ti select/deselect reset wait .1s
  ti1101_select();
  byte fail = 0;
 
  CNWDEBUG("ti1101 selected()");
  i = 0;
  for (;;) {
    byte offset = current_config[i++];
    byte value = current_config[i++];
    if ((offset == ENDMARK) && (value == ENDMARK)) {
      break;
    }
    //IPLOG("Register %x: %x\r\n", (int)offset, (int)value);
    if (ti1101_write(offset) == -1) {
      fail++;
    }
    if (ti1101_write(value) == -1) {
      fail++;
    }
    if (fail > 10) {
      ti1101_failed = 1;
      break;
    }
  }
 
  ti1101_rx();
  ti1101_deselect();
 
  CNWDEBUG("ti1101 deselected()");
 
  ti1101_isready = 1;
 
  if (ti1101_failed) {
    ti1101_unlock();
    printf("TI1101 failed to reset\r\n");
    return 1;
  }
  int er = ti1101_compare_config();
 
  ti1101_unlock();
  if (er) {
    printf("TI1101 failed config check after reset\r\n");
    return 2;
  }
  ti1101_enable_irq();
  need_reset = 0;
  printf("TI1101 was reset (%i)\r\n", ti1101_failed);
 
  return 0;
}
 
 
 
// read all registers, print out those that do not match configuration
void ti1101_print_config() {
  CHECK_TI1101_FAILURE_S
  int i = 0;
 
  for (i = 0; i < 0x30; i++) {
    int v = ti1101_read_register(i);
    IPLOG("Register %x == %x\r\n", i, v);
    v++; // in case iplog is a noop
  }
}
int ti1101_compare_config() {
  CHECK_TI1101_FAILURE_V
  int i = 0;
 
  IPLOG("Checking config...\r\n");
  long start = mculib_get_seconds_since_boot();
  int nonzero = 0;
  int okvalues = 0;
  int failvalues = 0;
 
  for (;;) {
    if ((mculib_get_seconds_since_boot() - start) > 3) {
      return 1;
    }
    byte offset = current_config[i++];
    byte value = (int)current_config[i++];
    if ((offset == ENDMARK) && (value == ENDMARK)) {
      break;
    }
    //printf("Reading %i ",offset);
    int v2 = (int)value;
    int v = ti1101_read_register(offset);
    //printf(" == %i\r\n",v);
    if (v != 0) {
      nonzero++;
    }
    if (v != v2) {
      failvalues++;
      //      IPLOG("Register %x should be %x and is %x \r\n", (int)offset, v2, v);
    } else {
      okvalues++;
    }
  }
  IPLOG("cc1101: Config check done (%i, ok=%i,fail=%i)\r\n", nonzero, okvalues, failvalues);
  if (failvalues > okvalues) {
    return 1;
  }
  if (nonzero) {
    return 0;
  }
  return 1;
}
static int ti1101_send(int num_bytes, const byte *data) {
  if ((!ti1101_enabled) || (config_get_ti1101disable())) {
    IPLOG("Not sending via radio - radio is not enabled\r\n");
    return 1;
  }
  CHECK_TI1101_FAILURE_V
  if (need_reset) {
    return 2;
  }
  if (num_bytes == 0) {
    IPLOG("Reject request to send 0 bytes\r\n");
    return 3;
  }
  if (!ti1101_lock()) {
    printf("Failed to lock ti1101 (sending) - exit");
    ti1101_failed = 1;
    return 4;
  }
 
  IPLOG("Sending %i bytes via cc1101\r\n", num_bytes);
  ti1101_select();
  ti1101_write(0x36);                           // strobe SIDLE
  ti1101_write(0x3b);                           // strobe FLUSH TX FIFO
  int i = 0;
 
  ti1101_write(TI1101_BURST | 0x3f);
  ti1101_write((byte)num_bytes);
  for (i = 0; i < num_bytes; i++) {
    int r = ti1101_write(data[i]);
    //IPLOG("i=%i,state=0x%x\r\n",i,r);
    if ((r & 0x0F) < 4) {
      break;
    }
  }
  ti1101_deselect();    // end burst
  ti1101_select();      // and start
  ti1101_tx();          // transmission
 
  //are there more bytes to send? (than fit into txfifo)
  for (i++; i < num_bytes; i++) {
    ti1101_write(0x3f);  // send the data (no burst though)
    int r = ti1101_write(data[i]);
    int txf;
    // if less than 4 bytes reported by
    // chip status byte, we force the readloop of the
    // txbytes register until more bytes are available
    txf = ((r & 0x0F) < 4) ? 70 : 50;
 
    while (txf > 60) {
      // TODO: add timeout/error handling here
      txf = ti1101_read_status_register(0x3A); // bytes in txfifo
      //IPLOG("i=%i,txf=%i,state=0x%x\r\n",i,txf,r);
    }
  }
 
  int marcstate;
 
  reset_delay_counter(DELAY_TI1101);
  while (
    ((marcstate = ti1101_read_status_register(0x35)) != 0)
    && (marcstate != 13)
    && (marcstate != 1)
    && (marcstate != 22)
    ) {
    if (get_delay_counter(DELAY_TI1101) > 500) {
      IPLOG("Timeout in TX, marcstate= %s (%i) - ti1101 reset triggered\r\n", decode_marcstate(marcstate), marcstate);
      need_reset = 1;
      ti1101_select();
      break;
    }
    // in this case we remain in this loop as long as the chip has not transitioned to an after-tx state
  }
 
  ti1101_deselect();    // exit from burst or tx mode
  Delay(1);             // give it a chance to see it
  ti1101_select();
  ti1101_rx();
  ti1101_deselect();
  IPLOG("Sending done (marcstate=%s).\r\n", decode_marcstate(marcstate));
  ti1101_unlock();
  ti1101_print_status();
  IncMetric_PKTS_RADIO_CTR_OUT;
  return 0;
}
 
 
// read register, add burst-read, return value or -1 if error
int ti1101_read_status_register(byte offset) {
  int i;
 
  if ((offset < 0x30) || (offset > 0x3F)) {
    IPLOG("Warning! %x register is not a valid status register read\r\n", offset);
  }
  byte reg = TI1101_BURST | TI1101_READ | offset;
 
  laststatus = ti1101_write_and_read(reg);
  i = ti1101_write_and_read(0);
  return i;
}
 
// read register, return value or -1 if error
int ti1101_read_register(byte offset) {
  CHECK_TI1101_FAILURE_V
  if (offset >= 0x30) {
    IPLOG("Warning! register access to %x - it is a strobe/statusregister\r\n", offset);
  }
  ti1101_select();
  byte reg = TI1101_READ | offset;
  int i;
 
  ti1101_write_and_read(reg);
  i = ti1101_write_and_read(0);
  ti1101_deselect();
  return i;
}
void ti1101_print_status() {
  CHECK_TI1101_FAILURE_S
  const char *ms;
  const char *o = "";
 
  if (!ti1101_lock()) {
    printf("Failed to lock ti1101 (print_status) - exit");
    ti1101_failed = 1;
    need_reset = 1;
  }
  ti1101_select();
  int marcstate = ti1101_read_status_register(0x35);
  int rxbytes = ti1101_read_status_register(0x3b);
  int packetstate = ti1101_read_status_register(0x38);
 
  ti1101_deselect();
  if (rxbytes & 0x80) {
    o = "(OVERFLOW)";
    rxbytes = rxbytes & 0x7F;
  }
  ms = decode_marcstate(marcstate);
  IPLOG("[%i]RXbytes: %i%s, marcstate=0x%x (%s), laststatus=0x%x, packetstate=0x%x \r\n",
        ti1101_isready, rxbytes, o,
        marcstate, ms, laststatus, packetstate);
  packetstate++;        // in case iplog is a noop
  ms++;                 // in case iplog is a noop
  o++;                  // in case iplog is a noop
  ti1101_unlock();
}
 
// this gets called from the cc1101-gd0-IRQ
// printf should not be used in here since it might destroy
// a buffer which is initialised otherwise
// void ti1101_receive_loop() __attribute__ ((interrupt ("IRQ")));
void ti1101_receive_loop() {
  //led_flash(LED_MACHINE, 0xFFFF00, 10);
  if (!ti1101_enabled) {
    return;
  }
  CHECK_TI1101_FAILURE
  if (!ti1101_isready) {
    //IPLOG("Warning: receive_loop called but ti1101 is not ready!\r\n");
    return;
  }
  if (ti1101_locked) {
    return; // sending? resetting?
  }
  if (ti1101_in_read_loop) {
    return; // avoid double-IRQ (not a race-condition on single-core cpus)
  }
  ti1101_in_read_loop = 1;
  if (ti1101_debug) {
    printf("ti1101_loop()\r\n");
  }
  if (packet_isvalid(PACKETBUFFER_CC1101)) {
    // error - cannot receive whilst packet is still being processed.
    //IPLOG("CC1101 PACKET buffer not ready!\r\n");
    ti1101_in_read_loop = 0;
    return;
  }
 
  int i;
  int rxbytes;
 
  ti1101_select();
 
  int total_bytes = 0;
 
  //int marcstate = ti1101_read_status_register(0x35);
  rxbytes = 1;
  reset_delay_counter(DELAY_TI1101);
  long started = mculib_get_seconds_since_boot();
  byte needlen = 0;
 
  while (rxbytes) {
    if ((mculib_get_seconds_since_boot() - started) > 3) {
      need_reset = 1;
      ti1101_isready = 0;
      ti1101_failed = 1;
      last_irq_error = 13;
      // very broken!!
      break;
    }
 
    // the the number of byes currently in RXFIFO
    rxbytes = ti1101_read_status_register(0x3b); // field RXBYTES (rxfifo_overflow & num_rxbytes)
    if (rxbytes == 0) {
      break;
    }
    // was there an rx overflow?
    if (rxbytes & 0x80) {
      overflowed = 1;
      break;
    }
    total_bytes = total_bytes + rxbytes;
    // get & print bytes
    for (i = 0; i < rxbytes; i++) {
      // tell chip we want a single byte from rxfifo
      laststatus = ti1101_write_and_read(TI1101_READ | 0x3f);  //3f==RXFIFO, TI1101_READ=="Single Byte"
      // now read the byte
      int v = ti1101_write_and_read(0);
      if (packet_put_byte(PACKETBUFFER_CC1101, (byte)v) < 0) {
        packet_getbuf(PACKETBUFFER_CC1101)[0] = 0;
        break; // error adding byte, so there's nothing we can do anymore
      }
    }
 
    needlen = packet_getbuf(PACKETBUFFER_CC1101)[0];
    needlen++; // including the length byte!
    if (packet_getbytesinbuf(PACKETBUFFER_CC1101) >= needlen) {
      packet_mark_valid(PACKETBUFFER_CC1101);
    }
  }
  ti1101_in_read_loop = 0;
 
  // for the fun of it, get the RSSI of (presumably) most recent packet
  int res = ti1101_read_status_register(0x34);   //34==RSSI, TI1101_READ=="Single Byte"
 
  last_packet_rssi = (byte)(res & 0xFF);
  //ti1101_rx();
 
  // ti1101_deselect();
}
 
int ti1101_off() {
  IPLOG("ti1101 off\r\n");
  int res = ti1101_enabled ? 1 : 0;
 
  ti1101_enabled = 0;
  return res;
}
/*
 * \brief disable ti1101 (power it off)
 */
void ti1101_disable() {
  IPLOG("ti1101 disable\r\n");
  ti1101_enabled = 0;
  mculib_spi_write_only(nctx->mculib_handle, ti1101_spiport(), 0x39);   // SLEEP when CSN is high
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 1);
}
void ti1101_on() {
  IPLOG("ti1101_enable\r\n");
  ti1101_enabled = 1;
  mculib_pin_set(nctx->mculib_handle, ti1101_cssns(), 0);
  need_reset = 1;
}
int ti1101_is_enabled() {
  return ti1101_enabled;
}
byte ti1101_read_byte() {
  return 1;
}
 
 
 
int ti1101_read_version() {
  CHECK_TI1101_FAILURE_V
  int v;
 
  ti1101_select();
 
  v = ti1101_read_status_register(0x31);
  ti1101_deselect();
  return v;
}
 
const char *decode_marcstate(int state) {
  int i = 0;
  const char *tstate;
 
  while ((tstate = statetable[i]) != NULL) {
    if (i == state) {
      return tstate;
    }
    i++;
  }
  ;
  return (const char *)"UNDEF";
}
 
byte ti1101_get_last_irq_error() {
  byte res = last_irq_error;
 
  last_irq_error = 0;
  return res;
}
static void forwardPacketBuffer(byte *bs, int len) {
  if (forwardto == 0) {
    return;
  }
  send_command_one_arg(40, forwardto, bs, ((len >= MAX_SINGLE_ARG_SIZE) ? MAX_SINGLE_ARG_SIZE : len));
}
static void printPacketBuffer(byte *bs, int len) {
  printf("Contents of TI1101 packetbuffer\r\n");
  int i;
  int j = 0;
  int l;
 
  for (i = 0; i < len; i++) {
    printf("%x ", bs[i]);
    if (j > 10) {
      for (l = 0; l < j; l++) {
        byte b = bs[i - j + l];
        if ((b == '\n') || (b == '\r')) {
          printf(".");
        } else {
          printf("%c", b);
        }
      }
      printf("\r\n");
      j = 0;
    }
    j++;
  }
  printf("\r\nNote: command parsing starts at start+1!\r\n");
  printf("END OF BUF LISTING\r\n");
}
 
static void ti_got_new_packet(struct command *com) {
  int sig_ind = last_packet_rssi;
 
  if (sig_ind >= 128) {
    sig_ind = (sig_ind - 256) / 2 - 74;
  } else {
    sig_ind = sig_ind / 2 - 74;
  }
  sig_ind = sig_ind + 128;
 
  printf("TI packet at: %p from %N (RSSI=%i,sig_ind=%i)\r\n", com, com->sender, last_packet_rssi, sig_ind);
  IncMetric_PKTS_RADIO_CTR_IN;
 
  got_new_packet(com, (uint8_t)(sig_ind & 0xFF));
  printf("TI packet processed\r\n");
}
 
void ti1101_event_loop_locked() {
  /*
   * here we check the input on the radio - perhaps
   * there's a command in the ringbuffer
   * if so, we execute it
   */
  struct command *com;
  int i;
 
  byte b = ti1101_get_last_irq_error();
 
  if (b != 0) {
    printf("TI1101 IRQ Error: %i\r\n", (int)b);
  }
  if (overflowed) {
    printf("RXFIFO overflowed\r\n");
    ti1101_reset();
  }
  if (need_reset) {
    ti1101_reset();
  }
  com = NULL;
  if (packet_isvalid(PACKETBUFFER_CC1101)) {
    byte *bs = packet_getbuf(PACKETBUFFER_CC1101);
    i = packet_getbytesinbuf(PACKETBUFFER_CC1101);
    if (i > 0) {
      if (ti1101_debug) {
        printf("TI1101: %i bytes in buf\r\n", i);
      }
      com = command_parse(bs + 1, i - 1);
    }
    if (com == NULL) {
      IncMetric_PKTS_RADIO_INVALID;
      IPLOG("\r\n*** Invalid command from radio (bufsize=%i)***\r\n",
            packet_getbytesinbuf(PACKETBUFFER_CC1101));
      printPacketBuffer(bs, i);
      forwardPacketBuffer(bs, i);
      packet_buf_init(PACKETBUFFER_CC1101);
      need_reset = 1;
      IPLOG("Packet buf cleared\r\n");
    } else {
      com->sourcedev = SOURCE_RADIO;
      //command_print(com);
      ti_got_new_packet(com);
      packet_buf_init(PACKETBUFFER_CC1101);
    }
  }
}
int ti1101_loop(struct network_context *ctx) {
  if (!ti1101_enabled) {
    return 1;
  }
  ti1101_lock();
  ti1101_event_loop_locked();
  ti1101_unlock();
  return 0;
}
 
 
void ti1101_disable_irq(struct network_context *ctx) {
  mculib_pin_release(ctx->mculib_handle, ti1101_irqpin());
  int r = mculib_pin_out(ctx->mculib_handle, ti1101_irqpin(), HAL_PIN_SLOWEST);
 
  if (r != 0) {
    printf("Failed to disable irq for ti1101 (%i)\r\n", r);
  }
}
void ti1101_enable_irq() {
  mculib_pin_release(nctx->mculib_handle, ti1101_irqpin());
  int r = mculib_pin_in(nctx->mculib_handle, ti1101_irqpin(), HAL_PIN_SLOWEST, HAL_PUSHPULL_DOWN);
 
  if (r != 0) {
    printf("Failed to enable irq for ti1101 (%i)\r\n", r);
  }
  if (register_softirq(nctx->mculib_handle, ti1101_irqpin(), &ti1101_receive_loop, NULL) != 0) {
    printf("failed to register softirq for ti1101\r\n");
  }
}
 
/**************************************************
*** TI 1101 Configuration management
**************************************************/
static void ti1101_config_init() {
  /* copy the config from flash to ram */
  int i = 0;
  int t = 0;
 
  config_entries = 0;
  for (;;) {
    int val = RFSETTINGS[i++];
    int off = RFSETTINGS[i++];
    current_config[t++] = val;
    current_config[t++] = off;
    config_entries++;
    if ((val == ENDMARK) && (off == ENDMARK)) {
      break;
    }
  }
}
 
int received_radio_get_config(struct command *com) {
  struct command *dcom;
 
  dcom = alloc_command();
  if (dcom == NULL) {
    return 1;
  }
  command_init(dcom);
  dcom->target = com->sender;
  dcom->connid = com->connid;
  dcom->com = com->com;
  dcom->flags = COMFLAGS_DATA | COMFLAGS_SUCCESS;
  command_add_binary_arg(dcom, config_entries * 2, current_config);
  deliver_command(dcom, NULL);
  return 0;
}
static void set_reg_config(int reg, int value) {
  int i;
 
  for (i = 0; i < config_entries; i++) {
    if (current_config[i * 2] == reg) {
      int oldv = current_config[i * 2 + 1];
      if (oldv == value) {
        return;
      }
      current_config[i * 2 + 1] = value;
      printf("Changed TI1101 register %x from %x to %x\r\n", reg, oldv, value);
      return;
    }
  }
  current_config[config_entries * 2] = reg;
  current_config[config_entries * 2 + 1] = value;
  printf("Set TI1101 register %x to %x\r\n", reg, value);
  config_entries++;
  current_config[config_entries * 2] = ENDMARK;
  current_config[config_entries * 2 + 1] = ENDMARK;
}
 
int received_radio_set_config(struct command *com) {
  const char *b;
 
  b = get_arg(com, 0);
  int size = get_arg_size(com, 0);
  int i = 0;
 
  for (;;) {
    int reg = b[i++];
    int val = b[i++];
    set_reg_config(reg, val);
    if (i >= size) {
      break;
    }
  }
  ti1101_reset();
  return 0;
}
void ti1101_forward_radio(long node) {
  printf("Forwarding all packets to %N\r\n", node);
  forwardto = node;
}
 
int ti1101_transmit(struct network_context *nctx, const byte *data, uint16_t num_bytes) {
  return ti1101_send((int)num_bytes, data);
}