35 #include "cc1200-const.h" 36 #include "cc1200-conf.h" 37 #include "cc1200-arch.h" 38 #include "cc1200-rf-cfg.h" 42 #include "dev/watchdog.h" 51 static rtimer_clock_t sfd_timestamp = 0;
71 #ifndef CC1200_RF_TESTMODE 72 #define CC1200_RF_TESTMODE 0 75 #if CC1200_RF_TESTMODE 77 #if CC1200_RF_TESTMODE == 1 78 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 79 #elif CC1200_RF_TESTMODE == 2 80 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 81 #elif CC1200_RF_TESTMODE == 3 82 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 92 #define CC1200_WITH_TX_BUF (!MAC_CONF_WITH_TSCH) 100 #define STATE_USES_MARC_STATE 0 107 #if MAC_CONF_WITH_TSCH 108 #define USE_SFSTXON 0 110 #define USE_SFSTXON 1 123 #define APPENDIX_LEN 2 129 #if CC1200_MAX_PAYLOAD_LEN > (2048 - PHR_LEN) 130 #error Payload length not supported by this driver 133 #if CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN) 135 #error Payload length not supported without GPIO2 139 #if CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN) 141 #error Payload length not supported without enabling 802.15.4g mode 149 #define GPIO2_IOCFG CC1200_IOCFG_RXFIFO_THR 151 #if MAC_CONF_WITH_TSCH 153 #define FIFO_THRESHOLD 1 155 #define FIFO_THRESHOLD 0 158 #define FIFO_THRESHOLD 32 161 #define RXOFF_MODE_RX 1 163 #define APPEND_STATUS 1 166 #define GPIO2_IOCFG CC1200_IOCFG_MARC_2PIN_STATUS_0 167 #if (CC1200_MAX_PAYLOAD_LEN <= (CC1200_FIFO_SIZE - PHR_LEN - APPENDIX_LEN)) 172 #define RXOFF_MODE_RX 1 174 #define APPEND_STATUS 1 180 #define RXOFF_MODE_RX 0 182 #define APPEND_STATUS 0 187 #define GPIO0_IOCFG CC1200_IOCFG_PKT_SYNC_RXTX 189 #define GPIO3_IOCFG CC1200_IOCFG_MARC_2PIN_STATUS_0 191 #define TXOFF_MODE_RX 1 194 #define CC_APPENDIX_LEN 2 197 #define CC_APPENDIX_LEN 0 203 extern const cc1200_rf_cfg_t CC1200_RF_CFG;
208 #define XTAL_FREQ_KHZ 40000 215 #if (XTAL_FREQ_KHZ == 40000) && (LO_DIVIDER == 4) 216 #define FREQ_DIVIDER 625 217 #define FREQ_MULTIPLIER 4096 219 #error Invalid settings for frequency calculation 222 #if STATE_USES_MARC_STATE 224 #define STATE_IDLE CC1200_MARC_STATE_IDLE 225 #define STATE_RX CC1200_MARC_STATE_RX 226 #define STATE_TX CC1200_MARC_STATE_TX 227 #define STATE_RX_FIFO_ERROR CC1200_MARC_STATE_RX_FIFO_ERR 228 #define STATE_TX_FIFO_ERROR CC1200_MARC_STATE_TX_FIFO_ERR 231 #define STATE_IDLE CC1200_STATUS_BYTE_IDLE 232 #define STATE_RX CC1200_STATUS_BYTE_RX 233 #define STATE_TX CC1200_STATUS_BYTE_TX 234 #define STATE_FSTXON CC1200_STATUS_BYTE_FSTXON 235 #define STATE_CALIBRATE CC1200_STATUS_BYTE_CALIBRATE 236 #define STATE_SETTLING CC1200_STATUS_BYTE_SETTLING 237 #define STATE_RX_FIFO_ERR CC1200_STATUS_BYTE_RX_FIFO_ERR 238 #define STATE_TX_FIFO_ERR CC1200_STATUS_BYTE_TX_FIFO_ERR 244 #define INVALID_FRAME 0 246 #define ADDR_CHECK_FAILED 1 248 #define ADDR_CHECK_OK 2 250 #define ADDR_CHECK_OK_ACK_SEND 3 255 #define CHANNEL_UPDATE_SUCCEEDED 0 257 #define CHANNEL_UPDATE_POSTPONED 1 259 #define CHANNEL_OUT_OF_LIMITS 2 264 #define RF_INITIALIZED 0x01 268 #define RF_RX_PROCESSING_PKT 0x04 270 #define RF_TX_ACTIVE 0x08 272 #define RF_UPDATE_CHANNEL 0x10 274 #define RF_POLL_RX_INTERRUPT 0x20 276 #define RF_RX_ONGOING 0x40 279 #if CC1200_CAL_TIMEOUT_SECONDS 280 #define RF_FORCE_CALIBRATION 0x40 289 #ifdef CC1200_TX_LEDS 290 #define TX_LEDS_ON() leds_on(CC1200_TX_LEDS) 291 #define TX_LEDS_OFF() leds_off(CC1200_TX_LEDS) 294 #define TX_LEDS_OFF() 297 #ifdef CC1200_RX_LEDS 298 #define RX_LEDS_ON() leds_on(CC1200_RX_LEDS) 299 #define RX_LEDS_OFF() leds_off(CC1200_RX_LEDS) 302 #define RX_LEDS_OFF() 310 #define LOCK_SPI() do { spi_locked++; } while(0) 311 #define SPI_IS_LOCKED() (spi_locked != 0) 312 #define RELEASE_SPI() do { spi_locked--; } while(0) 317 #define SETUP_GPIO_INTERRUPTS() \ 319 cc1200_arch_gpio0_setup_irq(0); \ 320 cc1200_arch_gpio2_setup_irq(1); \ 322 #define ENABLE_GPIO_INTERRUPTS() \ 324 cc1200_arch_gpio0_enable_irq(); \ 325 cc1200_arch_gpio2_enable_irq(); \ 327 #define DISABLE_GPIO_INTERRUPTS() \ 329 cc1200_arch_gpio0_disable_irq(); \ 330 cc1200_arch_gpio2_disable_irq(); \ 333 #define SETUP_GPIO_INTERRUPTS() cc1200_arch_gpio0_setup_irq(0) 334 #define ENABLE_GPIO_INTERRUPTS() cc1200_arch_gpio0_enable_irq() 335 #define DISABLE_GPIO_INTERRUPTS() cc1200_arch_gpio0_disable_irq() 342 #define ERROR(...) printf(__VA_ARGS__) 349 #define RF_ASSERT(condition) \ 352 printf("RF: Assertion failed in line %d\n", __LINE__); \ 356 #define RF_ASSERT(condition) 361 #define WARNING(...) printf(__VA_ARGS__) 368 #define INFO(...) printf(__VA_ARGS__) 374 #define RTIMER_BUSYWAIT_UNTIL_STATE(s, t) RTIMER_BUSYWAIT_UNTIL(state() == (s), t) 380 static volatile uint8_t spi_locked = 0;
381 #if CC1200_WITH_TX_BUF 383 static uint8_t tx_pkt[CC1200_MAX_PAYLOAD_LEN];
386 static uint16_t tx_pkt_len;
388 uint16_t bytes_left_to_write;
390 static uint8_t rx_pkt[CC1200_MAX_PAYLOAD_LEN + APPENDIX_LEN];
392 static volatile uint16_t rx_pkt_len = 0;
397 static uint8_t rf_channel;
399 static uint8_t new_rf_channel;
405 static int8_t txpower;
406 static int8_t new_txpower;
408 static int8_t cca_threshold;
409 static int8_t new_cca_threshold;
411 static uint8_t rf_flags = 0;
412 #if !CC1200_AUTOCAL && CC1200_CAL_TIMEOUT_SECONDS 414 static unsigned long cal_timer;
416 #if CC1200_USE_RX_WATCHDOG 428 copy_header_to_tx_fifo(
unsigned short payload_len);
431 prepare(
const void *payload,
unsigned short payload_len);
434 transmit(
unsigned short payload_len);
437 send(
const void *payload,
unsigned short payload_len);
440 read(
void *buf,
unsigned short bufsize);
449 receiving_packet(
void);
452 pending_packet(
void);
460 static radio_result_t
463 static radio_result_t
466 static radio_result_t
467 get_object(radio_param_t param,
void *dest,
size_t size);
469 static radio_result_t
470 set_object(radio_param_t param,
const void *src,
size_t size);
497 strobe(uint8_t strobe);
503 single_write(uint16_t
addr, uint8_t value);
506 single_read(uint16_t
addr);
509 burst_write(uint16_t
addr,
const uint8_t *data, uint8_t data_len);
512 burst_read(uint16_t
addr, uint8_t *data, uint8_t data_len);
515 write_reg_settings(
const registerSetting_t *reg_settings,
516 uint16_t sizeof_reg_settings);
533 idle_calibrate_rx(
void);
539 idle_tx_rx(
const uint8_t *payload, uint16_t payload_len);
542 update_txpower(int8_t txpower_dbm);
545 update_cca_threshold(int8_t threshold_dbm);
548 calculate_freq(uint8_t channel);
554 addr_check_auto_ack(uint8_t *frame, uint16_t frame_len);
557 static void pollhandler(
void);
559 PROCESS(cc1200_process,
"CC1200 driver");
568 #if CC1200_USE_RX_WATCHDOG 571 if((rf_flags & (RF_ON | RF_TX_ACTIVE)) == RF_ON) {
585 if(cc1200_arch_gpio0_read_pin() == 0) {
595 if(state() != STATE_RX) {
596 WARNING(
"RF: RX watchdog triggered!\n");
621 if((rf_flags & (RF_ON + RF_POLL_RX_INTERRUPT)) ==
622 (RF_ON + RF_POLL_RX_INTERRUPT)) {
623 cc1200_rx_interrupt();
626 if(rf_flags & RF_UPDATE_CHANNEL) {
631 if((rx_mode_value & RADIO_RX_MODE_POLL_MODE) == 0 && rx_pkt_len > 0) {
646 NETSTACK_MAC.
input();
665 INFO(
"RF: Init (%s)\n", CC1200_RF_CFG.cfg_descriptor);
667 if(!(rf_flags & RF_INITIALIZED)) {
675 SETUP_GPIO_INTERRUPTS();
687 new_txpower = CC1200_RF_CFG.max_txpower;
688 update_txpower(new_txpower);
691 new_cca_threshold = CC1200_RF_CFG.cca_threshold;
692 update_cca_threshold(new_cca_threshold);
697 rf_flags |= (RF_INITIALIZED + RF_ON);
717 prepare(
const void *payload,
unsigned short payload_len)
720 INFO(
"RF: Prepare (%d)\n", payload_len);
722 if((payload_len < ACK_LEN) ||
723 (payload_len > CC1200_MAX_PAYLOAD_LEN)) {
724 ERROR(
"RF: Invalid payload length!\n");
728 tx_pkt_len = payload_len;
730 #if CC1200_WITH_TX_BUF 732 memcpy(tx_pkt, payload, tx_pkt_len);
734 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 735 #error CC1200 max payload too large 738 copy_header_to_tx_fifo(payload_len);
739 burst_write(CC1200_TXFIFO, payload, payload_len);
748 copy_header_to_tx_fifo(
unsigned short payload_len)
756 #if CC1200_802154G_CRC16 762 phr.phrb = (uint8_t)(payload_len & 0x00FF);
763 phr.phra = (uint8_t)((payload_len >> 8) & 0x0007);
764 #if CC1200_802154G_WHITENING 766 phr.phra |= (1 << 3);
768 #if CC1200_802154G_CRC16 770 phr.phra |= (1 << 4);
776 rf_flags &= ~RF_RX_PROCESSING_PKT;
783 burst_write(CC1200_TXFIFO, (uint8_t *)&phr, PHR_LEN);
786 burst_write(CC1200_TXFIFO, (uint8_t *)&payload_len, PHR_LEN);
794 transmit(
unsigned short transmit_len)
798 int ret = RADIO_TX_OK;
801 INFO(
"RF: Transmit (%d)\n", transmit_len);
803 if(transmit_len != tx_pkt_len) {
804 ERROR(
"RF: TX length mismatch!\n");
809 rf_flags |= RF_TX_ACTIVE;
811 if(!(rf_flags & RF_ON)) {
825 rf_flags &= ~RF_TX_ACTIVE;
826 return RADIO_TX_COLLISION;
843 if(new_txpower != txpower) {
844 update_txpower(new_txpower);
855 #if CC1200_WITH_TX_BUF 856 txret = idle_tx_rx(tx_pkt, tx_pkt_len);
858 txret = idle_tx_rx(NULL, tx_pkt_len);
860 if(txret == RADIO_TX_OK) {
868 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX,
869 CC1200_RF_CFG.tx_rx_turnaround);
871 ENABLE_GPIO_INTERRUPTS();
883 #ifdef RF_FORCE_CALIBRATION 884 rf_flags |= RF_FORCE_CALIBRATION;
898 rf_flags &= ~RF_TX_ACTIVE;
906 send(
const void *payload,
unsigned short payload_len)
911 INFO(
"RF: Send (%d)\n", payload_len);
914 if((ret =
prepare(payload, payload_len)) == RADIO_TX_OK) {
924 read(
void *buf,
unsigned short buf_len)
931 rssi = (int8_t)rx_pkt[rx_pkt_len - 2] + (
int)CC1200_RF_CFG.rssi_offset;
933 uint8_t crc_lqi = rx_pkt[rx_pkt_len - 1];
935 len = rx_pkt_len - APPENDIX_LEN;
939 ERROR(
"RF: Failed to read packet (too big)!\n");
943 INFO(
"RF: Read (%d bytes, %d dBm)\n", len, rssi);
945 memcpy((
void *)buf, (
const void *)rx_pkt, len);
950 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rssi);
952 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY,
953 crc_lqi & ~(1 << 7));
970 uint8_t cca, was_off = 0;
972 if(SPI_IS_LOCKED()) {
977 if(!(rf_flags & RF_ON)) {
985 RF_ASSERT(state() == STATE_RX);
994 if(cc1200_arch_gpio0_read_pin() == 1) {
996 INFO(
"RF: CCA (0)\n");
1003 if(new_cca_threshold != cca_threshold) {
1004 update_cca_threshold(new_cca_threshold);
1009 & CC1200_CARRIER_SENSE_VALID),
1010 RTIMER_SECOND / 100);
1011 RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID);
1013 if(rssi0 & CC1200_CARRIER_SENSE) {
1015 INFO(
"RF: CCA (0)\n");
1019 INFO(
"RF: CCA (1)\n");
1048 if((rf_flags & (RF_ON | RF_TX_ACTIVE)) == RF_ON) {
1050 if((cc1200_arch_gpio0_read_pin() == 1) || (rx_pkt_len != 0)) {
1070 INFO(
"RF: Receiving (%d)\n", ret);
1080 ret = ((rx_pkt_len != 0) ? 1 : 0);
1081 if(ret == 0 && !SPI_IS_LOCKED()) {
1083 ret = (single_read(CC1200_NUM_RXBYTES) > 0);
1087 INFO(
"RF: Pending (%d)\n", ret);
1100 if(!(rf_flags & RF_ON)) {
1102 if(SPI_IS_LOCKED()) {
1109 cc1200_arch_spi_select();
1111 RTIMER_SECOND / 100);
1112 RF_ASSERT((cc1200_arch_gpio0_read_pin() == 0));
1113 cc1200_arch_spi_deselect();
1115 rf_flags = RF_INITIALIZED;
1119 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1122 idle_calibrate_rx();
1126 #if CC1200_USE_RX_WATCHDOG 1133 INFO(
"RF: Already on\n");
1148 if(rf_flags & RF_ON) {
1150 if(SPI_IS_LOCKED()) {
1158 if(single_read(CC1200_NUM_RXBYTES) > 0) {
1161 cc1200_rx_interrupt();
1162 if(SPI_IS_LOCKED()) {
1172 single_write(CC1200_IOCFG0, CC1200_IOCFG_RXFIFO_CHIP_RDY_N);
1175 strobe(CC1200_SPWD);
1178 rf_flags = RF_INITIALIZED;
1182 #if CC1200_USE_RX_WATCHDOG 1187 INFO(
"RF: Already off\n");
1204 int16_t rssi0, rssi1;
1205 uint8_t was_off = 0;
1208 if(!(rf_flags & RF_ON)) {
1215 & CC1200_CARRIER_SENSE_VALID),
1216 RTIMER_SECOND / 100);
1217 RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID);
1218 rssi1 = (int8_t)single_read(CC1200_RSSI1) + (int)CC1200_RF_CFG.rssi_offset;
1229 static radio_result_t
1234 return RADIO_RESULT_INVALID_VALUE;
1238 case RADIO_PARAM_POWER_MODE:
1240 if(rf_flags & RF_ON) {
1245 return RADIO_RESULT_OK;
1247 case RADIO_PARAM_CHANNEL:
1250 return RADIO_RESULT_OK;
1252 case RADIO_PARAM_PAN_ID:
1253 case RADIO_PARAM_16BIT_ADDR:
1255 return RADIO_RESULT_NOT_SUPPORTED;
1257 case RADIO_PARAM_RX_MODE:
1260 return RADIO_RESULT_OK;
1262 case RADIO_PARAM_TX_MODE:
1265 return RADIO_RESULT_OK;
1267 case RADIO_PARAM_TXPOWER:
1270 return RADIO_RESULT_OK;
1272 case RADIO_PARAM_CCA_THRESHOLD:
1275 return RADIO_RESULT_OK;
1277 case RADIO_PARAM_RSSI:
1279 return RADIO_RESULT_OK;
1281 case RADIO_PARAM_LAST_RSSI:
1283 return RADIO_RESULT_OK;
1285 case RADIO_PARAM_64BIT_ADDR:
1287 return RADIO_RESULT_NOT_SUPPORTED;
1289 case RADIO_CONST_CHANNEL_MIN:
1292 return RADIO_RESULT_OK;
1294 case RADIO_CONST_CHANNEL_MAX:
1297 return RADIO_RESULT_OK;
1299 case RADIO_CONST_TXPOWER_MIN:
1302 return RADIO_RESULT_OK;
1304 case RADIO_CONST_TXPOWER_MAX:
1307 return RADIO_RESULT_OK;
1309 case RADIO_CONST_PHY_OVERHEAD:
1311 #
if CC1200_802154G_CRC16
1319 return RADIO_RESULT_OK;
1321 case RADIO_CONST_BYTE_AIR_TIME:
1322 *value = (
radio_value_t)8*1000*1000 / CC1200_RF_CFG.bitrate;
1323 return RADIO_RESULT_OK;
1325 case RADIO_CONST_DELAY_BEFORE_TX:
1327 return RADIO_RESULT_OK;
1329 case RADIO_CONST_DELAY_BEFORE_RX:
1331 return RADIO_RESULT_OK;
1333 case RADIO_CONST_DELAY_BEFORE_DETECT:
1335 return RADIO_RESULT_OK;
1339 return RADIO_RESULT_NOT_SUPPORTED;
1346 static radio_result_t
1351 case RADIO_PARAM_POWER_MODE:
1353 if(value == RADIO_POWER_MODE_ON) {
1355 return RADIO_RESULT_OK;
1358 if(value == RADIO_POWER_MODE_OFF) {
1360 return RADIO_RESULT_OK;
1363 return RADIO_RESULT_INVALID_VALUE;
1365 case RADIO_PARAM_CHANNEL:
1368 return RADIO_RESULT_INVALID_VALUE;
1379 return RADIO_RESULT_OK;
1381 case RADIO_PARAM_PAN_ID:
1382 case RADIO_PARAM_16BIT_ADDR:
1384 return RADIO_RESULT_NOT_SUPPORTED;
1386 case RADIO_PARAM_RX_MODE:
1388 rx_mode_value = value;
1389 return RADIO_RESULT_OK;
1391 case RADIO_PARAM_TX_MODE:
1393 tx_mode_value = value;
1394 return RADIO_RESULT_OK;
1396 case RADIO_PARAM_TXPOWER:
1407 new_txpower = (int8_t)value;
1408 return RADIO_RESULT_OK;
1410 case RADIO_PARAM_CCA_THRESHOLD:
1421 new_cca_threshold = (int8_t)value;
1422 return RADIO_RESULT_OK;
1424 case RADIO_PARAM_RSSI:
1425 case RADIO_PARAM_64BIT_ADDR:
1429 return RADIO_RESULT_NOT_SUPPORTED;
1436 static radio_result_t
1437 get_object(radio_param_t param,
void *dest,
size_t size)
1439 if(param == RADIO_PARAM_LAST_PACKET_TIMESTAMP) {
1440 if(size !=
sizeof(rtimer_clock_t) || !dest) {
1441 return RADIO_RESULT_INVALID_VALUE;
1443 *(rtimer_clock_t *)dest = sfd_timestamp;
1444 return RADIO_RESULT_OK;
1447 #if MAC_CONF_WITH_TSCH 1448 if(param == RADIO_CONST_TSCH_TIMING) {
1449 if(size !=
sizeof(uint16_t *) || !dest) {
1450 return RADIO_RESULT_INVALID_VALUE;
1452 *(
const uint16_t **)dest = CC1200_RF_CFG.tsch_timing;
1453 return RADIO_RESULT_OK;
1457 return RADIO_RESULT_NOT_SUPPORTED;
1462 static radio_result_t
1463 set_object(radio_param_t param,
const void *src,
size_t size)
1466 return RADIO_RESULT_NOT_SUPPORTED;
1479 strobe(uint8_t strobe)
1484 cc1200_arch_spi_select();
1485 ret = cc1200_arch_spi_rw_byte(strobe);
1486 cc1200_arch_spi_deselect();
1497 cc1200_arch_spi_select();
1498 cc1200_arch_spi_rw_byte(CC1200_SRES);
1504 cc1200_arch_spi_deselect();
1510 single_write(uint16_t
addr, uint8_t val)
1515 cc1200_arch_spi_select();
1516 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1517 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_WRITE_CMD);
1518 cc1200_arch_spi_rw_byte((uint8_t)addr);
1520 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT);
1522 ret = cc1200_arch_spi_rw_byte(val);
1523 cc1200_arch_spi_deselect();
1531 single_read(uint16_t addr)
1536 cc1200_arch_spi_select();
1537 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1538 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_READ_CMD);
1539 cc1200_arch_spi_rw_byte((uint8_t)addr);
1541 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT);
1543 ret = cc1200_arch_spi_rw_byte(0);
1544 cc1200_arch_spi_deselect();
1552 burst_write(uint16_t addr,
const uint8_t *data, uint8_t data_len)
1555 cc1200_arch_spi_select();
1556 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1557 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_WRITE_CMD);
1558 cc1200_arch_spi_rw_byte((uint8_t)addr);
1560 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT | CC1200_BURST_BIT);
1562 cc1200_arch_spi_rw(NULL, data, data_len);
1563 cc1200_arch_spi_deselect();
1569 burst_read(uint16_t addr, uint8_t *data, uint8_t data_len)
1572 cc1200_arch_spi_select();
1573 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1574 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_READ_CMD);
1575 cc1200_arch_spi_rw_byte((uint8_t)addr);
1577 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT | CC1200_BURST_BIT);
1579 cc1200_arch_spi_rw(data, NULL, data_len);
1580 cc1200_arch_spi_deselect();
1586 write_reg_settings(
const registerSetting_t *reg_settings,
1587 uint16_t sizeof_reg_settings)
1590 int i = sizeof_reg_settings /
sizeof(registerSetting_t);
1592 if(reg_settings != NULL) {
1594 single_write(reg_settings->addr,
1608 #if CC1200_RF_TESTMODE 1619 write_reg_settings(CC1200_RF_CFG.register_settings,
1620 CC1200_RF_CFG.size_of_register_settings);
1623 #if CC1200_FREQ_OFFSET 1625 single_write(CC1200_FREQOFF1, (uint8_t)(CC1200_FREQ_OFFSET >> 8));
1627 single_write(CC1200_FREQOFF0, (uint8_t)(CC1200_FREQ_OFFSET));
1631 single_write(CC1200_AGC_GAIN_ADJUST, (int8_t)CC1200_RF_CFG.rssi_offset);
1637 #if (CC1200_RF_TESTMODE == 1) || (CC1200_RF_TESTMODE == 2) 1639 strobe(CC1200_SFTX);
1640 single_write(CC1200_TXFIRST, 0);
1641 single_write(CC1200_TXLAST, 0xFF);
1642 update_txpower(CC1200_CONST_TX_POWER_MAX);
1643 single_write(CC1200_PKT_CFG2, 0x02);
1644 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1645 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1646 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1647 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1649 printf(
"RF: Freq0 0x%02x\n", ((uint8_t *)&freq)[0]);
1650 printf(
"RF: Freq1 0x%02x\n", ((uint8_t *)&freq)[1]);
1651 printf(
"RF: Freq2 0x%02x\n", ((uint8_t *)&freq)[2]);
1653 #if (CC1200_RF_TESTMODE == 1) 1654 single_write(CC1200_SYNC_CFG1, 0xE8);
1655 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1656 single_write(CC1200_MDMCFG1, 0x46);
1657 single_write(CC1200_PKT_CFG0, 0x40);
1658 single_write(CC1200_FS_DIG1, 0x07);
1659 single_write(CC1200_FS_DIG0, 0xAA);
1660 single_write(CC1200_FS_DVC1, 0xFF);
1661 single_write(CC1200_FS_DVC0, 0x17);
1664 #if (CC1200_RF_TESTMODE == 2) 1665 single_write(CC1200_SYNC_CFG1, 0xE8);
1666 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1667 single_write(CC1200_MDMCFG1, 0x06);
1668 single_write(CC1200_PA_CFG1, 0x3F);
1669 single_write(CC1200_MDMCFG2, 0x03);
1670 single_write(CC1200_FS_DIG1, 0x07);
1671 single_write(CC1200_FS_DIG0, 0xAA);
1672 single_write(CC1200_FS_DVC0, 0x17);
1673 single_write(CC1200_SERIAL_STATUS, 0x08);
1679 #if (CC1200_RF_TESTMODE == 1) 1700 #elif (CC1200_RF_TESTMODE == 3) 1703 single_write(CC1200_IOCFG3, CC1200_IOCFG_CARRIER_SENSE);
1704 single_write(CC1200_IOCFG2, CC1200_IOCFG_SERIAL_CLK);
1705 single_write(CC1200_IOCFG0, CC1200_IOCFG_SERIAL_RX);
1706 update_cca_threshold(CC1200_RF_CFG.cca_threshold);
1707 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1708 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1709 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1710 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1726 if(cc1200_arch_gpio3_read_pin() == 1) {
1741 single_write(CC1200_IOCFG3, GPIO3_IOCFG);
1742 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1743 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1745 reg = single_read(CC1200_SETTLING_CFG);
1758 single_write(CC1200_SETTLING_CFG, reg);
1761 reg = single_read(CC1200_RFEND_CFG1);
1767 single_write(CC1200_RFEND_CFG1, reg);
1770 reg = single_read(CC1200_RFEND_CFG0);
1775 single_write(CC1200_RFEND_CFG0, reg);
1783 single_write(CC1200_PKT_CFG2, (1 << 5));
1785 single_write(CC1200_PKT_CFG2, 0x00);
1789 reg = single_read(CC1200_PKT_CFG1);
1795 single_write(CC1200_PKT_CFG1, reg);
1798 reg = single_read(CC1200_PKT_CFG0);
1801 single_write(CC1200_PKT_CFG0, reg);
1803 #ifdef FIFO_THRESHOLD 1805 single_write(CC1200_FIFO_CFG, FIFO_THRESHOLD);
1815 #if STATE_USES_MARC_STATE 1816 return single_read(CC1200_MARCSTATE) & 0x1f;
1818 return strobe(CC1200_SNOP) & 0x70;
1829 #ifdef RF_FORCE_CALIBRATION 1830 if (!(rf_flags & RF_FORCE_CALIBRATION)
1831 && ((
clock_seconds() - cal_timer) < CC1200_CAL_TIMEOUT_SECONDS)) {
1835 rf_flags &= ~RF_FORCE_CALIBRATION;
1838 INFO(
"RF: Calibrate\n");
1840 strobe(CC1200_SCAL);
1841 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_CALIBRATE, RTIMER_SECOND / 100);
1842 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1844 #if CC1200_CAL_TIMEOUT_SECONDS 1858 DISABLE_GPIO_INTERRUPTS();
1863 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1864 ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
1868 if(s == STATE_IDLE) {
1870 }
else if(s == STATE_RX_FIFO_ERR) {
1871 WARNING(
"RF: RX FIFO error!\n");
1872 strobe(CC1200_SFRX);
1873 }
else if(s == STATE_TX_FIFO_ERR) {
1874 WARNING(
"RF: TX FIFO error!\n");
1875 strobe(CC1200_SFTX);
1878 strobe(CC1200_SIDLE);
1879 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1885 idle_calibrate_rx(
void)
1888 RF_ASSERT(state() == STATE_IDLE);
1894 rf_flags &= ~RF_RX_PROCESSING_PKT;
1895 strobe(CC1200_SFRX);
1897 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1899 ENABLE_GPIO_INTERRUPTS();
1901 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
1910 uint8_t s = state();
1912 if(s == STATE_IDLE) {
1914 }
else if(s == STATE_RX_FIFO_ERR) {
1915 WARNING(
"RF: RX FIFO error!\n");
1916 strobe(CC1200_SFRX);
1917 }
else if(s == STATE_TX_FIFO_ERR) {
1918 WARNING(
"RF: TX FIFO error!\n");
1919 strobe(CC1200_SFTX);
1921 strobe(CC1200_SIDLE);
1922 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE,
1923 RTIMER_SECOND / 100);
1927 rf_flags &= ~RF_RX_PROCESSING_PKT;
1930 ENABLE_GPIO_INTERRUPTS();
1932 strobe(CC1200_SFRX);
1934 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1940 idle_tx_rx(
const uint8_t *payload, uint16_t payload_len)
1942 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1948 rf_flags &= ~RF_RX_PROCESSING_PKT;
1949 strobe(CC1200_SFRX);
1952 single_write(CC1200_IOCFG0, CC1200_IOCFG_MARC_2PIN_STATUS_0);
1954 #if CC1200_WITH_TX_BUF 1956 copy_header_to_tx_fifo(payload_len);
1965 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1966 to_write = MIN(payload_len, (CC1200_FIFO_SIZE - PHR_LEN));
1967 burst_write(CC1200_TXFIFO, payload, to_write);
1968 bytes_left_to_write = payload_len - to_write;
1969 p = payload + to_write;
1971 burst_write(CC1200_TXFIFO, payload, payload_len);
1977 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_FSTXON, RTIMER_SECOND / 100);
1990 ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
1992 if((cc1200_arch_gpio0_read_pin() == 0) &&
1993 (single_read(CC1200_NUM_TXBYTES) != 0)) {
2000 ERROR(
"RF: TX doesn't start!\n");
2001 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2002 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2007 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2009 return RADIO_TX_ERR;
2013 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) && CC1200_WITH_TX_BUF 2014 if(bytes_left_to_write != 0) {
2019 if((bytes_left_to_write != 0) &&
2020 (cc1200_arch_gpio2_read_pin() == 0)) {
2022 to_write = MIN(bytes_left_to_write, FIFO_THRESHOLD);
2023 burst_write(CC1200_TXFIFO, p, to_write);
2024 bytes_left_to_write -= to_write;
2026 t0 += CC1200_RF_CFG.tx_pkt_lifetime;
2028 }
while((cc1200_arch_gpio0_read_pin() == 1) &&
2029 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + CC1200_RF_CFG.tx_pkt_lifetime));
2039 if((s != STATE_RX) && (s != STATE_SETTLING)) {
2046 INFO(
"RF: TX failure!\n");
2049 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2053 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2055 return RADIO_TX_ERR;
2062 CC1200_RF_CFG.tx_pkt_lifetime);
2067 CC1200_RF_CFG.tx_pkt_lifetime);
2070 if(cc1200_arch_gpio0_read_pin() == 1) {
2072 ERROR(
"RF: TX takes to long!\n");
2073 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2075 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2080 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2082 return RADIO_TX_ERR;
2086 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2088 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2092 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2096 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
2104 update_txpower(int8_t txpower_dbm)
2107 uint8_t reg = single_read(CC1200_PA_CFG1);
2111 reg |= ((((txpower_dbm + 18) * 2) - 1) & 0x3F);
2112 single_write(CC1200_PA_CFG1, reg);
2114 txpower = txpower_dbm;
2120 update_cca_threshold(int8_t threshold_dbm)
2123 single_write(CC1200_AGC_CS_THR, (uint8_t)threshold_dbm);
2124 cca_threshold = threshold_dbm;
2130 calculate_freq(uint8_t channel)
2135 freq = CC1200_RF_CFG.chan_center_freq0 + (channel * CC1200_RF_CFG.chan_spacing) / 1000 ;
2136 freq *= FREQ_MULTIPLIER;
2137 freq /= FREQ_DIVIDER;
2148 uint8_t was_off = 0;
2151 channel %= (CC1200_RF_CFG.max_channel - CC1200_RF_CFG.min_channel + 1);
2152 channel += CC1200_RF_CFG.min_channel;
2159 if(channel == rf_channel) {
2164 if(channel < CC1200_RF_CFG.min_channel ||
2165 channel > CC1200_RF_CFG.max_channel) {
2167 return CHANNEL_OUT_OF_LIMITS;
2174 new_rf_channel = channel;
2175 rf_flags |= RF_UPDATE_CHANNEL;
2177 INFO(
"RF: Channel update postponed\n");
2179 return CHANNEL_UPDATE_POSTPONED;
2182 rf_flags &= ~RF_UPDATE_CHANNEL;
2184 INFO(
"RF: Channel update (%d)\n", channel);
2186 if(!(rf_flags & RF_ON)) {
2195 freq = calculate_freq(channel - CC1200_RF_CFG.min_channel);
2196 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
2197 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
2198 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
2200 rf_channel = channel;
2204 #ifdef RF_FORCE_CALIBRATION 2205 rf_flags |= RF_FORCE_CALIBRATION;
2207 idle_calibrate_rx();
2216 return CHANNEL_UPDATE_SUCCEEDED;
2222 is_broadcast_addr(uint8_t mode, uint8_t *addr)
2225 int i = mode == FRAME802154_SHORTADDRMODE ? 2 : 8;
2228 if(addr[i] != 0xff) {
2238 addr_check_auto_ack(uint8_t *frame, uint16_t frame_len)
2261 if((rx_mode_value & RADIO_RX_MODE_AUTOACK) &&
2264 (!(rx_mode_value & RADIO_RX_MODE_ADDRESS_FILTER) ||
2274 uint8_t ack[ACK_LEN] = { FRAME802154_ACKFRAME, 0, info154.
seq };
2276 #if (RXOFF_MODE_RX == 1) 2284 prepare((
const uint8_t *)ack, ACK_LEN);
2285 idle_tx_rx((
const uint8_t *)ack, ACK_LEN);
2289 return ADDR_CHECK_OK_ACK_SEND;
2293 return ADDR_CHECK_OK;
2297 return ADDR_CHECK_FAILED;
2303 return INVALID_FRAME;
2312 cc1200_rx_interrupt(
void)
2318 uint8_t num_rxbytes;
2320 static uint16_t payload_len;
2325 static uint16_t bytes_read;
2331 static uint8_t buf[CC1200_MAX_PAYLOAD_LEN + APPENDIX_LEN];
2338 #if CC1200_USE_GPIO2 2339 int gpio2 = cc1200_arch_gpio2_read_pin();
2340 int gpio0 = cc1200_arch_gpio0_read_pin();
2341 if((rf_flags & RF_RX_ONGOING) == 0 && gpio2 > 0) {
2342 rf_flags |= RF_RX_ONGOING;
2346 rf_flags &= ~RF_RX_ONGOING;
2350 if(SPI_IS_LOCKED()) {
2358 rf_flags |= RF_POLL_RX_INTERRUPT;
2363 rf_flags &= ~RF_POLL_RX_INTERRUPT;
2375 if((s == STATE_RX_FIFO_ERR) || (s == STATE_TX_FIFO_ERR)) {
2383 num_rxbytes = single_read(CC1200_NUM_RXBYTES);
2385 if(num_rxbytes == 0) {
2393 INFO(
"RF: RX FIFO empty!\n");
2399 if(!(rf_flags & RF_RX_PROCESSING_PKT)) {
2408 if(num_rxbytes < PHR_LEN) {
2410 WARNING(
"RF: PHR incomplete!\n");
2417 burst_read(CC1200_RXFIFO,
2420 payload_len = (phr.phra & 0x07);
2422 payload_len += phr.phrb;
2424 if(phr.phra & (1 << 4)) {
2433 burst_read(CC1200_RXFIFO,
2434 (uint8_t *)&payload_len,
2438 if(payload_len < ACK_LEN) {
2440 WARNING(
"RF: Packet too short!\n");
2446 if(payload_len > CC1200_MAX_PAYLOAD_LEN) {
2448 WARNING(
"RF: Packet to long!\n");
2456 num_rxbytes -= PHR_LEN;
2458 rf_flags |= RF_RX_PROCESSING_PKT;
2464 if(rf_flags & RF_RX_PROCESSING_PKT) {
2471 if((num_rxbytes + bytes_read) > (payload_len + CC_APPENDIX_LEN)) {
2479 WARNING(
"RF: RX length mismatch %d %d %d!\n", num_rxbytes,
2488 burst_read(CC1200_RXFIFO,
2492 bytes_read += num_rxbytes;
2495 if(bytes_read == (payload_len + CC_APPENDIX_LEN)) {
2504 uint8_t crc_lqi = buf[bytes_read - 1];
2506 int8_t rssi = single_read(CC1200_RSSI1);
2507 uint8_t crc_lqi = single_read(CC1200_LQI_VAL);
2510 if(!(crc_lqi & (1 << 7))) {
2512 INFO(
"RF: CRC error!\n");
2513 }
else if(rx_pkt_len != 0) {
2515 WARNING(
"RF: Packet pending!\n");
2518 int ret = addr_check_auto_ack(buf, bytes_read);
2520 if((ret == ADDR_CHECK_OK) ||
2521 (ret == ADDR_CHECK_OK_ACK_SEND)) {
2525 buf[bytes_read++] = (uint8_t)rssi;
2526 buf[bytes_read++] = crc_lqi;
2528 rx_pkt_len = bytes_read;
2529 memcpy((
void *)rx_pkt, buf, rx_pkt_len);
radio_result_t(* get_object)(radio_param_t param, void *dest, size_t size)
Get a radio parameter object.
void * packetbuf_dataptr(void)
Get a pointer to the data in the packetbuf.
uint8_t dest_addr_mode
2 bit.
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
#define PROCESS(name, strname)
Declare a process.
void etimer_stop(struct etimer *et)
Stop a pending event timer.
frame802154_fcf_t fcf
Frame control field.
#define PROCESS_CONTEXT_END(p)
End a context switch.
void packetbuf_clear(void)
Clear and reset the packetbuf.
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Header file for the energy estimation mechanism
#define PROCESS_YIELD_UNTIL(c)
Yield the currently running process until a condition occurs.
#define PROCESS_BEGIN()
Define the beginning of a process.
#define PROCESS_END()
Define the end of a process.
int frame802154_parse(uint8_t *data, int len, frame802154_t *pf)
Parses an input frame.
int(* receiving_packet)(void)
Check if the radio driver is currently receiving a packet.
#define PROCESS_WAIT_EVENT_UNTIL(c)
Wait for an event to be posted to the process, with an extra condition.
radio_result_t(* set_value)(radio_param_t param, radio_value_t value)
Set a radio parameter value.
int(* pending_packet)(void)
Check if the radio driver has just received a packet.
void clock_delay_usec(uint16_t dt)
Delay a given number of microseconds.
The structure of a device driver for a radio in Contiki.
#define RTIMER_BUSYWAIT_UNTIL(cond, max_time)
Busy-wait until a condition for at most max_time.
static void set_channel(uint8_t channel)
Set the current operating channel.
int(* channel_clear)(void)
Perform a Clear-Channel Assessment (CCA) to find out if there is a packet in the air or not...
unsigned long clock_seconds(void)
Get the current value of the platform seconds.
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
void leds_on(unsigned char leds)
Turn on multiple LEDs.
void leds_off(unsigned char leds)
Turn off multiple LEDs.
linkaddr_t linkaddr_node_addr
The link-layer address of the node.
#define RTIMER_NOW()
Get the current clock time.
#define CLOCK_SECOND
A second, measured in system clock time.
void(* input)(void)
Callback for getting notified of incoming packet.
int(* send)(const void *payload, unsigned short payload_len)
Prepare & transmit a packet.
int(* transmit)(unsigned short transmit_len)
Send the packet that has previously been prepared.
void process_poll(struct process *p)
Request a process to be polled.
int(* off)(void)
Turn the radio off.
#define PACKETBUF_SIZE
The size of the packetbuf, in bytes.
void clock_delay(unsigned int i)
Obsolete delay function but we implement it here since some code still uses it.
int etimer_expired(struct etimer *et)
Check if an event timer has expired.
#define RADIO_RX_MODE_ADDRESS_FILTER
The radio reception mode controls address filtering and automatic transmission of acknowledgements in...
#define PROCESS_YIELD()
Yield the currently running process.
Parameters used by the frame802154_create() function.
#define RADIO_TX_MODE_SEND_ON_CCA
The radio transmission mode controls whether transmissions should be done using clear channel assessm...
int linkaddr_cmp(const linkaddr_t *addr1, const linkaddr_t *addr2)
Compare two link-layer addresses.
#define PROCESS_CONTEXT_BEGIN(p)
Switch context to another process.
uint8_t seq
Sequence number.
static radio_value_t get_rssi(void)
Reads the current signal strength (RSSI)
int(* read)(void *buf, unsigned short buf_len)
Read a received packet into a buffer.
Header file for the Packet buffer (packetbuf) management
Include file for the Contiki low-layer network stack (NETSTACK)
void watchdog_periodic(void)
Writes the WDT clear sequence.
radio_result_t(* get_value)(radio_param_t param, radio_value_t *value)
Get a radio parameter value.
PROCESS_THREAD(cc2538_rf_process, ev, data)
Implementation of the cc2538 RF driver process.
uint8_t dest_addr[8]
Destination address.
void etimer_reset(struct etimer *et)
Reset an event timer with the same interval as was previously set.
radio_result_t(* set_object)(radio_param_t param, const void *src, size_t size)
Set a radio parameter object.
Header file for the LED HAL.
uint8_t ack_required
1 bit.
void etimer_set(struct etimer *et, clock_time_t interval)
Set an event timer.
void packetbuf_set_datalen(uint16_t len)
Set the length of the data in the packetbuf.
#define PROCESS_POLLHANDLER(handler)
Specify an action when a process is polled.
int(* on)(void)
Turn the radio on.
#define RTIMER_BUSYWAIT(duration)
Busy-wait for a fixed duration.
void process_start(struct process *p, process_data_t data)
Start a process.