/** * Scan all the available channels for carrier/rpd * Results are stored in the sweeper struct * * @param s sweeper instance to work with * @param loops number of loops to perform the sweep */ void rf24_sweep(struct rf24_sweeper *s, int loops) { while (loops--) { int i = RF24_NUM_CHANNELS; while (i--) { /* Select this channel */ rf24_set_channel(s->r, i); // Listen for a little rf24_start_listening(s->r); delay_us(128); rf24_stop_listening(s->r); /* Did we get a carrier? */ #ifdef CONFIG_LIB_RF24_SWEEP_RPD if ( rf24_test_rpd(s->r) ) #else if ( rf24_test_carrier(s->r) ) #endif s->values[i]++; } } }
uchar usbFunctionSetup(uchar data[8]) { usbRequest_t *rq = (void *)data; switch (rq->bRequest) { case RQ_SET_CONFIG: rf24_init(g_radio); rf24_enable_dynamic_payloads(g_radio); rf24_set_channel(g_radio, rq->wValue.bytes[0]); rf24_set_data_rate(g_radio, rq->wValue.bytes[1]); rf24_set_pa_level(g_radio, rq->wIndex.bytes[0]); break; case RQ_OPEN_PIPES: break; case RQ_LISTEN: if (rq->wValue.bytes[0]) { rf24_open_reading_pipe(g_radio, 1, local_addr); rf24_start_listening(g_radio); } else { rf24_stop_listening(g_radio); rf24_open_writing_pipe(g_radio, remote_addr); } break; case RQ_READ: { uint8_t pipe; uint8_t retries=50; uint8_t len =0; do { if (rf24_available(g_radio, &pipe)) { PORTC ^= 1<<2; len = rf24_get_dynamic_payload_size(g_radio); have_moar = !rf24_read(g_radio, msg, len); usbMsgPtr = msg; return len; } delay_ms(10); } while (retries--); } return 0; break; case RQ_NOP: /* Shit out dbg buffer */ usbMsgPtr = msg; return strlen(msg)+1; break; } last_rq = rq->bRequest; rq_len = rq->wLength.word; pos = 0; return USB_NO_MSG; }
int nrf24_scan_channels(struct rf24 *pnrf, int argc, char *argv[]) { uint8_t addr[] = {'A', 'A', 'A', 'A', 'A'}; uint32_t rpd[RF24_MAX_CHANNEL + 1] = { 0 }; int cmax = RF24_MAX_CHANNEL; int cmin = 0; int loops = 5; int cycles = 25; int ch, lps; if ((argc > 0) && argv[0]) cmin = atoi(argv[0]); if ((argc > 1) && argv[1]) cmax = atoi(argv[1]); if ((argc > 2) && argv[2]) loops = atoi(argv[2]); if ((argc > 3) && argv[3]) cycles = atoi(argv[3]); if ((cmin < 0) || (cmin > cmax)) cmin = 0; if ((cmax < cmin) || (cmax > RF24_MAX_CHANNEL)) cmax = RF24_MAX_CHANNEL; if (loops <= 0) loops = 5; if (cycles <= 0) cycles = 25; for (ch = cmin; ch <= cmax; ch++) printf("%02x ", ch); printf("\n"); rf24_set_crc_mode(pnrf, RF24_CRC_NONE); rf24_set_auto_ack_all(pnrf, 0x0); rf24_setup_prx(pnrf, 0x0, addr); while (cycles--) { lps = loops; memset(rpd, 0x0, sizeof(rpd)); while (lps--) { for (ch = cmin; ch <= cmax; ch++) { rf24_set_channel(pnrf, ch); rf24_start_prx(pnrf); if (rf24_get_carrier(pnrf) & RPD_RPD) rpd[ch]++; } } for (ch = cmin; ch <= cmax; ch++) printf("%02x ", rpd[ch]); printf("\n"); } return 0; }
int main(int argc, char *argv[]) { struct nrf24_drv *pdrv; bool parse_message = false; uint8_t recv_buffer[32]; enum rf24_rx_status ret; int recv_length = 32; struct rf24 *pnrf; int pipe; int rc; int i; struct cfg_platform pconf = {0}; struct cfg_radio rconf = {0}; char *config_name = DEFAULT_CONFIG; /* command line options */ int opt; const char opts[] = "c:ph"; const struct option longopts[] = { {"config", required_argument, NULL, 'c'}, {"parse-message", no_argument, NULL, 'p'}, {"help", optional_argument, NULL, 'h'}, {NULL,} }; /* use sane config defaults */ cfg_radio_init(&rconf); cfg_platform_init(&pconf); while (opt = getopt_long(argc, argv, opts, longopts, &opt), opt > 0) { switch (opt) { case 'c': config_name = strdup(optarg); break; case 'p': parse_message = true; break; case 'h': default: nrf24_test_usage(argv[0]); exit(0); } } /* read and validate config */ rc = cfg_from_file(config_name); if (rc < 0) { printf("ERR: failed to parse config\n"); exit(-1); } rc = cfg_radio_read(&rconf); if (rc < 0) { printf("ERR: failed to get radio config\n"); exit(-1); } rc = cfg_platform_read(&pconf); if (rc < 0) { printf("ERR: failed to get platform config\n"); exit(-1); } cfg_platform_dump(&pconf); cfg_radio_dump(&rconf); rc = cfg_radio_validate(&rconf); if (rc < 0) { printf("ERR: invalid radio config\n"); exit(-1); } /* setup nRF24 driver */ pnrf = &nrf; memset(pnrf, 0x0, sizeof(*pnrf)); pdrv = nrf24_driver_setup(pnrf, (void *)&pconf); if (!pdrv) { printf("ERR: can't setup driver for nrf24 radio\n"); exit(-1); } /* setup nRF24L01 */ rf24_init(pnrf); rf24_print_status(pnrf); /* */ if (cfg_payload_is_dynamic(&rconf)) rf24_enable_dyn_payload(pnrf); else rf24_set_payload_size(pnrf, rconf.payload); rf24_set_channel(pnrf, rconf.channel); rf24_set_data_rate(pnrf, rconf.rate); rf24_set_crc_mode(pnrf, rconf.crc); rf24_set_pa_level(pnrf, rconf.pwr); for (i = 0; i < PIPE_MAX_NUM; i++) { if (rconf.pipe[i]) rf24_setup_prx(pnrf, i, rconf.pipe[i]); } rf24_start_prx(pnrf); rf24_print_status(pnrf); /* */ while (1) { /* block for driver 'ready' event */ ret = nrf24_driver_wait_for(pdrv); if (ret < 0) { printf("ERR: driver wait failure\n"); exit(-1); } else if (ret == 0) { /* some interruption: try again */ continue; } else { /* ready to go */ } if (!rf24_rx_ready(pnrf, &pipe)) continue; ret = rf24_rx_pipe_check(pnrf, pipe); if (ret != RF24_RX_OK) { printf("WARN: pipe check error 0x%02x\n", (int)pipe); rf24_flush_rx(pnrf); continue; } printf("INFO: data ready in pipe 0x%02x\n", pipe); memset(recv_buffer, 0x0, sizeof(recv_buffer)); if (rf24_is_dyn_payload(pnrf)) { recv_length = (int)rf24_get_dyn_payload_size(pnrf); if (recv_length == 0xff) { printf("WARN: failed to get dynamic payload length\n"); rf24_flush_rx(pnrf); continue; } } ret = rf24_recv(pnrf, recv_buffer, recv_length); if (ret != RF24_RX_OK) { printf("WARN: failed to receive rx data: 0x%02x\n", ret); rf24_flush_rx(pnrf); continue; } if (parse_message) decode_data(recv_buffer, recv_length); else dump_data(recv_buffer, recv_length); } }