observe fixes
Dependencies: nanoservice_client_1_12_X Nanostack_lib
Fork of mbedEndpointNetwork_6LowPAN by
driverRFPhy.c
00001 /* 00002 * driverRFPhy.c 00003 * 00004 * Created on: 14 July 2014 00005 * Author: mBed team 00006 */ 00007 #include "arm_hal_interrupt.h" 00008 #include "arm_hal_phy.h" 00009 #include "driverRFPhy.h" 00010 #include "driverAtmelRFInterface.h" 00011 #include <string.h> 00012 00013 #include <stdio.h> 00014 00015 #include "configuration.h" 00016 00017 /*RF receive buffer*/ 00018 static uint8_t rf_buffer[RF_BUFFER_SIZE]; 00019 /*RF ACK receive buffer*/ 00020 static uint8_t ack_rx_buf[5]; 00021 /*ACK wait duration changes depending on data rate*/ 00022 static uint16_t rf_ack_wait_duration = RF_ACK_WAIT_TIMEOUT; 00023 00024 // TUNABLES 00025 extern uint8_t rf_channel; 00026 00027 static uint8_t radio_tx_power = 0x07; 00028 static uint8_t rf_tuned = 1; 00029 static uint8_t radio_rpc_value = 0xef; 00030 static uint8_t rf_use_front_end = 0; 00031 static uint8_t rf_use_antenna_diversity = 0; 00032 static uint8_t rf_csd_port = 0; 00033 static uint8_t rf_csd_pin = 0; 00034 static uint8_t rf_cps_port = 0; 00035 static uint8_t rf_cps_pin = 0; 00036 static uint8_t tx_sequence = 0xff; 00037 static uint8_t need_ack = 0; 00038 static uint8_t rf_rx_mode = 0; 00039 static uint8_t rf_flags = 0; 00040 static uint8_t rf_rnd_rssi = 0; 00041 static int8_t rf_radio_driver_id = -1; 00042 static phy_device_driver_s device_driver; 00043 static uint8_t atmel_MAC[8]; 00044 static phy_device_channel_info_s channel_info; 00045 static uint8_t mac_tx_handle = 0; 00046 00047 /* 00048 * \brief Function sets given RF flag on. 00049 * 00050 * \param x Given RF flag 00051 * 00052 * \return none 00053 */ 00054 void rf_flags_set(uint8_t x) 00055 { 00056 rf_flags |= x; 00057 } 00058 00059 /* 00060 * \brief Function clears given RF flag on. 00061 * 00062 * \param x Given RF flag 00063 * 00064 * \return none 00065 */ 00066 void rf_flags_clear(uint8_t x) 00067 { 00068 rf_flags &= ~x; 00069 } 00070 00071 /* 00072 * \brief Function checks if given RF flag is on. 00073 * 00074 * \param x Given RF flag 00075 * 00076 * \return states of the given flags 00077 */ 00078 uint8_t rf_flags_check(uint8_t x) 00079 { 00080 return (rf_flags & x); 00081 } 00082 00083 /* 00084 * \brief Function clears all RF flags. 00085 * 00086 * \param none 00087 * 00088 * \return none 00089 */ 00090 void rf_flags_reset(void) 00091 { 00092 rf_flags = 0; 00093 } 00094 00095 /* 00096 * \brief Function sets CPS and CSD pins of the Front end. 00097 * 00098 * \param none 00099 * 00100 * \return none 00101 */ 00102 void rf_front_end_rx_lna(void) 00103 { 00104 /* not supported in this version */ 00105 } 00106 00107 /* 00108 * \brief Function clears CPS and CSD pins of the Front end. 00109 * 00110 * \param none 00111 * 00112 * \return none 00113 */ 00114 void rf_front_end_sleep(void) 00115 { 00116 /* not supported in this version */ 00117 } 00118 00119 /* 00120 * \brief Function initialises and registers the RF driver. 00121 * 00122 * \param none 00123 * 00124 * \return rf_radio_driver_id Driver ID given by NET library 00125 */ 00126 int8_t rf_device_register(void) 00127 { 00128 rf_init(); 00129 /*Set pointer to MAC address*/ 00130 device_driver.PHY_MAC = atmel_MAC; 00131 device_driver.driver_description = "ATMEL_MAC"; 00132 #if PHY_LINK_15_4_2_4GHZ_TYPE 00133 /*Number of channels in PHY*/ 00134 channel_info.channel_count = 16; 00135 /*Channel mask 26-11*/ 00136 channel_info.channel_mask = 0x07FFF800; 00137 /*Type of RF PHY is SubGHz*/ 00138 device_driver.link_type = PHY_LINK_15_4_2_4GHZ_TYPE; 00139 device_driver.link_channel_info = &channel_info; 00140 #else 00141 /*Number of channels in PHY*/ 00142 channel_info.channel_count = 11; 00143 /*Channel mask 0-10*/ 00144 channel_info.channel_mask = 0x000007ff; 00145 /*Type of RF PHY is SubGHz*/ 00146 device_driver.link_type = PHY_LINK_15_4_SUBGHZ_TYPE; 00147 device_driver.link_channel_info = &channel_info; 00148 #endif 00149 /*Maximum size of payload is 127*/ 00150 device_driver.phy_MTU = 127; 00151 /*No header in PHY*/ 00152 device_driver.phy_header_length = 0; 00153 /*No tail in PHY*/ 00154 device_driver.phy_tail_length = 0; 00155 /*Set address write function*/ 00156 device_driver.phy_xx_address_write = &rf_address_write; 00157 /*Set RF extension function*/ 00158 device_driver.phy_xx_extension = &rf_extension; 00159 /*Set RF state control function*/ 00160 device_driver.phy_xx_state_control = &rf_interface_state_control; 00161 /*Set transmit function*/ 00162 device_driver.phy_xx_tx = &rf_start_cca; 00163 printf("RF Device Registration..."); 00164 /*Register device driver*/ 00165 rf_radio_driver_id = arm_net_phy_register(&device_driver); 00166 printf("OK\r\n"); 00167 return rf_radio_driver_id; 00168 } 00169 00170 /* 00171 * \brief Function returns the generated 8-bit random value for seeding Pseudo-random generator. This value was generated by reading noise from RF channel in RF initialisation. 00172 * 00173 * \param none 00174 * 00175 * \return random RSSI value 00176 */ 00177 int8_t rf_read_random(void) 00178 { 00179 return rf_rnd_rssi; 00180 } 00181 00182 /* 00183 * \brief Function is a call back for ACK wait timeout. 00184 * 00185 * \param none 00186 * 00187 * \return none 00188 */ 00189 void rf_ack_wait_timer_interrupt(void) 00190 { 00191 arm_enter_critical(); 00192 /*Force PLL state*/ 00193 rf_if_change_trx_state(FORCE_PLL_ON); 00194 rf_poll_trx_state_change(PLL_ON); 00195 /*Start receiver in RX_AACK_ON state*/ 00196 rf_rx_mode = 0; 00197 rf_flags_clear(RFF_RX); 00198 rf_receive(); 00199 arm_exit_critical(); 00200 } 00201 00202 /* 00203 * \brief Function is a call back for calibration interval timer. 00204 * 00205 * \param none 00206 * 00207 * \return none 00208 */ 00209 void rf_calibration_timer_interrupt(void) 00210 { 00211 /*Calibrate RF*/ 00212 rf_calibration_cb(); 00213 /*Start new calibration timeout*/ 00214 rf_calibration_timer_start(RF_CALIBRATION_INTERVAL); 00215 } 00216 00217 /* 00218 * \brief Function initialises the RF timer for ACK wait and calibration. 00219 * 00220 * \param none 00221 * 00222 * \return none 00223 */ 00224 void rf_timer_init(void) 00225 { 00226 rf_if_timer_init(); 00227 } 00228 00229 /* 00230 * \brief Function starts the ACK wait timeout. 00231 * 00232 * \param slots Given slots, resolution 50us 00233 * 00234 * \return none 00235 */ 00236 void rf_ack_wait_timer_start(uint16_t slots) 00237 { 00238 rf_if_ack_wait_timer_start(slots); 00239 } 00240 00241 /* 00242 * \brief Function starts the calibration interval. 00243 * 00244 * \param slots Given slots, resolution 50us 00245 * 00246 * \return none 00247 */ 00248 void rf_calibration_timer_start(uint32_t slots) 00249 { 00250 rf_if_calibration_timer_start(slots); 00251 } 00252 00253 /* 00254 * \brief Function stops the ACK wait timeout. 00255 * 00256 * \param none 00257 * 00258 * \return none 00259 */ 00260 void rf_ack_wait_timer_stop(void) 00261 { 00262 rf_if_ack_wait_timer_stop(); 00263 } 00264 00265 /* 00266 * \brief Function reads the MAC address array. 00267 * 00268 * \param ptr Pointer to read array 00269 * 00270 * \return none 00271 */ 00272 void rf_read_mac_address(uint8_t *ptr) 00273 { 00274 memcpy(ptr, atmel_MAC, 8); 00275 } 00276 00277 /* 00278 * \brief Function sets the MAC address array. 00279 * 00280 * \param ptr Pointer to given MAC address array 00281 * 00282 * \return none 00283 */ 00284 void rf_set_mac_address(const uint8_t *ptr) 00285 { 00286 memcpy(atmel_MAC,ptr,8); 00287 } 00288 00289 /* 00290 * \brief Function writes various RF settings in startup. 00291 * 00292 * \param none 00293 * 00294 * \return none 00295 */ 00296 void rf_write_settings(void) 00297 { 00298 arm_enter_critical(); 00299 00300 //printf("RF Write Settings: 1\r\n"); 00301 rf_if_write_rf_settings(); 00302 00303 //printf("RF Write Settings: 2\r\n"); 00304 /*Set output power*/ 00305 rf_if_write_set_tx_power_register(radio_tx_power); 00306 00307 //printf("RF Write Settings: 3\r\n"); 00308 /*Set RPC register*/ 00309 rf_if_write_set_trx_rpc_register(radio_rpc_value); 00310 00311 //printf("RF Write Settings: 4\r\n"); 00312 /*Initialise Front end*/ 00313 if(rf_use_front_end) 00314 { 00315 printf("RF Front End used\r\n"); 00316 rf_if_enable_pa_ext(); 00317 /* not supported in this version */ 00318 } 00319 00320 //printf("RF Write Settings: 5\r\n"); 00321 /*Initialise Antenna Diversity*/ 00322 if(rf_use_antenna_diversity) { 00323 printf("RF Antenna diversity\r\n"); 00324 rf_if_write_antenna_diversity_settings(); 00325 } 00326 00327 printf("RF Write Settings: 7\r\n"); 00328 arm_exit_critical(); 00329 printf("RF Write Settings End\r\n"); 00330 } 00331 00332 /* 00333 * \brief Function writes 16-bit address in RF address filter. 00334 * 00335 * \param short_address Given short address 00336 * 00337 * \return none 00338 */ 00339 void rf_set_short_adr(uint8_t * short_address) 00340 { 00341 uint8_t rf_off_flag = 0; 00342 arm_enter_critical(); 00343 /*Wake up RF if sleeping*/ 00344 if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F) 00345 { 00346 rf_if_disable_slptr(); 00347 rf_off_flag = 1; 00348 rf_poll_trx_state_change(TRX_OFF); 00349 } 00350 /*Write address filter registers*/ 00351 rf_if_write_short_addr_registers(short_address); 00352 /*RF back to sleep*/ 00353 if(rf_off_flag) 00354 rf_if_enable_slptr(); 00355 arm_exit_critical(); 00356 } 00357 00358 /* 00359 * \brief Function writes PAN Id in RF PAN Id filter. 00360 * 00361 * \param pan_id Given PAN Id 00362 * 00363 * \return none 00364 */ 00365 void rf_set_pan_id(uint8_t *pan_id) 00366 { 00367 uint8_t rf_off_flag = 0; 00368 00369 arm_enter_critical(); 00370 /*Wake up RF if sleeping*/ 00371 if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F) 00372 { 00373 rf_if_disable_slptr(); 00374 rf_off_flag = 1; 00375 rf_poll_trx_state_change(TRX_OFF); 00376 } 00377 /*Write address filter registers*/ 00378 rf_if_write_pan_id_registers(pan_id); 00379 /*RF back to sleep*/ 00380 if(rf_off_flag) 00381 rf_if_enable_slptr(); 00382 arm_exit_critical(); 00383 } 00384 00385 /* 00386 * \brief Function writes 64-bit address in RF address filter. 00387 * 00388 * \param address Given 64-bit address 00389 * 00390 * \return none 00391 */ 00392 void rf_set_address(uint8_t *address) 00393 { 00394 uint8_t rf_off_flag = 0; 00395 00396 arm_enter_critical(); 00397 /*Wake up RF if sleeping*/ 00398 if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F) 00399 { 00400 rf_if_disable_slptr(); 00401 rf_off_flag = 1; 00402 rf_poll_trx_state_change(TRX_OFF); 00403 } 00404 /*Write address filter registers*/ 00405 rf_if_write_ieee_addr_registers(address); 00406 /*RF back to sleep*/ 00407 if(rf_off_flag) 00408 rf_if_enable_slptr(); 00409 00410 arm_exit_critical(); 00411 } 00412 00413 /* 00414 * \brief Function sets the RF channel. 00415 * 00416 * \param ch New channel 00417 * 00418 * \return none 00419 */ 00420 void rf_channel_set(uint8_t ch) 00421 { 00422 arm_enter_critical(); 00423 rf_channel = ch; 00424 if(ch < 0x1f) 00425 rf_if_set_channel_register(ch); 00426 arm_exit_critical(); 00427 } 00428 00429 00430 /* 00431 * \brief Function initialises the radio driver and resets the radio. 00432 * 00433 * \param none 00434 * 00435 * \return none 00436 */ 00437 void rf_init(void) 00438 { 00439 printf("RF Init Start\r\n"); 00440 /*Initialise timers*/ 00441 rf_timer_init(); //TODO 00442 rf_channel = RF_DEFAULT_CHANNEL; 00443 printf("RF Reset\r\n"); 00444 /*Reset RF module*/ 00445 rf_if_reset_radio(); 00446 printf("RF Write Settings\r\n"); 00447 /*Write RF settings*/ 00448 rf_write_settings(); 00449 printf("RF Init PHY Mode\r\n"); 00450 /*Initialise PHY mode*/ 00451 rf_init_phy_mode(); 00452 /*Clear RF flags*/ 00453 rf_flags_reset(); 00454 /*Set RF in TRX OFF state*/ 00455 rf_if_change_trx_state(TRX_OFF); 00456 /*Set RF in PLL_ON state*/ 00457 rf_if_change_trx_state(PLL_ON); 00458 /*Start receiver*/ 00459 rf_receive(); 00460 /*Read random variable. This will be used when seeding pseudo-random generator*/ 00461 rf_rnd_rssi = rf_if_read_rnd(); 00462 /*Start RF calibration timer*/ 00463 rf_calibration_timer_start(RF_CALIBRATION_INTERVAL); //ACA! 00464 printf("RF Init End\r\n"); 00465 } 00466 00467 /** 00468 * \brief Function gets called when MAC is setting radio off. 00469 * 00470 * \param none 00471 * 00472 * \return none 00473 */ 00474 void rf_off(void) 00475 { 00476 if(rf_flags_check(RFF_ON)) 00477 { 00478 rf_cca_abort(); 00479 uint16_t while_counter = 0; 00480 /*Wait while receiving*/ 00481 while(rf_if_read_trx_state() == BUSY_RX_AACK || rf_if_read_trx_state() == BUSY_RX) 00482 { 00483 while_counter++; 00484 if(while_counter == 0xffff) 00485 break; 00486 } 00487 /*RF state change: RX_AACK_ON->PLL_ON->TRX_OFF->SLEEP*/ 00488 if(rf_if_read_trx_state() == RX_AACK_ON) 00489 { 00490 rf_if_change_trx_state(PLL_ON); 00491 } 00492 rf_if_change_trx_state(TRX_OFF); 00493 rf_if_enable_slptr(); 00494 rf_flags_clear(~RFF_ON); 00495 /*Front end in sleep*/ 00496 if(rf_use_front_end) 00497 { 00498 rf_if_disable_pa_ext(); 00499 rf_front_end_sleep(); 00500 } 00501 /*Disable Antenna Diversity*/ 00502 if(rf_use_antenna_diversity) 00503 rf_if_disable_ant_div(); 00504 } 00505 } 00506 00507 /* 00508 * \brief Function polls the RF state until it has changed to desired state. 00509 * 00510 * \param trx_state RF state 00511 * 00512 * \return none 00513 */ 00514 void rf_poll_trx_state_change(rf_trx_states_t trx_state) 00515 { 00516 uint16_t while_counter = 0; 00517 arm_enter_critical(); 00518 00519 if(trx_state != RF_TX_START) 00520 { 00521 if(trx_state == FORCE_PLL_ON) 00522 trx_state = PLL_ON; 00523 else if(trx_state == FORCE_TRX_OFF) 00524 trx_state = TRX_OFF; 00525 00526 while(rf_if_read_trx_state() != trx_state) 00527 { 00528 while_counter++; 00529 if(while_counter == 0x1ff) 00530 break; 00531 } 00532 } 00533 arm_exit_critical(); 00534 } 00535 00536 /* 00537 * \brief Function starts the CCA process before starting data transmission and copies the data to RF TX FIFO. 00538 * 00539 * \param data_ptr Pointer to TX data 00540 * \param data_length Length of the TX data 00541 * \param tx_handle Handle to transmission 00542 * \return 0 Success 00543 * \return -1 Busy 00544 */ 00545 int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle) 00546 { 00547 /*Check if transmitter is busy*/ 00548 if((rf_if_read_trx_state() == BUSY_RX_AACK) || (rf_if_read_trx_state() == BUSY_RX)) 00549 { 00550 /*Return busy*/ 00551 return -1; 00552 } 00553 else 00554 { 00555 arm_enter_critical(); 00556 /*Check if transmitted data needs to be acked*/ 00557 if(*data_ptr & 0x20) 00558 need_ack = 1; 00559 else 00560 need_ack = 0; 00561 /*Store the sequence number for ACK handling*/ 00562 tx_sequence = *(data_ptr + 2); 00563 /*Set radio in RX state to read channel*/ 00564 rf_receive(); 00565 /*Write TX FIFO*/ 00566 rf_if_write_frame_buffer(data_ptr, (uint8_t)data_length); 00567 rf_flags_set(RFF_CCA); 00568 /*Start CCA process*/ 00569 rf_if_enable_cca_ed_done_interrupt(); 00570 rf_if_start_cca_process(); 00571 /*Store TX handle*/ 00572 mac_tx_handle = tx_handle; 00573 arm_exit_critical(); 00574 } 00575 00576 /*Return success*/ 00577 return 0; 00578 } 00579 00580 /* 00581 * \brief Function aborts CCA process. 00582 * 00583 * \param none 00584 * 00585 * \return none 00586 */ 00587 void rf_cca_abort(void) 00588 { 00589 /*Clear RFF_CCA RF flag*/ 00590 rf_flags_clear(RFF_CCA); 00591 } 00592 00593 00594 00595 /* 00596 * \brief Function starts the transmission of the frame. 00597 * 00598 * \param none 00599 * 00600 * \return none 00601 */ 00602 void rf_start_tx(void) 00603 { 00604 /*Only start transmitting from RX state*/ 00605 uint8_t trx_state = rf_if_read_trx_state(); 00606 if((trx_state != RX_AACK_ON) && (trx_state != RX_ON)) 00607 { 00608 arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, PHY_LINK_CCA_FAIL, 1, 1); 00609 } 00610 else 00611 { 00612 /*RF state change: ->PLL_ON->RF_TX_START*/ 00613 rf_if_change_trx_state(FORCE_PLL_ON); 00614 rf_flags_clear(RFF_RX); 00615 rf_if_enable_tx_end_interrupt(); 00616 rf_flags_set(RFF_TX); 00617 rf_if_change_trx_state(RF_TX_START); 00618 } 00619 } 00620 00621 /* 00622 * \brief Function sets the RF in RX state. 00623 * 00624 * \param none 00625 * 00626 * \return none 00627 */ 00628 void rf_receive(void) 00629 { 00630 uint16_t while_counter = 0; 00631 if(rf_flags_check(RFF_ON) == 0) 00632 { 00633 rf_on(); 00634 } 00635 /*If not yet in RX state set it*/ 00636 if(rf_flags_check(RFF_RX) == 0) 00637 { 00638 arm_enter_critical(); 00639 /*Wait while receiving data*/ 00640 while((rf_if_read_trx_state() == BUSY_RX) || (rf_if_read_trx_state() == BUSY_RX_AACK)) 00641 { 00642 while_counter++; 00643 if(while_counter == 0xffff) 00644 { 00645 break; 00646 } 00647 } 00648 /*Wake up from sleep state*/ 00649 if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1f) 00650 { 00651 rf_if_disable_slptr(); 00652 rf_poll_trx_state_change(TRX_OFF); 00653 } 00654 00655 rf_if_change_trx_state(PLL_ON); 00656 /*ACK is always received in RX_ON state to bypass address filters*/ 00657 if(rf_rx_mode) 00658 { 00659 rf_rx_mode = 0; 00660 rf_if_change_trx_state(RX_ON); 00661 } 00662 else 00663 { 00664 rf_if_change_trx_state(RX_AACK_ON); 00665 /*If calibration timer was unable to calibrate the RF, run calibration now*/ 00666 if(!rf_tuned) 00667 { 00668 /*Start calibration. This can be done in states TRX_OFF, PLL_ON or in any receive state*/ 00669 rf_if_calibration(); 00670 /*RF is tuned now*/ 00671 rf_tuned = 1; 00672 } 00673 } 00674 rf_channel_set(rf_channel); 00675 rf_flags_set(RFF_RX); 00676 rf_if_enable_rx_end_interrupt(); 00677 /*Enable LNA if Front end used*/ 00678 if(rf_use_front_end) 00679 rf_front_end_rx_lna(); 00680 arm_exit_critical(); 00681 } 00682 /*Stop the running CCA process*/ 00683 if(rf_flags_check(RFF_CCA)) 00684 rf_cca_abort(); 00685 } 00686 00687 /* 00688 * \brief Function calibrates the radio. 00689 * 00690 * \param none 00691 * 00692 * \return none 00693 */ 00694 void rf_calibration_cb(void) 00695 { 00696 /*clear tuned flag to start tuning in rf_receive*/ 00697 rf_tuned = 0; 00698 /*If RF is in default receive state, start calibration*/ 00699 if(rf_if_read_trx_state() == RX_AACK_ON) 00700 { 00701 arm_enter_critical(); 00702 /*Set RF in PLL_ON state*/ 00703 rf_if_change_trx_state(PLL_ON); 00704 /*Set RF in TRX_OFF state to start PLL tuning*/ 00705 rf_if_change_trx_state(TRX_OFF); 00706 /*Set RF in RX_ON state to calibrate*/ 00707 rf_if_change_trx_state(RX_ON); 00708 /*Calibrate FTN*/ 00709 rf_if_calibration(); 00710 /*RF is tuned now*/ 00711 rf_tuned = 1; 00712 /*Back to default receive state*/ 00713 rf_flags_clear(RFF_RX); 00714 rf_receive(); 00715 arm_exit_critical(); 00716 } 00717 } 00718 00719 /* 00720 * \brief Function sets RF_ON flag when radio is powered. 00721 * 00722 * \param none 00723 * 00724 * \return none 00725 */ 00726 void rf_on(void) 00727 { 00728 /*Set RFF_ON flag*/ 00729 if(rf_flags_check(RFF_ON) == 0) 00730 { 00731 rf_flags_set(RFF_ON); 00732 /*Wake up Front end*/ 00733 if(rf_use_front_end) 00734 { 00735 /*Set PA_EXT_EN to enable controlling of external front end*/ 00736 rf_if_enable_pa_ext(); 00737 rf_front_end_rx_lna(); 00738 } 00739 /*Enable Antenna diversity*/ 00740 if(rf_use_antenna_diversity) 00741 /*Set ANT_EXT_SW_EN to enable controlling of antenna diversity*/ 00742 rf_if_enable_ant_div(); 00743 } 00744 } 00745 00746 /* 00747 * \brief Function handles the received ACK frame. 00748 * 00749 * \param seq_number Sequence number of received ACK 00750 * \param data_pending Pending bit state in received ACK 00751 * 00752 * \return none 00753 */ 00754 void rf_handle_ack(uint8_t seq_number, uint8_t data_pending) 00755 { 00756 phy_link_tx_status_e phy_status; 00757 arm_enter_critical(); 00758 /*Received ACK sequence must be equal with transmitted packet sequence*/ 00759 if(tx_sequence == seq_number) 00760 { 00761 rf_ack_wait_timer_stop(); 00762 /*When data pending bit in ACK frame is set, inform NET library*/ 00763 if(data_pending) 00764 phy_status = PHY_LINK_TX_DONE_PENDING; 00765 else 00766 phy_status = PHY_LINK_TX_DONE; 00767 /*Call PHY TX Done API*/ 00768 arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle,phy_status, 1, 1); 00769 } 00770 arm_exit_critical(); 00771 } 00772 00773 /* 00774 * \brief Function is a call back for RX end interrupt. 00775 * 00776 * \param none 00777 * 00778 * \return none 00779 */ 00780 void rf_handle_rx_end(void) 00781 { 00782 uint8_t rf_lqi; 00783 00784 /*Frame received interrupt*/ 00785 if(rf_flags_check(RFF_RX)) 00786 { 00787 /*Check CRC_valid bit*/ 00788 if(rf_if_check_crc()) 00789 { 00790 uint8_t *rf_rx_ptr; 00791 uint8_t receiving_ack = 0; 00792 /*Read length*/ 00793 uint8_t len = rf_if_read_received_frame_length(); 00794 /*Not ACK frame*/ 00795 if(len > 5) 00796 { 00797 rf_rx_ptr = rf_buffer; 00798 } 00799 /*ACK received*/ 00800 else 00801 { 00802 /*Read ACK in static ACK buffer*/ 00803 receiving_ack = 1; 00804 rf_rx_ptr = ack_rx_buf; 00805 } 00806 /*Check the length is valid*/ 00807 if(len > 1 && len < RF_BUFFER_SIZE) 00808 { 00809 /*Read received packet*/ 00810 rf_if_read_packet(rf_rx_ptr, len); 00811 /*Get LQI*/ 00812 rf_lqi = rf_if_read_lqi(); 00813 /*Handle received ACK*/ 00814 if(receiving_ack && ((ack_rx_buf[0] & 0x07) == 0x02)) 00815 { 00816 uint8_t pending = 0; 00817 /*Check if data is pending*/ 00818 if ((ack_rx_buf[0] & 0x10)) 00819 { 00820 pending=1; 00821 } 00822 /*Send sequence number in ACK handler*/ 00823 rf_handle_ack(ack_rx_buf[2], pending); 00824 } 00825 /*Handle received data*/ 00826 else if(rf_if_read_trx_state() != RX_ON && rf_if_read_trx_state() != BUSY_RX) 00827 { 00828 arm_net_phy_rx(rf_buffer,len - 2, rf_lqi, rf_radio_driver_id); 00829 } 00830 } 00831 } 00832 } 00833 /*Start receiver*/ 00834 rf_flags_clear(RFF_RX); 00835 rf_receive(); 00836 } 00837 00838 /* 00839 * \brief Function is called when MAC is shutting down the radio. 00840 * 00841 * \param none 00842 * 00843 * \return none 00844 */ 00845 void rf_shutdown(void) 00846 { 00847 /*Call RF OFF*/ 00848 rf_off(); 00849 /*Clear RF flags*/ 00850 rf_flags_reset(); 00851 } 00852 00853 /* 00854 * \brief Function is a call back for TX end interrupt. 00855 * 00856 * \param none 00857 * 00858 * \return none 00859 */ 00860 void rf_handle_tx_end(void) 00861 { 00862 phy_link_tx_status_e phy_status = PHY_LINK_TX_SUCCESS; 00863 00864 rf_rx_mode = 0; 00865 /*If ACK is needed for this transmission*/ 00866 if(need_ack && rf_flags_check(RFF_TX)) 00867 { 00868 rf_ack_wait_timer_start(rf_ack_wait_duration); 00869 rf_rx_mode = 1; 00870 } 00871 rf_flags_clear(RFF_RX); 00872 /*Start receiver*/ 00873 rf_receive(); 00874 00875 /*Call PHY TX Done API*/ 00876 arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, phy_status, 1, 1); 00877 } 00878 00879 /* 00880 * \brief Function is a call back for CCA ED done interrupt. 00881 * 00882 * \param none 00883 * 00884 * \return none 00885 */ 00886 void rf_handle_cca_ed_done(void) 00887 { 00888 rf_flags_clear(RFF_CCA); 00889 /*Check the result of CCA process*/ 00890 if(rf_if_check_cca()) 00891 { 00892 rf_start_tx(); 00893 } 00894 else 00895 { 00896 /*Send CCA fail notification*/ 00897 arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, PHY_LINK_CCA_FAIL, 1, 1); 00898 } 00899 } 00900 00901 /* 00902 * \brief Function sets the TX power variable. 00903 * 00904 * \param power TX power setting 00905 * 00906 * \return 0 Success 00907 * \return -1 Fail 00908 */ 00909 int8_t rf_tx_power_set(uint8_t power) 00910 { 00911 int8_t ret_val = -1; 00912 if(power < 16) 00913 { 00914 radio_tx_power = power; 00915 ret_val = 0; 00916 } 00917 return ret_val; 00918 } 00919 00920 /* 00921 * \brief Function returns the TX power variable. 00922 * 00923 * \param none 00924 * 00925 * \return radio_tx_power TX power variable 00926 */ 00927 uint8_t rf_tx_power_get(void) 00928 { 00929 return radio_tx_power; 00930 } 00931 00932 /* 00933 * \brief Function sets the RF RPC variable. 00934 * 00935 * \param rpc_value RPC setting 00936 * 00937 * \return 0 Success 00938 */ 00939 int8_t rf_rpc_set(uint8_t rpc_value) 00940 { 00941 int8_t ret_val = -1; 00942 radio_rpc_value = rpc_value; 00943 ret_val = 0; 00944 return ret_val; 00945 } 00946 00947 /* 00948 * \brief Function enables the usage of Front end. 00949 * 00950 * \param none 00951 * 00952 * \return 0 Success 00953 */ 00954 int8_t rf_enable_pa(void) 00955 { 00956 int8_t ret_val = 0; 00957 rf_use_front_end = 1; 00958 return ret_val; 00959 } 00960 00961 /* 00962 * \brief Function enables the usage of Antenna diversity. 00963 * 00964 * \param none 00965 * 00966 * \return 0 Success 00967 */ 00968 int8_t rf_enable_antenna_diversity(void) 00969 { 00970 int8_t ret_val = 0; 00971 rf_use_antenna_diversity = 1; 00972 return ret_val; 00973 } 00974 00975 /* 00976 * \brief Function defines the CSD pin of the Front end. 00977 * 00978 * \param port CSD port 00979 * \param port CSD pin 00980 * 00981 * \return 0 Success 00982 */ 00983 int8_t rf_set_csd_pin(uint8_t port, uint8_t pin) 00984 { 00985 int8_t ret_val = -1; 00986 00987 rf_csd_port = port; 00988 rf_csd_pin = pin; 00989 ret_val = 0; 00990 00991 return ret_val; 00992 } 00993 00994 /* 00995 * \brief Function defines the CPS pin of the Front end. 00996 * 00997 * \param port CPS port 00998 * \param port CPS pin 00999 * 01000 * \return 0 Success 01001 */ 01002 int8_t rf_set_cps_pin(uint8_t port, uint8_t pin) 01003 { 01004 int8_t ret_val = -1; 01005 01006 rf_cps_port = port; 01007 rf_cps_pin = pin; 01008 ret_val = 0; 01009 01010 return ret_val; 01011 } 01012 01013 /* 01014 * \brief Function gives the control of RF states to MAC. 01015 * 01016 * \param new_state RF state 01017 * \param rf_channel RF channel 01018 * 01019 * \return 0 Success 01020 */ 01021 static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel) 01022 { 01023 int8_t ret_val = 0; 01024 switch (new_state) 01025 { 01026 /*Reset PHY driver and set to idle*/ 01027 case PHY_INTERFACE_RESET: 01028 break; 01029 /*Disable PHY Interface driver*/ 01030 case PHY_INTERFACE_DOWN: 01031 rf_shutdown(); 01032 break; 01033 /*Enable PHY Interface driver*/ 01034 case PHY_INTERFACE_UP: 01035 rf_channel_set(rf_channel); 01036 rf_receive(); 01037 break; 01038 /*Enable wireless interface ED scan mode*/ 01039 case PHY_INTERFACE_RX_ENERGY_STATE: 01040 break; 01041 } 01042 return ret_val; 01043 } 01044 01045 /* 01046 * \brief Function controls the ACK pending, channel setting and energy detection. 01047 * 01048 * \param extension_type Type of control 01049 * \param data_ptr Data from NET library 01050 * 01051 * \return 0 Success 01052 */ 01053 static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_ptr) 01054 { 01055 switch (extension_type) 01056 { 01057 /*Control MAC pending bit for Indirect data transmission*/ 01058 case PHY_EXTENSION_CTRL_PENDING_BIT: 01059 if(*data_ptr) 01060 { 01061 rf_if_ack_pending_ctrl(1); 01062 } 01063 else 01064 { 01065 rf_if_ack_pending_ctrl(0); 01066 } 01067 break; 01068 /*Return frame pending status*/ 01069 case PHY_EXTENSION_READ_LAST_ACK_PENDING_STATUS: 01070 *data_ptr = rf_if_last_acked_pending(); 01071 break; 01072 /*Set channel*/ 01073 case PHY_EXTENSION_SET_CHANNEL: 01074 break; 01075 /*Read energy on the channel*/ 01076 case PHY_EXTENSION_READ_CHANNEL_ENERGY: 01077 break; 01078 /*Read status of the link*/ 01079 case PHY_EXTENSION_READ_LINK_STATUS: 01080 break; 01081 } 01082 return 0; 01083 } 01084 01085 /* 01086 * \brief Function sets the addresses to RF address filters. 01087 * 01088 * \param address_type Type of address 01089 * \param address_ptr Pointer to given address 01090 * 01091 * \return 0 Success 01092 */ 01093 static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address_ptr) 01094 { 01095 int8_t ret_val = 0; 01096 switch (address_type) 01097 { 01098 /*Set 48-bit address*/ 01099 case PHY_MAC_48BIT: 01100 break; 01101 /*Set 64-bit address*/ 01102 case PHY_MAC_64BIT: 01103 rf_set_address(address_ptr); 01104 break; 01105 /*Set 16-bit address*/ 01106 case PHY_MAC_16BIT: 01107 rf_set_short_adr(address_ptr); 01108 break; 01109 /*Set PAN Id*/ 01110 case PHY_MAC_PANID: 01111 rf_set_pan_id(address_ptr); 01112 break; 01113 } 01114 return ret_val; 01115 } 01116 01117 /* 01118 * \brief Function initialises the ACK wait time and returns the used PHY mode. 01119 * 01120 * \param none 01121 * 01122 * \return tmp Used PHY mode 01123 */ 01124 uint8_t rf_init_phy_mode(void) 01125 { 01126 uint8_t tmp; 01127 /*Read used PHY Mode*/ 01128 tmp = rf_if_read_register(TRX_CTRL_2); 01129 /*Set ACK wait time for used data rate*/ 01130 if((tmp & 0x1f) == 0x00) 01131 { 01132 rf_ack_wait_duration = 938; 01133 tmp = BPSK_20; 01134 } 01135 else if((tmp & 0x1f) == 0x04) 01136 { 01137 rf_ack_wait_duration = 469; 01138 tmp = BPSK_40; 01139 } 01140 else if((tmp & 0x1f) == 0x14) 01141 { 01142 rf_ack_wait_duration = 469; 01143 tmp = BPSK_40_ALT; 01144 } 01145 else if((tmp & 0x1f) == 0x08) 01146 { 01147 rf_ack_wait_duration = 100; 01148 tmp = OQPSK_SIN_RC_100; 01149 } 01150 else if((tmp & 0x1f) == 0x09) 01151 { 01152 rf_ack_wait_duration = 50; 01153 tmp = OQPSK_SIN_RC_200; 01154 } 01155 else if((tmp & 0x1f) == 0x18) 01156 { 01157 rf_ack_wait_duration = 100; 01158 tmp = OQPSK_RC_100; 01159 } 01160 else if((tmp & 0x1f) == 0x19) 01161 { 01162 rf_ack_wait_duration = 50; 01163 tmp = OQPSK_RC_200; 01164 } 01165 else if((tmp & 0x1f) == 0x0c) 01166 { 01167 rf_ack_wait_duration = 50; 01168 tmp = OQPSK_SIN_250; 01169 } 01170 else if((tmp & 0x1f) == 0x0d) 01171 { 01172 rf_ack_wait_duration = 25; 01173 tmp = OQPSK_SIN_500; 01174 } 01175 else if((tmp & 0x1f) == 0x0f) 01176 { 01177 rf_ack_wait_duration = 25; 01178 tmp = OQPSK_SIN_500_ALT; 01179 } 01180 else if((tmp & 0x1f) == 0x1c) 01181 { 01182 rf_ack_wait_duration = 50; 01183 tmp = OQPSK_RC_250; 01184 } 01185 else if((tmp & 0x1f) == 0x1d) 01186 { 01187 rf_ack_wait_duration = 25; 01188 tmp = OQPSK_RC_500; 01189 } 01190 else if((tmp & 0x1f) == 0x1f) 01191 { 01192 rf_ack_wait_duration = 25; 01193 tmp = OQPSK_RC_500_ALT; 01194 } 01195 else if((tmp & 0x3f) == 0x2A) 01196 { 01197 rf_ack_wait_duration = 25; 01198 tmp = OQPSK_SIN_RC_400_SCR_ON; 01199 } 01200 else if((tmp & 0x3f) == 0x0A) 01201 { 01202 rf_ack_wait_duration = 25; 01203 tmp = OQPSK_SIN_RC_400_SCR_OFF; 01204 } 01205 else if((tmp & 0x3f) == 0x3A) 01206 { 01207 rf_ack_wait_duration = 25; 01208 tmp = OQPSK_RC_400_SCR_ON; 01209 } 01210 else if((tmp & 0x3f) == 0x1A) 01211 { 01212 rf_ack_wait_duration = 25; 01213 tmp = OQPSK_RC_400_SCR_OFF; 01214 } 01215 else if((tmp & 0x3f) == 0x2E) 01216 { 01217 rf_ack_wait_duration = 13; 01218 tmp = OQPSK_SIN_1000_SCR_ON; 01219 } 01220 else if((tmp & 0x3f) == 0x0E) 01221 { 01222 rf_ack_wait_duration = 13; 01223 tmp = OQPSK_SIN_1000_SCR_OFF; 01224 } 01225 else if((tmp & 0x3f) == 0x3E) 01226 { 01227 rf_ack_wait_duration = 13; 01228 tmp = OQPSK_RC_1000_SCR_ON; 01229 } 01230 else if((tmp & 0x3f) == 0x1E) 01231 { 01232 rf_ack_wait_duration = 13; 01233 tmp = OQPSK_RC_1000_SCR_OFF; 01234 } 01235 return tmp; 01236 } 01237
Generated on Fri Jul 15 2022 08:02:55 by 1.7.2