RE: Minimum Bandwidth Requirement for FCC Certification

FormerMember — Thu, 19 Apr 2018 13:22:43 GMT

The code you are using looks fine, except that you should use modulated tx carrier. For testing the bandwidth, modulated TX carrier has to be used.

"6dB bandwidth" is measured on a modulated signal. When setting up the radio, use radio_modulated_tx_carrier() to generate a signal with a random payload.

RE: Minimum Bandwidth Requirement for FCC Certification

KrishNa — Thu, 19 Apr 2018 03:58:25 GMT

Hi Kristin/nRF Team,

We are awaiting your response. We are stuck at our certification lab and not able to move forward from past week.

Please expedite and help us to resolve the issue earliest.

Update: Do i need to send Constant carrier Tx or Modulated Carrier Tx for FCC.

Thanks in Advance,

Best,

Krish

RE: Minimum Bandwidth Requirement for FCC Certification

KrishNa — Tue, 17 Apr 2018 09:30:04 GMT

Hi Kristin,

Thanks for the quick reply.

I have modified the code so that instead of sending the inputs via terminal, i have hardcoded it in the main loop.

Below is the code snippet for the same

uint8_t txpower = RADIO_TXPOWER_TXPOWER_Pos4dBm; // 0 dBm

uint8_t mode = RADIO_MODE_MODE_Nrf_2Mbit; // 2 MBit mode

uint8_t channel = 2; // Transmit at channel 40

int delayms = 10;

radio_tx_carrier(txpower, mode, channel);

radio_tx_sweep_start(txpower,mode,channel,channel, delayms);

In the below code snippet, i am trying to change frequency channels on button press.

1) 1st button click - channel 2 (2402)

2) 2nd button click - channel 40 (2440)

3) 3rd button click - channel 80 (2480)

4) 4th button click - radio sweep end

Also attaching my modified main function for your reference

