Minimum Bandwidth Requirement for FCC Certification

[KrishNa]

Hi All,

We are currently in the process of FCC certification for one of our product that uses nRF51822. Our testing house said the the test has failed because of not qualifying the minimum bandwidth requirement.

We used the radio test example provided in the SDK12.2 for this purpose and the radio settings used are as below

1) Tx Power = RADIO_TXPOWER_TXPOWER_Pos4dBm  (4dBm)

2) Frequency = 2402 MHz

3) Mode = RADIO_MODE_MODE_Nrf_2Mbit      (Nrf 2Mbit)

The testing house has sent us the image of the failed results as attached below

and it says like this

According to FCC 15.247,  systems using digital modulation, the minimum 6dB bandwidth shall be at least 500 kHz.

I dont know what went wrong. Please help us to resolve the issue at the earliest as we are approaching the production deadline.

Best.

Krish

[FormerMember]

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:

a

2

m

2

p

0

o

 

[KrishNa]

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

[KrishNa]

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 

[FormerMember]

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.