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;
1453 *(
const uint16_t **)dest = CC1200_RF_CFG.tsch_timing;
1454 return RADIO_RESULT_OK;
1458 return RADIO_RESULT_NOT_SUPPORTED;
1463 static radio_result_t
1464 set_object(radio_param_t param,
const void *src,
size_t size)
1467 return RADIO_RESULT_NOT_SUPPORTED;
1480 strobe(uint8_t strobe)
1485 cc1200_arch_spi_select();
1486 ret = cc1200_arch_spi_rw_byte(strobe);
1487 cc1200_arch_spi_deselect();
1498 cc1200_arch_spi_select();
1499 cc1200_arch_spi_rw_byte(CC1200_SRES);
1505 cc1200_arch_spi_deselect();
1511 single_write(uint16_t
addr, uint8_t val)
1516 cc1200_arch_spi_select();
1517 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1518 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_WRITE_CMD);
1519 cc1200_arch_spi_rw_byte((uint8_t)addr);
1521 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT);
1523 ret = cc1200_arch_spi_rw_byte(val);
1524 cc1200_arch_spi_deselect();
1532 single_read(uint16_t addr)
1537 cc1200_arch_spi_select();
1538 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1539 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_READ_CMD);
1540 cc1200_arch_spi_rw_byte((uint8_t)addr);
1542 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT);
1544 ret = cc1200_arch_spi_rw_byte(0);
1545 cc1200_arch_spi_deselect();
1553 burst_write(uint16_t addr,
const uint8_t *data, uint8_t data_len)
1556 cc1200_arch_spi_select();
1557 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1558 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_WRITE_CMD);
1559 cc1200_arch_spi_rw_byte((uint8_t)addr);
1561 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT | CC1200_BURST_BIT);
1563 cc1200_arch_spi_rw(NULL, data, data_len);
1564 cc1200_arch_spi_deselect();
1570 burst_read(uint16_t addr, uint8_t *data, uint8_t data_len)
1573 cc1200_arch_spi_select();
1574 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1575 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_READ_CMD);
1576 cc1200_arch_spi_rw_byte((uint8_t)addr);
1578 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT | CC1200_BURST_BIT);
1580 cc1200_arch_spi_rw(data, NULL, data_len);
1581 cc1200_arch_spi_deselect();
1587 write_reg_settings(
const registerSetting_t *reg_settings,
1588 uint16_t sizeof_reg_settings)
1591 int i = sizeof_reg_settings /
sizeof(registerSetting_t);
1593 if(reg_settings != NULL) {
1595 single_write(reg_settings->addr,
1609 #if CC1200_RF_TESTMODE 1620 write_reg_settings(CC1200_RF_CFG.register_settings,
1621 CC1200_RF_CFG.size_of_register_settings);
1624 #if CC1200_FREQ_OFFSET 1626 single_write(CC1200_FREQOFF1, (uint8_t)(CC1200_FREQ_OFFSET >> 8));
1628 single_write(CC1200_FREQOFF0, (uint8_t)(CC1200_FREQ_OFFSET));
1632 single_write(CC1200_AGC_GAIN_ADJUST, (int8_t)CC1200_RF_CFG.rssi_offset);
1638 #if (CC1200_RF_TESTMODE == 1) || (CC1200_RF_TESTMODE == 2) 1640 strobe(CC1200_SFTX);
1641 single_write(CC1200_TXFIRST, 0);
1642 single_write(CC1200_TXLAST, 0xFF);
1643 update_txpower(CC1200_CONST_TX_POWER_MAX);
1644 single_write(CC1200_PKT_CFG2, 0x02);
1645 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1646 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1647 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1648 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1650 printf(
"RF: Freq0 0x%02x\n", ((uint8_t *)&freq)[0]);
1651 printf(
"RF: Freq1 0x%02x\n", ((uint8_t *)&freq)[1]);
1652 printf(
"RF: Freq2 0x%02x\n", ((uint8_t *)&freq)[2]);
1654 #if (CC1200_RF_TESTMODE == 1) 1655 single_write(CC1200_SYNC_CFG1, 0xE8);
1656 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1657 single_write(CC1200_MDMCFG1, 0x46);
1658 single_write(CC1200_PKT_CFG0, 0x40);
1659 single_write(CC1200_FS_DIG1, 0x07);
1660 single_write(CC1200_FS_DIG0, 0xAA);
1661 single_write(CC1200_FS_DVC1, 0xFF);
1662 single_write(CC1200_FS_DVC0, 0x17);
1665 #if (CC1200_RF_TESTMODE == 2) 1666 single_write(CC1200_SYNC_CFG1, 0xE8);
1667 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1668 single_write(CC1200_MDMCFG1, 0x06);
1669 single_write(CC1200_PA_CFG1, 0x3F);
1670 single_write(CC1200_MDMCFG2, 0x03);
1671 single_write(CC1200_FS_DIG1, 0x07);
1672 single_write(CC1200_FS_DIG0, 0xAA);
1673 single_write(CC1200_FS_DVC0, 0x17);
1674 single_write(CC1200_SERIAL_STATUS, 0x08);
1680 #if (CC1200_RF_TESTMODE == 1) 1701 #elif (CC1200_RF_TESTMODE == 3) 1704 single_write(CC1200_IOCFG3, CC1200_IOCFG_CARRIER_SENSE);
1705 single_write(CC1200_IOCFG2, CC1200_IOCFG_SERIAL_CLK);
1706 single_write(CC1200_IOCFG0, CC1200_IOCFG_SERIAL_RX);
1707 update_cca_threshold(CC1200_RF_CFG.cca_threshold);
1708 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1709 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1710 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1711 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1727 if(cc1200_arch_gpio3_read_pin() == 1) {
1742 single_write(CC1200_IOCFG3, GPIO3_IOCFG);
1743 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1744 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1746 reg = single_read(CC1200_SETTLING_CFG);
1759 single_write(CC1200_SETTLING_CFG, reg);
1762 reg = single_read(CC1200_RFEND_CFG1);
1768 single_write(CC1200_RFEND_CFG1, reg);
1771 reg = single_read(CC1200_RFEND_CFG0);
1776 single_write(CC1200_RFEND_CFG0, reg);
1784 single_write(CC1200_PKT_CFG2, (1 << 5));
1786 single_write(CC1200_PKT_CFG2, 0x00);
1790 reg = single_read(CC1200_PKT_CFG1);
1796 single_write(CC1200_PKT_CFG1, reg);
1799 reg = single_read(CC1200_PKT_CFG0);
1802 single_write(CC1200_PKT_CFG0, reg);
1804 #ifdef FIFO_THRESHOLD 1806 single_write(CC1200_FIFO_CFG, FIFO_THRESHOLD);
1816 #if STATE_USES_MARC_STATE 1817 return single_read(CC1200_MARCSTATE) & 0x1f;
1819 return strobe(CC1200_SNOP) & 0x70;
1830 #ifdef RF_FORCE_CALIBRATION 1831 if (!(rf_flags & RF_FORCE_CALIBRATION)
1832 && ((
clock_seconds() - cal_timer) < CC1200_CAL_TIMEOUT_SECONDS)) {
1836 rf_flags &= ~RF_FORCE_CALIBRATION;
1839 INFO(
"RF: Calibrate\n");
1841 strobe(CC1200_SCAL);
1842 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_CALIBRATE, RTIMER_SECOND / 100);
1843 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1845 #if CC1200_CAL_TIMEOUT_SECONDS 1859 DISABLE_GPIO_INTERRUPTS();
1864 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1865 ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
1869 if(s == STATE_IDLE) {
1871 }
else if(s == STATE_RX_FIFO_ERR) {
1872 WARNING(
"RF: RX FIFO error!\n");
1873 strobe(CC1200_SFRX);
1874 }
else if(s == STATE_TX_FIFO_ERR) {
1875 WARNING(
"RF: TX FIFO error!\n");
1876 strobe(CC1200_SFTX);
1879 strobe(CC1200_SIDLE);
1880 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1886 idle_calibrate_rx(
void)
1889 RF_ASSERT(state() == STATE_IDLE);
1895 rf_flags &= ~RF_RX_PROCESSING_PKT;
1896 strobe(CC1200_SFRX);
1898 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1900 ENABLE_GPIO_INTERRUPTS();
1902 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
1911 uint8_t s = state();
1913 if(s == STATE_IDLE) {
1915 }
else if(s == STATE_RX_FIFO_ERR) {
1916 WARNING(
"RF: RX FIFO error!\n");
1917 strobe(CC1200_SFRX);
1918 }
else if(s == STATE_TX_FIFO_ERR) {
1919 WARNING(
"RF: TX FIFO error!\n");
1920 strobe(CC1200_SFTX);
1922 strobe(CC1200_SIDLE);
1923 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE,
1924 RTIMER_SECOND / 100);
1928 rf_flags &= ~RF_RX_PROCESSING_PKT;
1931 ENABLE_GPIO_INTERRUPTS();
1933 strobe(CC1200_SFRX);
1935 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1941 idle_tx_rx(
const uint8_t *payload, uint16_t payload_len)
1943 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1949 rf_flags &= ~RF_RX_PROCESSING_PKT;
1950 strobe(CC1200_SFRX);
1953 single_write(CC1200_IOCFG0, CC1200_IOCFG_MARC_2PIN_STATUS_0);
1955 #if CC1200_WITH_TX_BUF 1957 copy_header_to_tx_fifo(payload_len);
1966 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1967 to_write = MIN(payload_len, (CC1200_FIFO_SIZE - PHR_LEN));
1968 burst_write(CC1200_TXFIFO, payload, to_write);
1969 bytes_left_to_write = payload_len - to_write;
1970 p = payload + to_write;
1972 burst_write(CC1200_TXFIFO, payload, payload_len);
1978 RTIMER_BUSYWAIT_UNTIL_STATE(STATE_FSTXON, RTIMER_SECOND / 100);
1991 ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
1993 if((cc1200_arch_gpio0_read_pin() == 0) &&
1994 (single_read(CC1200_NUM_TXBYTES) != 0)) {
2001 ERROR(
"RF: TX doesn't start!\n");
2002 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2003 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2008 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2010 return RADIO_TX_ERR;
2014 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) && CC1200_WITH_TX_BUF 2015 if(bytes_left_to_write != 0) {
2020 if((bytes_left_to_write != 0) &&
2021 (cc1200_arch_gpio2_read_pin() == 0)) {
2023 to_write = MIN(bytes_left_to_write, FIFO_THRESHOLD);
2024 burst_write(CC1200_TXFIFO, p, to_write);
2025 bytes_left_to_write -= to_write;
2027 t0 += CC1200_RF_CFG.tx_pkt_lifetime;
2029 }
while((cc1200_arch_gpio0_read_pin() == 1) &&
2030 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + CC1200_RF_CFG.tx_pkt_lifetime));
2040 if((s != STATE_RX) && (s != STATE_SETTLING)) {
2047 INFO(
"RF: TX failure!\n");
2050 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2054 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2056 return RADIO_TX_ERR;
2063 CC1200_RF_CFG.tx_pkt_lifetime);
2068 CC1200_RF_CFG.tx_pkt_lifetime);
2071 if(cc1200_arch_gpio0_read_pin() == 1) {
2073 ERROR(
"RF: TX takes to long!\n");
2074 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2076 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2081 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2083 return RADIO_TX_ERR;
2087 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 2089 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
2093 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
2097 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
2105 update_txpower(int8_t txpower_dbm)
2108 uint8_t reg = single_read(CC1200_PA_CFG1);
2112 reg |= ((((txpower_dbm + 18) * 2) - 1) & 0x3F);
2113 single_write(CC1200_PA_CFG1, reg);
2115 txpower = txpower_dbm;
2121 update_cca_threshold(int8_t threshold_dbm)
2124 single_write(CC1200_AGC_CS_THR, (uint8_t)threshold_dbm);
2125 cca_threshold = threshold_dbm;
2131 calculate_freq(uint8_t channel)
2136 freq = CC1200_RF_CFG.chan_center_freq0 + (channel * CC1200_RF_CFG.chan_spacing) / 1000 ;
2137 freq *= FREQ_MULTIPLIER;
2138 freq /= FREQ_DIVIDER;
2149 uint8_t was_off = 0;
2152 channel %= (CC1200_RF_CFG.max_channel - CC1200_RF_CFG.min_channel + 1);
2153 channel += CC1200_RF_CFG.min_channel;
2160 if(channel == rf_channel) {
2165 if(channel < CC1200_RF_CFG.min_channel ||
2166 channel > CC1200_RF_CFG.max_channel) {
2168 return CHANNEL_OUT_OF_LIMITS;
2175 new_rf_channel = channel;
2176 rf_flags |= RF_UPDATE_CHANNEL;
2178 INFO(
"RF: Channel update postponed\n");
2180 return CHANNEL_UPDATE_POSTPONED;
2183 rf_flags &= ~RF_UPDATE_CHANNEL;
2185 INFO(
"RF: Channel update (%d)\n", channel);
2187 if(!(rf_flags & RF_ON)) {
2196 freq = calculate_freq(channel - CC1200_RF_CFG.min_channel);
2197 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
2198 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
2199 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
2201 rf_channel = channel;
2205 #ifdef RF_FORCE_CALIBRATION 2206 rf_flags |= RF_FORCE_CALIBRATION;
2208 idle_calibrate_rx();
2217 return CHANNEL_UPDATE_SUCCEEDED;
2223 is_broadcast_addr(uint8_t mode, uint8_t *addr)
2226 int i = mode == FRAME802154_SHORTADDRMODE ? 2 : 8;
2229 if(addr[i] != 0xff) {
2239 addr_check_auto_ack(uint8_t *frame, uint16_t frame_len)
2262 if((rx_mode_value & RADIO_RX_MODE_AUTOACK) &&
2265 (!(rx_mode_value & RADIO_RX_MODE_ADDRESS_FILTER) ||
2275 uint8_t ack[ACK_LEN] = { FRAME802154_ACKFRAME, 0, info154.
seq };
2277 #if (RXOFF_MODE_RX == 1) 2285 prepare((
const uint8_t *)ack, ACK_LEN);
2286 idle_tx_rx((
const uint8_t *)ack, ACK_LEN);
2290 return ADDR_CHECK_OK_ACK_SEND;
2294 return ADDR_CHECK_OK;
2298 return ADDR_CHECK_FAILED;
2304 return INVALID_FRAME;
2313 cc1200_rx_interrupt(
void)
2319 uint8_t num_rxbytes;
2321 static uint16_t payload_len;
2326 static uint16_t bytes_read;
2332 static uint8_t buf[CC1200_MAX_PAYLOAD_LEN + APPENDIX_LEN];
2339 #if CC1200_USE_GPIO2 2340 int gpio2 = cc1200_arch_gpio2_read_pin();
2341 int gpio0 = cc1200_arch_gpio0_read_pin();
2342 if((rf_flags & RF_RX_ONGOING) == 0 && gpio2 > 0) {
2343 rf_flags |= RF_RX_ONGOING;
2347 rf_flags &= ~RF_RX_ONGOING;
2351 if(SPI_IS_LOCKED()) {
2359 rf_flags |= RF_POLL_RX_INTERRUPT;
2364 rf_flags &= ~RF_POLL_RX_INTERRUPT;
2376 if((s == STATE_RX_FIFO_ERR) || (s == STATE_TX_FIFO_ERR)) {
2384 num_rxbytes = single_read(CC1200_NUM_RXBYTES);
2386 if(num_rxbytes == 0) {
2394 INFO(
"RF: RX FIFO empty!\n");
2400 if(!(rf_flags & RF_RX_PROCESSING_PKT)) {
2409 if(num_rxbytes < PHR_LEN) {
2411 WARNING(
"RF: PHR incomplete!\n");
2418 burst_read(CC1200_RXFIFO,
2421 payload_len = (phr.phra & 0x07);
2423 payload_len += phr.phrb;
2425 if(phr.phra & (1 << 4)) {
2434 burst_read(CC1200_RXFIFO,
2435 (uint8_t *)&payload_len,
2439 if(payload_len < ACK_LEN) {
2441 WARNING(
"RF: Packet too short!\n");
2447 if(payload_len > CC1200_MAX_PAYLOAD_LEN) {
2449 WARNING(
"RF: Packet to long!\n");
2457 num_rxbytes -= PHR_LEN;
2459 rf_flags |= RF_RX_PROCESSING_PKT;
2465 if(rf_flags & RF_RX_PROCESSING_PKT) {
2472 if((num_rxbytes + bytes_read) > (payload_len + CC_APPENDIX_LEN)) {
2480 WARNING(
"RF: RX length mismatch %d %d %d!\n", num_rxbytes,
2489 burst_read(CC1200_RXFIFO,
2493 bytes_read += num_rxbytes;
2496 if(bytes_read == (payload_len + CC_APPENDIX_LEN)) {
2505 uint8_t crc_lqi = buf[bytes_read - 1];
2507 int8_t rssi = single_read(CC1200_RSSI1);
2508 uint8_t crc_lqi = single_read(CC1200_LQI_VAL);
2511 if(!(crc_lqi & (1 << 7))) {
2513 INFO(
"RF: CRC error!\n");
2514 }
else if(rx_pkt_len != 0) {
2516 WARNING(
"RF: Packet pending!\n");
2519 int ret = addr_check_auto_ack(buf, bytes_read);
2521 if((ret == ADDR_CHECK_OK) ||
2522 (ret == ADDR_CHECK_OK_ACK_SEND)) {
2526 buf[bytes_read++] = (uint8_t)rssi;
2527 buf[bytes_read++] = crc_lqi;
2529 rx_pkt_len = bytes_read;
2530 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.