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" 68 #ifndef CC1200_RF_TESTMODE 69 #define CC1200_RF_TESTMODE 0 72 #if CC1200_RF_TESTMODE 74 #if CC1200_RF_TESTMODE == 1 75 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 76 #elif CC1200_RF_TESTMODE == 2 77 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 78 #elif CC1200_RF_TESTMODE == 3 79 #define CC1200_RF_CFG cc1200_802154g_863_870_fsk_50kbps 89 #define STATE_USES_MARC_STATE 0 108 #define APPENDIX_LEN 2 114 #if CC1200_MAX_PAYLOAD_LEN > (2048 - PHR_LEN) 115 #error Payload length not supported by this driver 118 #if CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN) 120 #error Payload length not supported without GPIO2 124 #if CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN) 126 #error Payload length not supported without enabling 802.15.4g mode 134 #define GPIO2_IOCFG CC1200_IOCFG_RXFIFO_THR 136 #define FIFO_THRESHOLD 32 138 #define RXOFF_MODE_RX 1 140 #define APPEND_STATUS 1 143 #define GPIO2_IOCFG CC1200_IOCFG_MARC_2PIN_STATUS_0 144 #if (CC1200_MAX_PAYLOAD_LEN <= (CC1200_FIFO_SIZE - PHR_LEN - APPENDIX_LEN)) 149 #define RXOFF_MODE_RX 1 151 #define APPEND_STATUS 1 157 #define RXOFF_MODE_RX 0 159 #define APPEND_STATUS 0 164 #define GPIO0_IOCFG CC1200_IOCFG_PKT_SYNC_RXTX 166 #define GPIO3_IOCFG CC1200_IOCFG_MARC_2PIN_STATUS_0 168 #define TXOFF_MODE_RX 1 171 #define CC_APPENDIX_LEN 2 174 #define CC_APPENDIX_LEN 0 180 extern const cc1200_rf_cfg_t CC1200_RF_CFG;
185 #define XTAL_FREQ_KHZ 40000 192 #if (XTAL_FREQ_KHZ == 40000) && (LO_DIVIDER == 4) 193 #define FREQ_DIVIDER 625 194 #define FREQ_MULTIPLIER 4096 196 #error Invalid settings for frequency calculation 199 #if STATE_USES_MARC_STATE 201 #define STATE_IDLE CC1200_MARC_STATE_IDLE 202 #define STATE_RX CC1200_MARC_STATE_RX 203 #define STATE_TX CC1200_MARC_STATE_TX 204 #define STATE_RX_FIFO_ERROR CC1200_MARC_STATE_RX_FIFO_ERR 205 #define STATE_TX_FIFO_ERROR CC1200_MARC_STATE_TX_FIFO_ERR 208 #define STATE_IDLE CC1200_STATUS_BYTE_IDLE 209 #define STATE_RX CC1200_STATUS_BYTE_RX 210 #define STATE_TX CC1200_STATUS_BYTE_TX 211 #define STATE_FSTXON CC1200_STATUS_BYTE_FSTXON 212 #define STATE_CALIBRATE CC1200_STATUS_BYTE_CALIBRATE 213 #define STATE_SETTLING CC1200_STATUS_BYTE_SETTLING 214 #define STATE_RX_FIFO_ERR CC1200_STATUS_BYTE_RX_FIFO_ERR 215 #define STATE_TX_FIFO_ERR CC1200_STATUS_BYTE_TX_FIFO_ERR 221 #define INVALID_FRAME 0 223 #define ADDR_CHECK_FAILED 1 225 #define ADDR_CHECK_OK 2 227 #define ADDR_CHECK_OK_ACK_SEND 3 232 #define CHANNEL_UPDATE_SUCCEEDED 0 234 #define CHANNEL_UPDATE_POSTPONED 1 236 #define CHANNEL_OUT_OF_LIMITS 2 241 #define RF_INITIALIZED 0x01 245 #define RF_RX_PROCESSING_PKT 0x04 247 #define RF_TX_ACTIVE 0x08 249 #define RF_UPDATE_CHANNEL 0x10 251 #define RF_POLL_RX_INTERRUPT 0x20 254 #if CC1200_CAL_TIMEOUT_SECONDS 255 #define RF_FORCE_CALIBRATION 0x40 264 #ifdef CC1200_TX_LEDS 265 #define TX_LEDS_ON() leds_on(CC1200_TX_LEDS) 266 #define TX_LEDS_OFF() leds_off(CC1200_TX_LEDS) 269 #define TX_LEDS_OFF() 272 #ifdef CC1200_RX_LEDS 273 #define RX_LEDS_ON() leds_on(CC1200_RX_LEDS) 274 #define RX_LEDS_OFF() leds_off(CC1200_RX_LEDS) 277 #define RX_LEDS_OFF() 285 #define LOCK_SPI() do { spi_locked++; } while(0) 286 #define SPI_IS_LOCKED() (spi_locked != 0) 287 #define RELEASE_SPI() do { spi_locked--; } while(0) 289 #define BUSYWAIT_UNTIL(cond, max_time) \ 293 while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) { \ 294 watchdog_periodic(); \ 300 #define SETUP_GPIO_INTERRUPTS() \ 302 cc1200_arch_gpio0_setup_irq(0); \ 303 cc1200_arch_gpio2_setup_irq(1); \ 305 #define ENABLE_GPIO_INTERRUPTS() \ 307 cc1200_arch_gpio0_enable_irq(); \ 308 cc1200_arch_gpio2_enable_irq(); \ 310 #define DISABLE_GPIO_INTERRUPTS() \ 312 cc1200_arch_gpio0_disable_irq(); \ 313 cc1200_arch_gpio2_disable_irq(); \ 316 #define SETUP_GPIO_INTERRUPTS() cc1200_arch_gpio0_setup_irq(0) 317 #define ENABLE_GPIO_INTERRUPTS() cc1200_arch_gpio0_enable_irq() 318 #define DISABLE_GPIO_INTERRUPTS() cc1200_arch_gpio0_disable_irq() 325 #define ERROR(...) printf(__VA_ARGS__) 332 #define RF_ASSERT(condition) \ 335 printf("RF: Assertion failed in line %d\n", __LINE__); \ 339 #define RF_ASSERT(condition) 344 #define WARNING(...) printf(__VA_ARGS__) 351 #define INFO(...) printf(__VA_ARGS__) 362 #define BUSYWAIT_UNTIL_STATE(s, t) \ 366 while((state() != s) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t))) {} \ 367 if(!(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t)))) { \ 368 printf("RF: Timeout exceeded in line %d!\n", __LINE__); \ 372 #define BUSYWAIT_UNTIL_STATE(s, t) \ 376 while((state() != s) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t))) {} \ 383 static volatile uint8_t spi_locked = 0;
385 static uint8_t tx_pkt[CC1200_MAX_PAYLOAD_LEN];
387 static uint16_t tx_pkt_len;
389 static uint8_t rx_pkt[CC1200_MAX_PAYLOAD_LEN + APPENDIX_LEN];
391 static volatile uint16_t rx_pkt_len = 0;
396 static uint8_t rf_channel;
398 static uint8_t new_rf_channel;
404 static int8_t txpower;
405 static int8_t new_txpower;
407 static int8_t cca_threshold;
408 static int8_t new_cca_threshold;
410 static uint8_t rf_flags = 0;
411 #if !CC1200_AUTOCAL && CC1200_CAL_TIMEOUT_SECONDS 413 static unsigned long cal_timer;
415 #if CC1200_USE_RX_WATCHDOG 427 prepare(
const void *payload,
unsigned short payload_len);
430 transmit(
unsigned short payload_len);
433 send(
const void *payload,
unsigned short payload_len);
436 read(
void *buf,
unsigned short bufsize);
445 receiving_packet(
void);
448 pending_packet(
void);
456 static radio_result_t
459 static radio_result_t
462 static radio_result_t
463 get_object(radio_param_t param,
void *dest,
size_t size);
465 static radio_result_t
466 set_object(radio_param_t param,
const void *src,
size_t size);
493 strobe(uint8_t strobe);
499 single_write(uint16_t
addr, uint8_t value);
502 single_read(uint16_t
addr);
505 burst_write(uint16_t
addr,
const uint8_t *data, uint8_t data_len);
508 burst_read(uint16_t
addr, uint8_t *data, uint8_t data_len);
511 write_reg_settings(
const registerSetting_t *reg_settings,
512 uint16_t sizeof_reg_settings);
529 idle_calibrate_rx(
void);
535 idle_tx_rx(
const uint8_t *payload, uint16_t payload_len);
538 update_txpower(int8_t txpower_dbm);
541 update_cca_threshold(int8_t threshold_dbm);
544 calculate_freq(uint8_t channel);
550 addr_check_auto_ack(uint8_t *frame, uint16_t frame_len);
553 static void pollhandler(
void);
555 PROCESS(cc1200_process,
"CC1200 driver");
564 #if CC1200_USE_RX_WATCHDOG 567 if((rf_flags & (RF_ON | RF_TX_ACTIVE)) == RF_ON) {
581 if(cc1200_arch_gpio0_read_pin() == 0) {
591 if(state() != STATE_RX) {
592 WARNING(
"RF: RX watchdog triggered!\n");
617 if((rf_flags & (RF_ON + RF_POLL_RX_INTERRUPT)) ==
618 (RF_ON + RF_POLL_RX_INTERRUPT)) {
619 cc1200_rx_interrupt();
622 if(rf_flags & RF_UPDATE_CHANNEL) {
642 NETSTACK_MAC.
input();
661 INFO(
"RF: Init (%s)\n", CC1200_RF_CFG.cfg_descriptor);
663 if(!(rf_flags & RF_INITIALIZED)) {
671 SETUP_GPIO_INTERRUPTS();
683 new_txpower = CC1200_RF_CFG.max_txpower;
684 update_txpower(new_txpower);
687 new_cca_threshold = CC1200_RF_CFG.cca_threshold;
688 update_cca_threshold(new_cca_threshold);
693 rf_flags |= (RF_INITIALIZED + RF_ON);
713 prepare(
const void *payload,
unsigned short payload_len)
716 INFO(
"RF: Prepare (%d)\n", payload_len);
718 if((payload_len < ACK_LEN) ||
719 (payload_len > CC1200_MAX_PAYLOAD_LEN)) {
720 ERROR(
"RF: Invalid payload length!\n");
724 tx_pkt_len = payload_len;
725 memcpy(tx_pkt, payload, tx_pkt_len);
733 transmit(
unsigned short transmit_len)
737 int ret = RADIO_TX_OK;
739 INFO(
"RF: Transmit (%d)\n", transmit_len);
741 if(transmit_len != tx_pkt_len) {
742 ERROR(
"RF: TX length mismatch!\n");
747 rf_flags |= RF_TX_ACTIVE;
749 if(!(rf_flags & RF_ON)) {
763 rf_flags &= ~RF_TX_ACTIVE;
764 return RADIO_TX_COLLISION;
781 if(new_txpower != txpower) {
782 update_txpower(new_txpower);
793 if(idle_tx_rx((
const uint8_t *)tx_pkt, tx_pkt_len) == RADIO_TX_OK) {
801 BUSYWAIT_UNTIL_STATE(STATE_RX,
802 CC1200_RF_CFG.tx_rx_turnaround);
804 ENABLE_GPIO_INTERRUPTS();
816 #ifdef RF_FORCE_CALIBRATION 817 rf_flags |= RF_FORCE_CALIBRATION;
831 rf_flags &= ~RF_TX_ACTIVE;
839 send(
const void *payload,
unsigned short payload_len)
844 INFO(
"RF: Send (%d)\n", payload_len);
847 if((ret =
prepare(payload, payload_len)) == RADIO_TX_OK) {
857 read(
void *buf,
unsigned short buf_len)
864 int8_t rssi = rx_pkt[rx_pkt_len - 2];
866 uint8_t crc_lqi = rx_pkt[rx_pkt_len - 1];
868 len = rx_pkt_len - APPENDIX_LEN;
872 ERROR(
"RF: Failed to read packet (too big)!\n");
876 INFO(
"RF: Read (%d bytes, %d dBm)\n", len, rssi);
878 memcpy((
void *)buf, (
const void *)rx_pkt, len);
883 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rssi);
885 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY,
886 crc_lqi & ~(1 << 7));
903 uint8_t cca, was_off = 0;
905 if(SPI_IS_LOCKED()) {
910 if(!(rf_flags & RF_ON)) {
918 RF_ASSERT(state() == STATE_RX);
927 if(cc1200_arch_gpio0_read_pin() == 1) {
929 INFO(
"RF: CCA (0)\n");
936 if(new_cca_threshold != cca_threshold) {
937 update_cca_threshold(new_cca_threshold);
941 BUSYWAIT_UNTIL(((rssi0 = single_read(CC1200_RSSI0))
942 & CC1200_CARRIER_SENSE_VALID),
943 RTIMER_SECOND / 100);
944 RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID);
946 if(rssi0 & CC1200_CARRIER_SENSE) {
948 INFO(
"RF: CCA (0)\n");
952 INFO(
"RF: CCA (1)\n");
981 if((rf_flags & (RF_ON | RF_TX_ACTIVE)) == RF_ON) {
983 if((cc1200_arch_gpio0_read_pin() == 1) || (rx_pkt_len != 0)) {
1003 INFO(
"RF: Receiving (%d)\n", ret);
1013 INFO(
"RF: Pending (%d)\n", ((rx_pkt_len != 0) ? 1 : 0));
1014 return (rx_pkt_len != 0) ? 1 : 0;
1026 if(!(rf_flags & RF_ON)) {
1028 if(SPI_IS_LOCKED()) {
1035 cc1200_arch_spi_select();
1036 BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
1037 RTIMER_SECOND / 100);
1038 RF_ASSERT((cc1200_arch_gpio0_read_pin() == 0));
1039 cc1200_arch_spi_deselect();
1044 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1047 idle_calibrate_rx();
1051 #if CC1200_USE_RX_WATCHDOG 1058 INFO(
"RF: Already on\n");
1073 if(rf_flags & RF_ON) {
1075 if(SPI_IS_LOCKED()) {
1087 single_write(CC1200_IOCFG0, CC1200_IOCFG_RXFIFO_CHIP_RDY_N);
1090 strobe(CC1200_SPWD);
1093 rf_flags = RF_INITIALIZED;
1097 #if CC1200_USE_RX_WATCHDOG 1102 INFO(
"RF: Already off\n");
1110 static radio_result_t
1115 return RADIO_RESULT_INVALID_VALUE;
1119 case RADIO_PARAM_POWER_MODE:
1121 if(rf_flags & RF_ON) {
1126 return RADIO_RESULT_OK;
1128 case RADIO_PARAM_CHANNEL:
1131 return RADIO_RESULT_OK;
1133 case RADIO_PARAM_PAN_ID:
1134 case RADIO_PARAM_16BIT_ADDR:
1136 return RADIO_RESULT_NOT_SUPPORTED;
1138 case RADIO_PARAM_RX_MODE:
1141 return RADIO_RESULT_OK;
1143 case RADIO_PARAM_TX_MODE:
1146 return RADIO_RESULT_OK;
1148 case RADIO_PARAM_TXPOWER:
1151 return RADIO_RESULT_OK;
1153 case RADIO_PARAM_CCA_THRESHOLD:
1156 return RADIO_RESULT_OK;
1158 case RADIO_PARAM_RSSI:
1159 case RADIO_PARAM_64BIT_ADDR:
1161 return RADIO_RESULT_NOT_SUPPORTED;
1163 case RADIO_CONST_CHANNEL_MIN:
1166 return RADIO_RESULT_OK;
1168 case RADIO_CONST_CHANNEL_MAX:
1171 return RADIO_RESULT_OK;
1173 case RADIO_CONST_TXPOWER_MIN:
1176 return RADIO_RESULT_OK;
1178 case RADIO_CONST_TXPOWER_MAX:
1181 return RADIO_RESULT_OK;
1185 return RADIO_RESULT_NOT_SUPPORTED;
1192 static radio_result_t
1197 case RADIO_PARAM_POWER_MODE:
1199 if(value == RADIO_POWER_MODE_ON) {
1201 return RADIO_RESULT_OK;
1204 if(value == RADIO_POWER_MODE_OFF) {
1206 return RADIO_RESULT_OK;
1209 return RADIO_RESULT_INVALID_VALUE;
1211 case RADIO_PARAM_CHANNEL:
1214 return RADIO_RESULT_INVALID_VALUE;
1225 return RADIO_RESULT_OK;
1227 case RADIO_PARAM_PAN_ID:
1228 case RADIO_PARAM_16BIT_ADDR:
1230 return RADIO_RESULT_NOT_SUPPORTED;
1232 case RADIO_PARAM_RX_MODE:
1234 rx_mode_value = value;
1235 return RADIO_RESULT_OK;
1237 case RADIO_PARAM_TX_MODE:
1239 tx_mode_value = value;
1240 return RADIO_RESULT_OK;
1242 case RADIO_PARAM_TXPOWER:
1253 new_txpower = (int8_t)value;
1254 return RADIO_RESULT_OK;
1256 case RADIO_PARAM_CCA_THRESHOLD:
1267 new_cca_threshold = (int8_t)value;
1268 return RADIO_RESULT_OK;
1270 case RADIO_PARAM_RSSI:
1271 case RADIO_PARAM_64BIT_ADDR:
1275 return RADIO_RESULT_NOT_SUPPORTED;
1282 static radio_result_t
1283 get_object(radio_param_t param,
void *dest,
size_t size)
1286 return RADIO_RESULT_NOT_SUPPORTED;
1291 static radio_result_t
1292 set_object(radio_param_t param,
const void *src,
size_t size)
1295 return RADIO_RESULT_NOT_SUPPORTED;
1308 strobe(uint8_t strobe)
1313 cc1200_arch_spi_select();
1314 ret = cc1200_arch_spi_rw_byte(strobe);
1315 cc1200_arch_spi_deselect();
1326 cc1200_arch_spi_select();
1327 cc1200_arch_spi_rw_byte(CC1200_SRES);
1333 cc1200_arch_spi_deselect();
1339 single_write(uint16_t
addr, uint8_t val)
1344 cc1200_arch_spi_select();
1345 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1346 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_WRITE_CMD);
1347 cc1200_arch_spi_rw_byte((uint8_t)addr);
1349 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT);
1351 ret = cc1200_arch_spi_rw_byte(val);
1352 cc1200_arch_spi_deselect();
1360 single_read(uint16_t addr)
1365 cc1200_arch_spi_select();
1366 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1367 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_READ_CMD);
1368 cc1200_arch_spi_rw_byte((uint8_t)addr);
1370 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT);
1372 ret = cc1200_arch_spi_rw_byte(0);
1373 cc1200_arch_spi_deselect();
1381 burst_write(uint16_t addr,
const uint8_t *data, uint8_t data_len)
1384 cc1200_arch_spi_select();
1385 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1386 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_WRITE_CMD);
1387 cc1200_arch_spi_rw_byte((uint8_t)addr);
1389 cc1200_arch_spi_rw_byte(addr | CC1200_WRITE_BIT | CC1200_BURST_BIT);
1391 cc1200_arch_spi_rw(NULL, data, data_len);
1392 cc1200_arch_spi_deselect();
1398 burst_read(uint16_t addr, uint8_t *data, uint8_t data_len)
1401 cc1200_arch_spi_select();
1402 if(CC1200_IS_EXTENDED_ADDR(addr)) {
1403 cc1200_arch_spi_rw_byte(CC1200_EXTENDED_BURST_READ_CMD);
1404 cc1200_arch_spi_rw_byte((uint8_t)addr);
1406 cc1200_arch_spi_rw_byte(addr | CC1200_READ_BIT | CC1200_BURST_BIT);
1408 cc1200_arch_spi_rw(data, NULL, data_len);
1409 cc1200_arch_spi_deselect();
1415 write_reg_settings(
const registerSetting_t *reg_settings,
1416 uint16_t sizeof_reg_settings)
1419 int i = sizeof_reg_settings /
sizeof(registerSetting_t);
1421 if(reg_settings != NULL) {
1423 single_write(reg_settings->addr,
1437 #if CC1200_RF_TESTMODE 1448 write_reg_settings(CC1200_RF_CFG.register_settings,
1449 CC1200_RF_CFG.size_of_register_settings);
1452 #if CC1200_FREQ_OFFSET 1454 single_write(CC1200_FREQOFF1, (uint8_t)(CC1200_FREQ_OFFSET >> 8));
1456 single_write(CC1200_FREQOFF0, (uint8_t)(CC1200_FREQ_OFFSET));
1460 single_write(CC1200_AGC_GAIN_ADJUST, (int8_t)CC1200_RF_CFG.rssi_offset);
1466 #if (CC1200_RF_TESTMODE == 1) || (CC1200_RF_TESTMODE == 2) 1468 strobe(CC1200_SFTX);
1469 single_write(CC1200_TXFIRST, 0);
1470 single_write(CC1200_TXLAST, 0xFF);
1471 update_txpower(CC1200_CONST_TX_POWER_MAX);
1472 single_write(CC1200_PKT_CFG2, 0x02);
1473 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1474 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1475 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1476 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1478 printf(
"RF: Freq0 0x%02x\n", ((uint8_t *)&freq)[0]);
1479 printf(
"RF: Freq1 0x%02x\n", ((uint8_t *)&freq)[1]);
1480 printf(
"RF: Freq2 0x%02x\n", ((uint8_t *)&freq)[2]);
1482 #if (CC1200_RF_TESTMODE == 1) 1483 single_write(CC1200_SYNC_CFG1, 0xE8);
1484 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1485 single_write(CC1200_MDMCFG1, 0x46);
1486 single_write(CC1200_PKT_CFG0, 0x40);
1487 single_write(CC1200_FS_DIG1, 0x07);
1488 single_write(CC1200_FS_DIG0, 0xAA);
1489 single_write(CC1200_FS_DVC1, 0xFF);
1490 single_write(CC1200_FS_DVC0, 0x17);
1493 #if (CC1200_RF_TESTMODE == 2) 1494 single_write(CC1200_SYNC_CFG1, 0xE8);
1495 single_write(CC1200_PREAMBLE_CFG1, 0x00);
1496 single_write(CC1200_MDMCFG1, 0x06);
1497 single_write(CC1200_PA_CFG1, 0x3F);
1498 single_write(CC1200_MDMCFG2, 0x03);
1499 single_write(CC1200_FS_DIG1, 0x07);
1500 single_write(CC1200_FS_DIG0, 0xAA);
1501 single_write(CC1200_FS_DVC0, 0x17);
1502 single_write(CC1200_SERIAL_STATUS, 0x08);
1508 #if (CC1200_RF_TESTMODE == 1) 1510 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1514 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1519 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1523 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1529 #elif (CC1200_RF_TESTMODE == 3) 1532 single_write(CC1200_IOCFG3, CC1200_IOCFG_CARRIER_SENSE);
1533 single_write(CC1200_IOCFG2, CC1200_IOCFG_SERIAL_CLK);
1534 single_write(CC1200_IOCFG0, CC1200_IOCFG_SERIAL_RX);
1535 update_cca_threshold(CC1200_RF_CFG.cca_threshold);
1536 freq = calculate_freq(CC1200_DEFAULT_CHANNEL - CC1200_RF_CFG.min_channel);
1537 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
1538 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
1539 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
1545 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1549 BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10);
1555 if(cc1200_arch_gpio3_read_pin() == 1) {
1570 single_write(CC1200_IOCFG3, GPIO3_IOCFG);
1571 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1572 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1574 reg = single_read(CC1200_SETTLING_CFG);
1587 single_write(CC1200_SETTLING_CFG, reg);
1590 reg = single_read(CC1200_RFEND_CFG1);
1596 single_write(CC1200_RFEND_CFG1, reg);
1599 reg = single_read(CC1200_RFEND_CFG0);
1604 single_write(CC1200_RFEND_CFG0, reg);
1612 single_write(CC1200_PKT_CFG2, (1 << 5));
1614 single_write(CC1200_PKT_CFG2, 0x00);
1618 reg = single_read(CC1200_PKT_CFG1);
1624 single_write(CC1200_PKT_CFG1, reg);
1627 reg = single_read(CC1200_PKT_CFG0);
1630 single_write(CC1200_PKT_CFG0, reg);
1632 #ifdef FIFO_THRESHOLD 1634 single_write(CC1200_FIFO_CFG, FIFO_THRESHOLD);
1644 #if STATE_USES_MARC_STATE 1645 return single_read(CC1200_MARCSTATE) & 0x1f;
1647 return strobe(CC1200_SNOP) & 0x70;
1658 #ifdef RF_FORCE_CALIBRATION 1659 if (!(rf_flags & RF_FORCE_CALIBRATION)
1660 && ((
clock_seconds() - cal_timer) < CC1200_CAL_TIMEOUT_SECONDS)) {
1664 rf_flags &= ~RF_FORCE_CALIBRATION;
1667 INFO(
"RF: Calibrate\n");
1669 strobe(CC1200_SCAL);
1670 BUSYWAIT_UNTIL_STATE(STATE_CALIBRATE, RTIMER_SECOND / 100);
1671 BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1673 #if CC1200_CAL_TIMEOUT_SECONDS 1687 DISABLE_GPIO_INTERRUPTS();
1692 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1693 ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
1697 if(s == STATE_IDLE) {
1699 }
else if(s == STATE_RX_FIFO_ERR) {
1700 WARNING(
"RF: RX FIFO error!\n");
1701 strobe(CC1200_SFRX);
1702 }
else if(s == STATE_TX_FIFO_ERR) {
1703 WARNING(
"RF: TX FIFO error!\n");
1704 strobe(CC1200_SFTX);
1707 strobe(CC1200_SIDLE);
1708 BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
1714 idle_calibrate_rx(
void)
1717 RF_ASSERT(state() == STATE_IDLE);
1723 rf_flags &= ~RF_RX_PROCESSING_PKT;
1724 strobe(CC1200_SFRX);
1726 BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1728 ENABLE_GPIO_INTERRUPTS();
1730 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
1739 uint8_t s = state();
1741 if(s == STATE_IDLE) {
1743 }
else if(s == STATE_RX_FIFO_ERR) {
1744 WARNING(
"RF: RX FIFO error!\n");
1745 strobe(CC1200_SFRX);
1746 }
else if(s == STATE_TX_FIFO_ERR) {
1747 WARNING(
"RF: TX FIFO error!\n");
1748 strobe(CC1200_SFTX);
1750 strobe(CC1200_SIDLE);
1751 BUSYWAIT_UNTIL_STATE(STATE_IDLE,
1752 RTIMER_SECOND / 100);
1756 rf_flags &= ~RF_RX_PROCESSING_PKT;
1759 ENABLE_GPIO_INTERRUPTS();
1761 strobe(CC1200_SFRX);
1763 BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
1769 idle_tx_rx(
const uint8_t *payload, uint16_t payload_len)
1772 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1773 uint16_t bytes_left_to_write;
1784 #if CC1200_802154G_CRC16 1790 phr.phrb = (uint8_t)(payload_len & 0x00FF);
1791 phr.phra = (uint8_t)((payload_len >> 8) & 0x0007);
1792 #if CC1200_802154G_WHITENING 1794 phr.phra |= (1 << 3);
1796 #if CC1200_802154G_CRC16 1798 phr.phra |= (1 << 4);
1803 rf_flags &= ~RF_RX_PROCESSING_PKT;
1804 strobe(CC1200_SFRX);
1807 strobe(CC1200_SFTX);
1815 strobe(CC1200_SFSTXON);
1819 single_write(CC1200_IOCFG0, CC1200_IOCFG_MARC_2PIN_STATUS_0);
1821 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1826 single_write(CC1200_IOCFG2, CC1200_IOCFG_TXFIFO_THR);
1831 burst_write(CC1200_TXFIFO, (uint8_t *)&phr, PHR_LEN);
1834 burst_write(CC1200_TXFIFO, (uint8_t *)&payload_len, PHR_LEN);
1844 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1845 to_write = MIN(payload_len, (CC1200_FIFO_SIZE - PHR_LEN));
1846 burst_write(CC1200_TXFIFO, payload, to_write);
1847 bytes_left_to_write = payload_len - to_write;
1848 p = payload + to_write;
1850 burst_write(CC1200_TXFIFO, payload, payload_len);
1855 BUSYWAIT_UNTIL_STATE(STATE_FSTXON, RTIMER_SECOND / 100);
1862 BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 1), RTIMER_SECOND / 100);
1868 ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
1870 if((cc1200_arch_gpio0_read_pin() == 0) &&
1871 (single_read(CC1200_NUM_TXBYTES) != 0)) {
1878 ERROR(
"RF: TX doesn't start!\n");
1879 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1880 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1885 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1887 return RADIO_TX_ERR;
1891 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1892 if(bytes_left_to_write != 0) {
1897 if((bytes_left_to_write != 0) &&
1898 (cc1200_arch_gpio2_read_pin() == 0)) {
1900 to_write = MIN(bytes_left_to_write, FIFO_THRESHOLD);
1901 burst_write(CC1200_TXFIFO, p, to_write);
1902 bytes_left_to_write -= to_write;
1904 t0 += CC1200_RF_CFG.tx_pkt_lifetime;
1906 }
while((cc1200_arch_gpio0_read_pin() == 1) &&
1907 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + CC1200_RF_CFG.tx_pkt_lifetime));
1917 if((s != STATE_RX) && (s != STATE_SETTLING)) {
1924 INFO(
"RF: TX failure!\n");
1925 BUSYWAIT_UNTIL((state() != STATE_TX), RTIMER_SECOND / 100);
1927 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1931 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1933 return RADIO_TX_ERR;
1939 BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
1940 CC1200_RF_CFG.tx_pkt_lifetime);
1944 BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
1945 CC1200_RF_CFG.tx_pkt_lifetime);
1948 if(cc1200_arch_gpio0_read_pin() == 1) {
1950 ERROR(
"RF: TX takes to long!\n");
1951 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1953 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1958 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1960 return RADIO_TX_ERR;
1964 #if (CC1200_MAX_PAYLOAD_LEN > (CC1200_FIFO_SIZE - PHR_LEN)) 1966 single_write(CC1200_IOCFG2, GPIO2_IOCFG);
1970 single_write(CC1200_IOCFG0, GPIO0_IOCFG);
1974 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
1982 update_txpower(int8_t txpower_dbm)
1985 uint8_t reg = single_read(CC1200_PA_CFG1);
1989 reg |= ((((txpower_dbm + 18) * 2) - 1) & 0x3F);
1990 single_write(CC1200_PA_CFG1, reg);
1992 txpower = txpower_dbm;
1998 update_cca_threshold(int8_t threshold_dbm)
2001 single_write(CC1200_AGC_CS_THR, (uint8_t)threshold_dbm);
2002 cca_threshold = threshold_dbm;
2008 calculate_freq(uint8_t channel)
2013 freq = CC1200_RF_CFG.chan_center_freq0 + (channel * CC1200_RF_CFG.chan_spacing) / 1000 ;
2014 freq *= FREQ_MULTIPLIER;
2015 freq /= FREQ_DIVIDER;
2026 uint8_t was_off = 0;
2034 if(channel == rf_channel) {
2039 if(channel < CC1200_RF_CFG.min_channel ||
2040 channel > CC1200_RF_CFG.max_channel) {
2042 return CHANNEL_OUT_OF_LIMITS;
2049 new_rf_channel = channel;
2050 rf_flags |= RF_UPDATE_CHANNEL;
2052 INFO(
"RF: Channel update postponed\n");
2054 return CHANNEL_UPDATE_POSTPONED;
2057 rf_flags &= ~RF_UPDATE_CHANNEL;
2059 INFO(
"RF: Channel update (%d)\n", channel);
2061 if(!(rf_flags & RF_ON)) {
2070 freq = calculate_freq(channel - CC1200_RF_CFG.min_channel);
2071 single_write(CC1200_FREQ0, ((uint8_t *)&freq)[0]);
2072 single_write(CC1200_FREQ1, ((uint8_t *)&freq)[1]);
2073 single_write(CC1200_FREQ2, ((uint8_t *)&freq)[2]);
2075 rf_channel = channel;
2079 #ifdef RF_FORCE_CALIBRATION 2080 rf_flags |= RF_FORCE_CALIBRATION;
2082 idle_calibrate_rx();
2091 return CHANNEL_UPDATE_SUCCEEDED;
2097 is_broadcast_addr(uint8_t mode, uint8_t *addr)
2100 int i = mode == FRAME802154_SHORTADDRMODE ? 2 : 8;
2103 if(addr[i] != 0xff) {
2113 addr_check_auto_ack(uint8_t *frame, uint16_t frame_len)
2136 if((rx_mode_value & RADIO_RX_MODE_AUTOACK) &&
2139 (!(rx_mode_value & RADIO_RX_MODE_ADDRESS_FILTER) ||
2149 uint8_t ack[ACK_LEN] = { FRAME802154_ACKFRAME, 0, info154.
seq };
2151 #if (RXOFF_MODE_RX == 1) 2159 idle_tx_rx((
const uint8_t *)ack, ACK_LEN);
2163 return ADDR_CHECK_OK_ACK_SEND;
2167 return ADDR_CHECK_OK;
2171 return ADDR_CHECK_FAILED;
2177 return INVALID_FRAME;
2186 cc1200_rx_interrupt(
void)
2192 uint8_t num_rxbytes;
2194 static uint16_t payload_len;
2199 static uint16_t bytes_read;
2205 static uint8_t buf[CC1200_MAX_PAYLOAD_LEN + APPENDIX_LEN];
2207 if(SPI_IS_LOCKED()) {
2215 rf_flags |= RF_POLL_RX_INTERRUPT;
2220 rf_flags &= ~RF_POLL_RX_INTERRUPT;
2232 if((s == STATE_RX_FIFO_ERR) || (s == STATE_TX_FIFO_ERR)) {
2240 num_rxbytes = single_read(CC1200_NUM_RXBYTES);
2242 if(num_rxbytes == 0) {
2250 INFO(
"RF: RX FIFO empty!\n");
2256 if(!(rf_flags & RF_RX_PROCESSING_PKT)) {
2265 if(num_rxbytes < PHR_LEN) {
2267 WARNING(
"RF: PHR incomplete!\n");
2274 burst_read(CC1200_RXFIFO,
2277 payload_len = (phr.phra & 0x07);
2279 payload_len += phr.phrb;
2281 if(phr.phra & (1 << 4)) {
2290 burst_read(CC1200_RXFIFO,
2291 (uint8_t *)&payload_len,
2295 if(payload_len < ACK_LEN) {
2297 WARNING(
"RF: Packet too short!\n");
2303 if(payload_len > CC1200_MAX_PAYLOAD_LEN) {
2305 WARNING(
"RF: Packet to long!\n");
2313 num_rxbytes -= PHR_LEN;
2315 rf_flags |= RF_RX_PROCESSING_PKT;
2321 if(rf_flags & RF_RX_PROCESSING_PKT) {
2328 if((num_rxbytes + bytes_read) > (payload_len + CC_APPENDIX_LEN)) {
2336 WARNING(
"RF: RX length mismatch %d %d %d!\n", num_rxbytes,
2345 burst_read(CC1200_RXFIFO,
2349 bytes_read += num_rxbytes;
2352 if(bytes_read == (payload_len + CC_APPENDIX_LEN)) {
2361 uint8_t crc_lqi = buf[bytes_read - 1];
2363 int8_t rssi = single_read(CC1200_RSSI1);
2364 uint8_t crc_lqi = single_read(CC1200_LQI_VAL);
2367 if(!(crc_lqi & (1 << 7))) {
2369 INFO(
"RF: CRC error!\n");
2370 }
else if(rx_pkt_len != 0) {
2372 WARNING(
"RF: Packet pending!\n");
2375 int ret = addr_check_auto_ack(buf, bytes_read);
2377 if((ret == ADDR_CHECK_OK) ||
2378 (ret == ADDR_CHECK_OK_ACK_SEND)) {
2382 buf[bytes_read++] = (uint8_t)rssi;
2383 buf[bytes_read++] = crc_lqi;
2385 rx_pkt_len = bytes_read;
2386 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.
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.
static int8_t set_channel(uint8_t channel)
Set the current operating channel.
#define PROCESS_CONTEXT_BEGIN(p)
Switch context to another process.
uint8_t seq
Sequence number.
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.
void process_start(struct process *p, process_data_t data)
Start a process.