int main(void)
{
    uint32_t err_code;
    radio_tests_t test     = RADIO_TEST_NOP;
    radio_tests_t cur_test = RADIO_TEST_NOP;
	
		 
	 	uint8_t txpower = RADIO_TXPOWER_TXPOWER_Pos4dBm; // 0 dBm
		uint8_t mode    = RADIO_MODE_MODE_Nrf_2Mbit;  // 2 MBit mode
	
	static char toggle=0, toggle_1=0;

    init();
    const app_uart_comm_params_t comm_params =
    {
        RX_PIN_NUMBER,
        TX_PIN_NUMBER,
        RTS_PIN_NUMBER,
        CTS_PIN_NUMBER,
        APP_UART_FLOW_CONTROL_DISABLED,
        false,
        UART_BAUDRATE_BAUDRATE_Baud115200
    };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    APP_ERROR_CHECK(err_code);
    printf("RF Test\r\n");
    NVIC_EnableIRQ(TIMER0_IRQn);
    __enable_irq();
	 
	 nrf_gpio_cfg_output(22);
	 nrf_gpio_cfg_output(23);
	 
	 nrf_gpio_pin_set(22);  	
	 nrf_gpio_pin_set(23);	

	 nrf_gpio_cfg_input(06, NRF_GPIO_PIN_NOPULL);	
	 
    while (true)
    {

		 if((nrf_gpio_pin_read(06)==0)&&(toggle_1 == 0))
		 {
			 toggle++;
			 toggle_1 = 1;
			 
			 if(toggle == 1)
			 { 
				printf("toggle == 1\r\n");
				nrf_gpio_pin_clear(22);  
				nrf_gpio_pin_set(23);
				 
				uint8_t channel = 2; 												// Transmit at channel 40
				int 	  delayms = 10;
				radio_tx_carrier(txpower, mode, channel);
				radio_tx_sweep_start(txpower,mode,channel,channel, delayms);
			 }
			 else if(toggle == 2)
			 {
				 printf("toggle == 2\r\n");
				nrf_gpio_pin_set(22);  
				nrf_gpio_pin_clear(23);	

				uint8_t channel = 40; 												// Transmit at channel 40
				int 	  delayms = 10;
				radio_tx_carrier(txpower, mode, channel);
				radio_tx_sweep_start(txpower,mode,channel,channel, delayms);				 
			 }
			 else if(toggle == 3)
			 {
				 printf("toggle == 3\r\n");
			 	nrf_gpio_pin_clear(22);  
				nrf_gpio_pin_clear(23);
				 
				uint8_t channel = 80; 												// Transmit at channel 40
				int 	  delayms = 10;
				radio_tx_carrier(txpower, mode, channel);
				radio_tx_sweep_start(txpower,mode,channel,channel, delayms);
			 }
			 else if(toggle == 4)
			 {
				 printf("toggle == 4\r\n");
			 	nrf_gpio_pin_set(22);  
				nrf_gpio_pin_set(23);
				toggle = 0;
				 radio_sweep_end();
				 
			 }
			 
		 }
		 else if(nrf_gpio_pin_read(06)==1)
			toggle_1 = 0;
		 
			 
       /*{
			 uint8_t control;
        scanf("%c",&control);
        switch (control)
        {
            case 'a':
                while (true)
                {
                    printf("Enter start channel (two decimal digits, 00 to 80):\r\n");
                    scanf("%d",&channel_start_);
                    if ((channel_start_ <= 80)&&(channel_start_ >= 0))
                    {
                        printf("%d\r\n", channel_start_);
                        break;
                    }

                    printf("Channel must be between 0 and 80\r\n");
                }
                test = cur_test;
                break;

            case 'b':
                while (true)
                {
                    printf("Enter end channel (two decimal digits, 00 to 80):\r\n");
                    scanf("%d",&channel_end_);
                    if ((channel_end_ <= 80)&&(channel_start_ >= 0))
                    {
                        printf("%d\r\n", channel_end_);
                        break;
                    }
                    printf("Channel must be between 0 and 80\r\n");
                }
                test = cur_test;
                break;

            case 'c':
                test = RADIO_TEST_TXCC;
                break;

            case 'd':
                while (true)
                {
                    printf("Enter delay in ms (two decimal digits, 01 to 99):\r\n");
                    scanf("%d",&delayms_);
                    if ((delayms_ > 0) && (delayms_ < 100))
                    {
                        printf("%d\r\n", delayms_);
                        break;
                    }
                    printf("Delay must be between 1 and 99\r\n");
                }
                test = cur_test;
                break;

            case 'e':
                radio_sweep_end();
                cur_test = RADIO_TEST_NOP;
                break;

            case 'm':
                get_datarate();
                test = cur_test;
                break;

            case 'o':
                test = RADIO_TEST_TXMC;
                printf("TX modulated carrier\r\n");
                break;

            case 'p':
                get_power();
                test = cur_test;
                break;

            case 'r':
                test = RADIO_TEST_RXSWEEP;
                printf("RX Sweep\r\n");
                break;

            case 's':
                print_parameters();
                break;

            case 't':
                test = RADIO_TEST_TXSWEEP;
                printf("TX Sweep\r\n");
                break;

            case 'x':
                test = RADIO_TEST_RXC;
                printf("RX constant carrier\r\n");
                break;

            case 'h':
                help();
                break;

            default:
                // No implementation needed
                break;
        }

        switch (test)
        {
            case RADIO_TEST_TXCC:
                if (sweep)
                {
                    radio_sweep_end();
                    sweep = false;
                }
                radio_tx_carrier(txpower_, mode_, channel_start_);
                cur_test = test;
                test     = RADIO_TEST_NOP;
                break;

            case RADIO_TEST_TXMC:
                if (sweep)
                {
                    radio_sweep_end();
                    sweep = false;
                }
                radio_modulated_tx_carrier(txpower_, mode_, channel_start_);
                cur_test = test;
                test     = RADIO_TEST_NOP;
                break;

            case RADIO_TEST_TXSWEEP:
                radio_tx_sweep_start(txpower_, mode_, channel_start_, channel_end_, delayms_);
                sweep    = true;
                cur_test = test;
                test     = RADIO_TEST_NOP;
                break;

            case RADIO_TEST_RXC:
                if (sweep)
                {
                    radio_sweep_end();
                    sweep = false;
                }
                radio_rx_carrier(mode_, channel_start_);
                cur_test = test;
                test     = RADIO_TEST_NOP;
                break;

            case RADIO_TEST_RXSWEEP:
                radio_rx_sweep_start(mode_, channel_start_, channel_end_, delayms_);
                sweep    = true;
                cur_test = test;
                test     = RADIO_TEST_NOP;
                break;

            case RADIO_TEST_NOP:
                // Fall through.
            default:
                // No implementation needed.
                break;
        }
    }*/
  }
}

Can you check whether everything looks ok or not?

We have also got a report from our testing house that the output power is very low, it comes around -5 to -10 dBm range. Is there any specific reason why the output power is very low even we have selected +4 dBm in our code?

Awaiting your reply.

Best,

Krish

RE: Minimum Bandwidth Requirement for FCC Certification

FormerMember — Tue, 17 Apr 2018 09:01:15 GMT

Which commands you use when setting up the test? When I test here, I use the below commands and get the following result, which is within the 500 kHz requirement:

Commands: