// Configures RF parameters before Enhanced Shockburst can be used. void configureRF() { packet_received = false; send_success = false; // Enable the radio clock RFCKEN = 1; // Set payload width to 32 bytes hal_nrf_set_rx_payload_width((int)HAL_NRF_PIPE0, PAYLOAD_SIZE); // Set auto-retries to 5 with 500 us intervals hal_nrf_set_auto_retr(5, 500); // Set pipe address hal_nrf_set_address(HAL_NRF_PIPE0, default_pipe_address); hal_nrf_set_address(HAL_NRF_TX, default_pipe_address); // Set initial channel hal_nrf_set_rf_channel(default_channels[1]); // Configure radio as primary receiver (PTX) hal_nrf_set_operation_mode(HAL_NRF_PRX); // Wait for the xtal to power up while (hal_clk_get_16m_source() != HAL_CLK_XOSC16M) ; // Power up radio hal_nrf_set_power_mode(HAL_NRF_PWR_UP); // Enable receiver CE_HIGH(); return; }
void radio_sb_init( hal_nrf_operation_mode_t operational_mode ) { if( !bus_initialized ) radio_bus_init(); switch( operational_mode ) { case HAL_NRF_PRX: radio_mode = DEVICE_PRX_SB; break; case HAL_NRF_PTX: radio_mode = DEVICE_PTX_SB; break; } hal_nrf_close_pipe(HAL_NRF_ALL); // First close all radio pipes // Pipe 0 and 1 open by default hal_nrf_open_pipe(HAL_NRF_PIPE0, false); // Open pipe0, without/autoack hal_nrf_set_crc_mode(HAL_NRF_CRC_16BIT); // Operates in 16bits CRC mode hal_nrf_set_auto_retr(0, RF_RETRANS_DELAY); // Disables auto retransmit hal_nrf_set_address_width(HAL_NRF_AW_5BYTES); // 5 bytes address width hal_nrf_set_address(HAL_NRF_TX, address); // Set device's addresses hal_nrf_set_address(HAL_NRF_PIPE0, address); // Sets recieving address on // pipe0 if(operational_mode == HAL_NRF_PTX) // Mode depentant settings { hal_nrf_set_operation_mode(HAL_NRF_PTX); // Enter TX mode } else { hal_nrf_set_operation_mode(HAL_NRF_PRX); // Enter RX mode hal_nrf_set_rx_pload_width((uint8_t)HAL_NRF_PIPE0, RF_PAYLOAD_LENGTH); // Pipe0 expect // PAYLOAD_LENGTH byte payload // PAYLOAD_LENGTH in radio.h } hal_nrf_set_rf_channel(RF_CHANNEL); // Operating on static channel // Defined in radio.h. // Frequenzy = // 2400 + RF_CHANNEL hal_nrf_set_power_mode(HAL_NRF_PWR_UP); // Power up device //hal_nrf_set_datarate(HAL_NRF_1MBPS); // Uncomment this line for // compatibility with nRF2401 // and nRF24E1 radio_wait(); radio_set_status (RF_IDLE); // Radio now ready }
void radio_esb_init( hal_nrf_operation_mode_t operational_mode ) { if( !bus_initialized ) radio_bus_init(); switch( operational_mode ) { case HAL_NRF_PRX: radio_mode = DEVICE_PRX_ESB; break; case HAL_NRF_PTX: radio_mode = DEVICE_PTX_ESB; break; } hal_nrf_close_pipe( HAL_NRF_ALL ); // First close all radio pipes // Pipe 0 and 1 open by default hal_nrf_open_pipe( HAL_NRF_PIPE0, true ); // Then open pipe0, w/autoack // Changed from sb/radio_sb.c hal_nrf_set_crc_mode( HAL_NRF_CRC_16BIT ); // Operates in 16bits CRC mode hal_nrf_set_auto_retr( RF_RETRANSMITS, RF_RETRANS_DELAY ); // Enables auto retransmit. // 3 retrans with 250ms delay // Changed from sb/radio_sb.c hal_nrf_set_address_width( HAL_NRF_AW_5BYTES ); // 5 bytes address width hal_nrf_set_address( HAL_NRF_TX, address ); // Set device's addresses hal_nrf_set_address( HAL_NRF_PIPE0, address ); // Sets recieving address on // pipe0 if( operational_mode == HAL_NRF_PTX ) // Mode depentant settings { hal_nrf_set_operation_mode( HAL_NRF_PTX ); // Enter TX mode } else { hal_nrf_set_operation_mode( HAL_NRF_PRX ); // Enter RX mode hal_nrf_set_rx_pload_width( (uint8_t)HAL_NRF_PIPE0, RF_PAYLOAD_LENGTH ); // Pipe0 expect // PAYLOAD_LENGTH byte payload // PAYLOAD_LENGTH in radio.h } hal_nrf_set_rf_channel( RF_CHANNEL ); // Operating on static channel // Defined in radio.h. // Frequenzy = // 2400 + RF_CHANNEL hal_nrf_set_power_mode( HAL_NRF_PWR_UP ); // Power up device radio_wait(); radio_set_status( RF_IDLE ); // Radio now ready }
/** Send the RF packet to designated destination. * Use this function to send RF packet. * * @param *in_dst_addr The destination address. * @param *in_tx_pload The pointer point to the packet to be sent. * @param in_length The packet length. */ void epl_rf_en_send_dst(unsigned char *in_dst_addr, unsigned char *in_tx_pload, unsigned char in_pload_length) { hal_nrf_set_address(HAL_NRF_TX, in_dst_addr); // Address for PTX (The address of destination.) epl_rf_en_enter_tx_mode(); hal_nrf_write_tx_payload(in_tx_pload, in_pload_length); CE_PULSE(); }
void radio_sb_init (const uint8_t *address, hal_nrf_operation_mode_t operational_mode) { hal_nrf_close_pipe(HAL_NRF_ALL); // First close all radio pipes // Pipe 0 and 1 open by default hal_nrf_open_pipe(HAL_NRF_PIPE0, FALSE); // Open pipe0, without/autoack hal_nrf_set_crc_mode(HAL_NRF_CRC_16BIT); // Operates in 16bits CRC mode hal_nrf_set_auto_retr(0, RF_RETRANS_DELAY); // Disables auto retransmit hal_nrf_set_address_width(HAL_NRF_AW_5BYTES); // 5 bytes address width hal_nrf_set_address(HAL_NRF_TX, address); // Set device's addresses hal_nrf_set_address(HAL_NRF_PIPE0, address); // Sets recieving address on // pipe0 if(operational_mode == HAL_NRF_PTX) // Mode depentant settings { hal_nrf_set_operation_mode(HAL_NRF_PTX); // Enter TX mode } else { hal_nrf_set_operation_mode(HAL_NRF_PRX); // Enter RX mode hal_nrf_set_rx_pload_width((uint8_t)HAL_NRF_PIPE0, RF_PAYLOAD_LENGTH); // Pipe0 expect // PAYLOAD_LENGTH byte payload // PAYLOAD_LENGTH in radio.h } hal_nrf_set_rf_channel(RF_CHANNEL); // Operating on static channel // Defined in radio.h. // Frequenzy = // 2400 + RF_CHANNEL hal_nrf_set_power_mode(HAL_NRF_PWR_UP); // Power up device hal_nrf_set_datarate(HAL_NRF_250KBPS); // Uncomment this line for // compatibility with nRF2401 // and nRF24E1 //hal_nrf_set_output_power(hal_nrf_output_power_t power); //default reset value is 0dbm // Wait for the radio to power up, max. 4.5ms depending on crystal Ls Timeout_SetTimeout2(5); while(!Timeout_IsTimeout2()); radio_set_status (RF_IDLE); // Radio now ready }
// Resets RF parameters to default values. // Must be called before jumping to new firmware. void resetRF() { // Reset values set by the RF setup. CE_LOW(); // PWR_UP = 0 hal_nrf_set_power_mode(HAL_NRF_PWR_DOWN); // PRIM_RX = 0 hal_nrf_set_operation_mode(HAL_NRF_PTX); // RF_CH = 0x02; hal_nrf_set_rf_channel(reset_channel); // AW = 11 (Default = 5 bytes) // RX_ADDR_P0 = TX_ADDR = 0xE7E7E7E7E7 hal_nrf_set_address(HAL_NRF_TX, reset_pipe_address); hal_nrf_set_address(HAL_NRF_PIPE0, reset_pipe_address); // ARD = 0000, ARC = 0011 hal_nrf_set_auto_retr(3, 250); // RX_PW_P0 = 0x00 hal_nrf_set_rx_payload_width((int)HAL_NRF_PIPE0, 0); // Disable radio clock RFCKEN = 0; return; }
void gzll_set_address(hal_nrf_address_t pipe, const uint8_t *address) { ASSERT((gzll_state_var == GZLL_IDLE)); ASSERT((pipe <= 5)); gzll_interupts_disable_rfck_enable(); gzll_tx_setup_modified = true; gzll_rx_setup_modified = true; if(pipe == HAL_NRF_PIPE0) { memcpy(gzll_p0_adr, (uint8_t*)address, GZLL_ADDRESS_WIDTH); } hal_nrf_set_address(pipe, address); gzll_interupts_enable_rfck_disable(); }
void gzll_set_address(hal_nrf_address_t pipe, const uint8_t *address) { uint32_t flag; ASSERT((gzll_state_var == GZLL_IDLE)); ASSERT((pipe <= 5)); flag = gzll_interupts_save(); gzll_tx_setup_modified = true; gzll_rx_setup_modified = true; if(pipe == HAL_NRF_PIPE0) { memcpy(gzll_p0_adr, (uint8_t*)address, GZLL_ADDRESS_WIDTH); } hal_nrf_set_address(pipe, address); gzll_interupts_restore(flag); }
void gzll_rx_start() { uint8_t i; uint32_t flag; gzll_goto_idle(); if(gzll_rx_setup_modified) { flag = gzll_interupts_save(); gzll_rx_setup_modified = false; gzll_tx_setup_modified = true; /* Restore pipe 0 address (this may have been altered during transmission) */ hal_nrf_set_address(HAL_NRF_PIPE0, gzll_p0_adr); /* Enable the receive pipes selected by gzll_set_param() */ hal_nrf_close_pipe(HAL_NRF_ALL); for(i = 0; i < 6; i++) { if(gzll_dyn_params[GZLL_PARAM_RX_PIPES] & (1 << i)) { hal_nrf_open_pipe((hal_nrf_address_t)i, EN_AA); } } hal_nrf_set_operation_mode(HAL_NRF_PRX); } gzll_set_radio_power_on(true); gzll_timeout_counter = 0; gzll_state_var = GZLL_HOST_ACTIVE; GZLL_RFCE_HIGH(); gzll_interupts_restore(flag); }
bool gzll_tx_data(const uint8_t *src, uint8_t length, uint8_t pipe) { uint8_t temp_address[GZLL_ADDRESS_WIDTH]; uint16_t temp; uint32_t flag; ASSERT(length <= GZLL_MAX_FW_PAYLOAD_LENGTH && length > 0); ASSERT(pipe <= 5); /* Length check to prevent memory corruption. (Note, assertion will capture this as well). */ if(length == 0 || length > GZLL_MAX_FW_PAYLOAD_LENGTH) { return false; } gzll_current_tx_payload_length = length; if(gzll_state_var == GZLL_HOST_ACTIVE) { gzll_goto_idle(); } flag = gzll_interupts_save(); /* If the specified pipe is different from the previous TX pipe, the TX setup must be updated */ if(pipe != gzll_current_tx_pipe) { gzll_current_tx_pipe = pipe; gzll_tx_setup_modified = true; } /* Here, state can be GZLL_IDLE or GZLL_DEVICE_ACTIVE */ if(gzll_state_var == GZLL_IDLE) { if(gzll_tx_setup_modified) // TX setup has to be restored? { gzll_tx_setup_modified = false; gzll_rx_setup_modified = true; hal_nrf_set_operation_mode(HAL_NRF_PTX); hal_nrf_open_pipe(HAL_NRF_PIPE0, EN_AA); //Read out the full RX address for pipe number "pipe" if(pipe == HAL_NRF_PIPE0) { hal_nrf_set_address(HAL_NRF_TX, gzll_p0_adr); hal_nrf_set_address(HAL_NRF_PIPE0, gzll_p0_adr); } else { //lint -esym(550,bytes_in_buffer) "variable not accessed" //lint -esym(438,bytes_in_buffer) "last assigned value not used" uint8_t bytes_in_buffer; bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE1, temp_address); if(pipe != HAL_NRF_PIPE1) { switch(pipe) { default: case HAL_NRF_PIPE2: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE2, temp_address); break; case HAL_NRF_PIPE3: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE3, temp_address); break; case HAL_NRF_PIPE4: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE4, temp_address); break; case HAL_NRF_PIPE5: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE5, temp_address); break; } bytes_in_buffer = bytes_in_buffer; } //Here, temp_address will contain the full TX address hal_nrf_set_address(HAL_NRF_PIPE0, temp_address); hal_nrf_set_address(HAL_NRF_TX, temp_address); /* Change seed for random generator. Will prevent different devices transmitting to the same host from using the same channel hopping sequence. */ //lint -esym(534, gzll_lfsr_get) "return value ignored" gzll_lfsr_get(pipe, 1); } } // Prepare for new transmission gzll_timeout_counter = 0; gzll_channel_switch_counter = 0; gzll_try_counter = 0; hal_nrf_flush_tx(); GZLL_UPLOAD_PAYLOAD_TO_RADIO(); gzll_tx_success_f = false; // Transmission by default "failure" temp = gzll_dyn_params[GZLL_PARAM_DEVICE_MODE]; gzll_set_radio_power_on(true); if(gzll_sync_on) { switch(temp) { case GZLL_DEVICE_MODE_2: default: gzll_start_new_tx(GZLL_CHANNEL_PREVIOUS_SUCCESS); break; case GZLL_DEVICE_MODE_3: gzll_start_new_tx(GZLL_CHANNEL_RANDOM); break; case GZLL_DEVICE_MODE_4: gzll_start_new_tx(GZLL_CHANNEL_ESTIMATED); break; } } else { switch(temp) { case GZLL_DEVICE_MODE_0: case GZLL_DEVICE_MODE_2: gzll_start_new_tx(GZLL_CHANNEL_PREVIOUS_SUCCESS); break; default: gzll_start_new_tx(GZLL_CHANNEL_RANDOM); break; } } gzll_state_var = GZLL_DEVICE_ACTIVE; gzll_interupts_restore(flag); return true; // Payload successfully written to TX FIFO } else // Else TRANSMIT state { /* Check if criteria for starting new transmission when already transmitting is fulfilled */ if(!gzll_tx_setup_modified && !hal_nrf_tx_fifo_full() ) { GZLL_UPLOAD_PAYLOAD_TO_RADIO(); gzll_interupts_restore(flag); return true; // Payload successfully written to TX FIFO } else { gzll_interupts_restore(flag); return false; // Payload not written to TX FIFO } } }
void gzll_init(void) { uint32_t flag; uint8_t temp_adr[GZLL_ADDRESS_WIDTH] = GZLL_DEFAULT_ADDRESS_PIPE1; flag = gzll_interupts_save(); GZLL_RFCE_LOW(); hal_nrf_enable_ack_payload(true); hal_nrf_enable_dynamic_payload(true); hal_nrf_setup_dynamic_payload(0xff); /* Initialize status variables. */ gzll_channel_tab_index = 0; gzll_channel_tab_size = GZLL_DEFAULT_CHANNEL_TAB_SIZE; gzll_pending_goto_idle = false; gzll_timer_period_modified = false; gzll_current_tx_pipe = 0; gzll_pending_tx_start = false; gzll_tx_setup_modified = true; gzll_rx_setup_modified = true; gzll_radio_active_f = false; gzll_tx_success_f = true; gzll_sync_period = 0; gzll_sync_on = false; gzll_rx_dr = false; gzll_rx_power_high_f = false; gzll_ack_rx_pipe_fifo_cnt = 0; /* Set up default addresses. */ hal_nrf_set_address(HAL_NRF_PIPE0, gzll_p0_adr); hal_nrf_set_address(HAL_NRF_PIPE1, temp_adr); temp_adr[0] = GZLL_DEFAULT_ADDRESS_PIPE2; hal_nrf_set_address(HAL_NRF_PIPE2, temp_adr); temp_adr[0] = GZLL_DEFAULT_ADDRESS_PIPE3; hal_nrf_set_address(HAL_NRF_PIPE3, temp_adr); temp_adr[0] = GZLL_DEFAULT_ADDRESS_PIPE4; hal_nrf_set_address(HAL_NRF_PIPE4, temp_adr); temp_adr[0] = GZLL_DEFAULT_ADDRESS_PIPE5; hal_nrf_set_address(HAL_NRF_PIPE5, temp_adr); /* Set up default channel. */ hal_nrf_set_rf_channel(gzll_channel_tab[gzll_channel_tab_index]); /* Initialize dynamic parameters using default values. */ gzll_dyn_params[GZLL_PARAM_DEVICE_MODE] = GZLL_DEFAULT_PARAM_DEVICE_MODE; gzll_dyn_params[GZLL_PARAM_TX_TIMEOUT] = GZLL_DEFAULT_PARAM_TX_TIMEOUT; gzll_dyn_params[GZLL_PARAM_TX_ATTEMPTS_PR_CHANNEL_WHEN_SYNC_ON] = GZLL_DEFAULT_PARAM_TX_ATTEMPTS_PR_CHANNEL_WHEN_SYNC_ON; gzll_dyn_params[GZLL_PARAM_TX_ATTEMPTS_PR_CHANNEL_WHEN_SYNC_OFF] = GZLL_DEFAULT_PARAM_TX_ATTEMPTS_PR_CHANNEL_WHEN_SYNC_OFF; gzll_dyn_params[GZLL_PARAM_HOST_MODE] = GZLL_DEFAULT_PARAM_HOST_MODE; gzll_dyn_params[GZLL_PARAM_RX_PIPES] = GZLL_DEFAULT_PARAM_RX_PIPES; gzll_dyn_params[GZLL_PARAM_CRYPT_PIPES] = GZLL_DEFAULT_PARAM_CRYPT_PIPES; gzll_dyn_params[GZLL_PARAM_RX_TIMEOUT] = GZLL_DEFAULT_PARAM_RX_TIMEOUT; gzll_dyn_params[GZLL_PARAM_HOST_MODE_1_CYCLE_PERIOD] = GZLL_DEFAULT_PARAM_HOST_MODE_1_CYCLE_PERIOD; gzll_dyn_params[GZLL_PARAM_RX_PERIOD] = GZLL_DEFAULT_PARAM_RX_PERIOD; gzll_dyn_params[GZLL_PARAM_RX_PERIOD_MODIFIER] = GZLL_DEFAULT_PARAM_RX_PERIOD_MODIFIER; gzll_dyn_params[GZLL_PARAM_RX_CHANNEL_HOLD_PERIODS] = GZLL_DEFAULT_PARAM_RX_CHANNEL_HOLD_PERIODS; gzll_dyn_params[GZLL_PARAM_OUTPUT_POWER] = GZLL_DEFAULT_PARAM_OUTPUT_POWER; gzll_dyn_params[GZLL_PARAM_POWER_DOWN_IDLE_ENABLE] = GZLL_DEFAULT_PARAM_POWER_DOWN_IDLE_ENABLE; gzll_dyn_params[GZLL_PARAM_MAX_SYNC_PERIOD] = GZLL_DEFAULT_PARAM_MAX_SYNC_PERIOD; gzll_dyn_params[GZLL_PARAM_COLLISION_CHANNEL_SWITCH_LIMIT] = GZLL_DEFAULT_PARAM_COLLISION_CHANNEL_SWITCH_LIMIT; /* Set up default output power. */ hal_nrf_set_output_power((hal_nrf_output_power_t) gzll_dyn_params[GZLL_PARAM_OUTPUT_POWER]); /* Static radio setup. */ hal_nrf_set_datarate(GZLL_HAL_DATARATE); hal_nrf_set_crc_mode(GZLL_CRC); hal_nrf_set_address_width(GZLL_ADDRESS_WIDTH); /* Clear radio IRQ flags. */ //lint -esym(534, hal_nrf_get_clear_irq_flags) "return value ignored" hal_nrf_get_clear_irq_flags(); hal_nrf_flush_rx(); hal_nrf_flush_tx(); gzll_set_timer_period(GZLL_DEFAULT_PARAM_RX_PERIOD); gzll_set_system_idle(); gzll_interupts_restore(flag); }
void radio_pl_init (const uint8_t *address, hal_nrf_operation_mode_t operational_mode) { hal_nrf_close_pipe(HAL_NRF_ALL); // First close all radio pipes // Pipe 0 and 1 open by default hal_nrf_open_pipe(HAL_NRF_PIPE0, true); // Then open pipe0, w/autoack hal_nrf_set_crc_mode(HAL_NRF_CRC_16BIT); // Operates in 16bits CRC mode hal_nrf_set_auto_retr(RF_RETRANSMITS, RF_RETRANS_DELAY); // Enables auto retransmit. // 3 retrans with 250ms delay hal_nrf_set_address_width(HAL_NRF_AW_5BYTES); // 5 bytes address width hal_nrf_set_address(HAL_NRF_TX, address); // Set device's addresses hal_nrf_set_address(HAL_NRF_PIPE0, address); // Sets recieving address on // pipe0 /***************************************************************************** * Changed from esb/radio_esb.c * * Enables: * * - ACK payload * * - Dynamic payload width * * - Dynamic ACK * *****************************************************************************/ hal_nrf_enable_ack_pl(); // Try to enable ack payload // When the features are locked, the FEATURE and DYNPD are read out 0x00 // even after we have tried to enable ack payload. This mean that we need to // activate the features. if(hal_nrf_read_reg(FEATURE) == 0x00 && (hal_nrf_read_reg(DYNPD) == 0x00)) { hal_nrf_lock_unlock (); // Activate features hal_nrf_enable_ack_pl(); // Enables payload in ack } hal_nrf_enable_dynamic_pl(); // Enables dynamic payload hal_nrf_setup_dyn_pl(ALL_PIPES); // Sets up dynamic payload on // all data pipes. /***************************************************************************** * End changes from esb/radio_esb.c * *****************************************************************************/ if(operational_mode == HAL_NRF_PTX) // Mode depentant settings { hal_nrf_set_operation_mode(HAL_NRF_PTX); // Enter TX mode } else { hal_nrf_set_operation_mode(HAL_NRF_PRX); // Enter RX mode hal_nrf_set_rx_pload_width((uint8_t)HAL_NRF_PIPE0, RF_PAYLOAD_LENGTH); // Pipe0 expect // PAYLOAD_LENGTH byte payload // PAYLOAD_LENGTH in radio.h } hal_nrf_set_rf_channel(RF_CHANNEL); // Operating on static channel // Defined in radio.h. // Frequenzy = // 2400 + RF_CHANNEL hal_nrf_set_power_mode(HAL_NRF_PWR_UP); // Power up device start_timer(RF_POWER_UP_DELAY); // Wait for the radio to wait_for_timer(); // power up radio_set_status (RF_IDLE); // Radio now ready }
void agent_set_my_addr(void) { uint8_t tmp_addr[GZLL_ADDRESS_WIDTH] = GZLL_DEFAULT_ADDRESS_PIPE1; tmp_addr[0] = my_addr; hal_nrf_set_address(HAL_NRF_PIPE1, tmp_addr); }
void main(void) { int i = 0; // local counter int total_pkt_count = 1; int addr_width = 5; int customized_plen = 0; int pipe_num = 6; epl_rf_en_auto_ack_t auto_ack = 0; //int mode = 1; // 1 for sender mode, 2 for dumper mode // new params unsigned char pipe_source; // used to store pipe_source number unsigned char ACKbuf[] = "ACK"; unsigned char temp_buf[34]; // used for dumper to get RF packets from RX FIFO unsigned char temp_addr[5]; unsigned char data_length = 0; unsigned char dynpd_pipe; unsigned char addr_buf[5]; // set pin direction P0EXP = 0x00; P0ALT = 0x00; P0DIR = 0x00; // uart init epl_uart_init(UART_BAUD_57K6); //init usb connection usb_init(); // Initialize USB EA = 1; // Enable global IRQ //Start RF tx mode epl_rf_en_quick_init(cfg); //Clear TX FIFO hal_nrf_write_reg(FLUSH_TX, 0); hal_nrf_write_reg(FLUSH_RX, 0); hal_nrf_lock_unlock(); hal_nrf_enable_dynamic_pl(); LED_Blink(20); epl_uart_putstr("start!"); while (1) { usb_recv_packet(); switch (ubuf[1]) { case EPL_SENDER_MODE: customized_plen = 0; for (i = 0; i < PLOAD_LEN; i++) packet[i] = i + 9; hal_nrf_close_pipe(HAL_NRF_PIPE1); hal_nrf_close_pipe(HAL_NRF_PIPE2); hal_nrf_close_pipe(HAL_NRF_PIPE3); hal_nrf_close_pipe(HAL_NRF_PIPE4); hal_nrf_close_pipe(HAL_NRF_PIPE5); break; case EPL_DUMPER_MODE: hal_nrf_close_pipe(HAL_NRF_PIPE1); hal_nrf_close_pipe(HAL_NRF_PIPE2); hal_nrf_close_pipe(HAL_NRF_PIPE3); hal_nrf_close_pipe(HAL_NRF_PIPE4); hal_nrf_close_pipe(HAL_NRF_PIPE5); break; case EPL_OUTPUT_POWER: //Host:set_output_power hal_nrf_set_output_power(ubuf[2]); epl_uart_putstr("EPL_OUTPUT_POWER\n"); usb_send_packet(ACKbuf, 3); epl_uart_putstr("EPL_OUTPUT_POWER END\n"); break; case EPL_CHANNEL: hal_nrf_set_rf_channel(ubuf[2]); usb_send_packet(ACKbuf, 3); break; case EPL_DATARATE: hal_nrf_set_datarate(ubuf[2]); usb_send_packet(ACKbuf, 3); break; case EPL_ADDR_WIDTH: addr_width = (int) ubuf[2]; hal_nrf_set_address_width(ubuf[2]); usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P0: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P1: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P2: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P3: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P4: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_AUTOACK_P5: auto_ack = ubuf[2]; usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P0: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE0, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P1: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE1, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P2: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE2, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P3: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE3, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P4: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE4, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_DATA_LENGTH_P5: data_length = (int) ubuf[2]; epl_rf_en_rcv_pipe_config(HAL_NRF_PIPE5, temp_addr, data_length, auto_ack); usb_send_packet(ACKbuf, 3); break; case EPL_CRC_MODE: if (ubuf[2] == 0) hal_nrf_set_crc_mode(HAL_NRF_CRC_OFF); else if (ubuf[2] == 2) hal_nrf_set_crc_mode(HAL_NRF_CRC_8BIT); else if (ubuf[2] == 3) hal_nrf_set_crc_mode(HAL_NRF_CRC_16BIT); else ; usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P0: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } hal_nrf_set_address(HAL_NRF_PIPE0, temp_addr); epl_rf_en_set_dst_addr(temp_addr); usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P1: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P2: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P3: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P4: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } usb_send_packet(ACKbuf, 3); break; case EPL_RX_ADDR_P5: for (i = 0; i < addr_width; i++) { temp_addr[i] = ubuf[i + 2]; } usb_send_packet(ACKbuf, 3); break; case EPL_USER_PLOAD: if (ubuf[2] == USRS_PLOAD) { customized_plen = (int) ubuf[3]; for (i = 0; i < customized_plen; i++) { packet[i] = ubuf[i + 4]; } } else { customized_plen = 0; for (i = 0; i < PLOAD_LEN; i++) { packet[i] = i + 9; } } usb_send_packet(ACKbuf, 3); break; case EPL_NEW_COUNTER: total_pkt_count = 1; usb_send_packet(ACKbuf, 3); break; /*20110221 celine*/ case EPL_DYNAMIC_PD: dynpd_pipe = (int)ubuf[2]; if ((int)ubuf[3] == 01){ //hal_nrf_setup_dyn_pl(dynpd_pipe); hal_nrf_write_reg(DYNPD, (1<<dynpd_pipe) | hal_nrf_read_reg(DYNPD)); } else { //hal_nrf_lock_unlock(); //hal_nrf_enable_dynamic_pl(); hal_nrf_write_reg(DYNPD, ~(1<<dynpd_pipe) & hal_nrf_read_reg(DYNPD)); } usb_send_packet(ACKbuf, 3); break; /**/ case EPL_RUN_SENDER: epl_rf_en_enter_tx_mode(); // clear Tx irq hal_nrf_clear_irq_flag(HAL_NRF_TX_DS); hal_nrf_clear_irq_flag(HAL_NRF_MAX_RT); if (ubuf[2] == AUTO_PLOAD) { epl_uart_putstr("\nauto pload\r\n"); packet[0] = total_pkt_count++; epl_rf_en_send(packet, data_length); } else { epl_uart_putstr("\nusrs pload\r\n"); epl_rf_en_send(packet, customized_plen); } LED_Blink(10); array_cp(temp_buf, ACKbuf, 3); temp_buf[3] = hal_nrf_read_reg(OBSERVE_TX) & 0x0F; usb_send_packet(temp_buf, 4); epl_rf_en_enter_rx_mode(); break; case EPL_RUN_DUMPER: hal_nrf_clear_irq_flag(HAL_NRF_RX_DR); hal_nrf_flush_rx(); epl_rf_en_enter_rx_mode(); while (1) { if (ubuf[1] == 0xf5) { // Host wants to terminate epl_uart_putstr("Terminate !\r\n"); break; }else if (hal_nrf_rx_fifo_empty() == 0) { // Rx_fifo is not empty LED0_Toggle(); pipe_source = hal_nrf_get_rx_data_source(); hal_nrf_read_rx_pload(temp_buf); // pending the data source on last byte temp_buf[32] = pipe_source; if(hal_nrf_read_reg(DYNPD)>>(int)pipe_source) temp_buf[33] = hal_nrf_read_reg(RD_RX_PLOAD_W); else temp_buf[33] = hal_nrf_read_reg(RX_PW_P0+pipe_source); // epl_uart_putstr("temp_buf[33] = "); // epl_uart_puthex(temp_buf[33]); // epl_uart_putstr("\r\n"); usb_send_packet(temp_buf, 34); if((hal_nrf_read_reg(STATUS))&0x10){ hal_nrf_write_reg(FLUSH_TX, 0); } LED0_Toggle(); } } break; case EPL_SHOW_CONFIG: epl_uart_putstr("\r\n0. CONFIG = "); epl_uart_puthex(hal_nrf_read_reg(CONFIG)); epl_uart_putstr("\r\n1. RF_CH = "); epl_uart_puthex(hal_nrf_read_reg(RF_CH)); epl_uart_putstr("\r\n2. EN_AA = "); epl_uart_puthex(hal_nrf_read_reg(EN_AA)); epl_uart_putstr("\r\n3. EN_RXADDR = "); epl_uart_puthex(hal_nrf_read_reg(EN_RXADDR)); epl_uart_putstr("\r\n4. TX_ADDR = "); hal_nrf_read_multibyte_reg(HAL_NRF_TX, addr_buf); epl_uart_puthex(addr_buf[0]); epl_uart_puthex(addr_buf[1]); epl_uart_puthex(addr_buf[2]); epl_uart_puthex(addr_buf[3]); epl_uart_puthex(addr_buf[4]); epl_uart_putstr("\r\n4. RX_ADDR_PO = "); hal_nrf_read_multibyte_reg(HAL_NRF_PIPE0, addr_buf); epl_uart_puthex(addr_buf[0]); epl_uart_puthex(addr_buf[1]); epl_uart_puthex(addr_buf[2]); epl_uart_puthex(addr_buf[3]); epl_uart_puthex(addr_buf[4]); epl_uart_putstr("\r\n RX_ADDR_P1 = "); hal_nrf_read_multibyte_reg(HAL_NRF_PIPE1, addr_buf); epl_uart_puthex(addr_buf[0]); epl_uart_puthex(addr_buf[1]); epl_uart_puthex(addr_buf[2]); epl_uart_puthex(addr_buf[3]); epl_uart_puthex(addr_buf[4]); epl_uart_putstr("\r\n RX_ADDR_P2 = "); epl_uart_puthex(hal_nrf_read_reg(RX_ADDR_P2)); epl_uart_putstr("\r\n RX_ADDR_P3 = "); epl_uart_puthex(hal_nrf_read_reg(RX_ADDR_P3)); epl_uart_putstr("\r\n RX_ADDR_P4 = "); epl_uart_puthex(hal_nrf_read_reg(RX_ADDR_P4)); epl_uart_putstr("\r\n RX_ADDR_P5 = "); epl_uart_puthex(hal_nrf_read_reg(RX_ADDR_P5)); epl_uart_putstr("\r\n5. RX_PW_P0 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P0)); epl_uart_putstr("\r\n RX_PW_P1 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P1)); epl_uart_putstr("\r\n RX_PW_P2 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P2)); epl_uart_putstr("\r\n RX_PW_P3 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P3)); epl_uart_putstr("\r\n RX_PW_P4 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P4)); epl_uart_putstr("\r\n RX_PW_P5 = "); epl_uart_puthex(hal_nrf_read_reg(RX_PW_P5)); epl_uart_putstr("\r\n6. RF_SETUP = "); epl_uart_puthex(hal_nrf_read_reg(RF_SETUP)); epl_uart_putstr("\r\n7. STATUS = "); epl_uart_puthex(hal_nrf_read_reg(STATUS)); epl_uart_putstr("\r\n8 .DYNPD = "); epl_uart_puthex(hal_nrf_read_reg(DYNPD)); epl_uart_putstr("\r\n9. FEATURE = "); epl_uart_puthex(hal_nrf_read_reg(FEATURE)); default: break; }// end switch case
/* To be compatible with nRF24L01, please disable the auto ack function. */ void epl_rf_en_rcv_pipe_config(hal_nrf_address_t in_pipe_num, char *in_pipe_rcv_addr, unsigned char in_pipe_pload_length, epl_rf_en_auto_ack_t in_auto_ack) { hal_nrf_open_pipe(in_pipe_num, in_auto_ack); // Open pipe and configure the auto ack function. hal_nrf_set_address(in_pipe_num, in_pipe_rcv_addr); // Address for PRX pipe hal_nrf_set_rx_payload_width(in_pipe_num, in_pipe_pload_length); }
/** Configuring the PTX address (destination address). * Use this function to configure destination address. * * @param *in_dst_addr The destination address. */ void epl_rf_en_set_dst_addr(unsigned char *in_dst_addr) { hal_nrf_set_address(HAL_NRF_TX, in_dst_addr); // Address for PTX (The address of destination.) }