Promiscuous scanners

.github/workflows/build_linux.yml

@@ -17,7 +17,7 @@ on:
  - "utility/MRAAA/*"
  - "utility/SPIDEV/*"
  - "utility/pigpio"
- - "examples_linux/*"
+ - "examples_linux/**"
  - "!examples_linux/*.py"
  - "!examples_linux/*.md"
  - "pyRF24/setup.py"
@@ -39,7 +39,7 @@ on:
  - "utility/MRAAA/*"
  - "utility/SPIDEV/*"
  - "utility/pigpio"
- - "examples_linux/*"
+ - "examples_linux/**"
  - "!examples_linux/*.py"
  - "!examples_linux/*.md"
  - "pyRF24/setup.py"

.gitignore

@@ -18,8 +18,9 @@ Session.vim
 .DS_Store
 Makefile.inc
 utility/includes.h
+!examples_linux/
 examples_linux/*
-examples_linux/**/*
+!examples_linux/**/
 !examples_linux/*.cpp
 !examples_linux/*.py
 !examples_linux/**/*.cpp

examples/scanner/scanner.ino

@@ -14,12 +14,36 @@
  * This is a good diagnostic tool to check whether you're picking a
  * good channel for your application.
  *
- * Run this sketch on two devices. On one device, start CCW output by sending a 'g'
- * character over Serial. The other device scanning should detect the output of the sending
- * device on the given channel. Adjust channel and output power of CCW below.
+ * Run this sketch on two devices. On one device, start emitting a constant carrier wave
+ * by sending a channel number in the Serial Monitor. The other device scanning should
+ * detect the constant carrier wave from the sending device on the given channel.
+ * Send a negative number in the Serial Monitor to stop emitting a constant carrier wave
+ * and resume scanning.
  *
  * Inspired by cpixip.
- * See http://arduino.cc/forum/index.php/topic,54795.0.html
+ * See https://forum.arduino.cc/t/poor-mans-2-4-ghz-scanner/54846
+ *
+ * See documentation at https://nRF24.github.io/RF24
+ */
+
+/*
+ * How to read the output:
+ * - The header is a list of supported channels in decimal written vertically.
+ * - Each column corresponding to the vertical header is a hexadecimal count of
+ * detected signals (max is 15 or 'f').
+ *
+ * The following example
+ * 000
+ * 111
+ * 789
+ * ~~~ <- just a divider between the channel's vertical labels and signal counts
+ * 1-2
+ * can be interpreted as
+ * - 1 signal detected on channel 17
+ * - 0 signals (denoted as '-') detected on channel 18
+ * - 2 signals detected on channel 19
+ *
+ * Each line of signal counts represent 100 passes of the supported spectrum.
  */
 
 #include "RF24.h"
@@ -38,76 +62,112 @@ RF24 radio(CE_PIN, CSN_PIN);
 // Channel info
 //
 
-const uint8_t num_channels = 126;
-uint8_t values[num_channels];
+const uint8_t num_channels = 126; // 0-125 are supported
+uint8_t values[num_channels]; // the array to store summary of signal counts per channel
+
+// To detect noise, we'll use the worst addresses possible (a reverse engineering tactic).
+// These addresses are designed to confuse the radio into thinking
+// that the RF signal's preamble is part of the packet/payload.
+const uint8_t noiseAddress[][2] = { { 0x55, 0x55 }, { 0xAA, 0xAA }, { 0xA0, 0xAA }, { 0xAB, 0xAA }, { 0xAC, 0xAA }, { 0xAD, 0xAA } };
+
+const int num_reps = 100; // number of passes for each scan of the entire spectrum
+bool constCarrierMode = 0; // this flag controls example behavior (scan mode is default)
+
+void printHeader(); // prototype function for printing the channels' header
 
-//
-// Setup
-//
 
 void setup(void) {
- //
- // Print preamble
- //
 
+ // Print preamble
  Serial.begin(115200);
- printf_begin();
- Serial.println(F("\n\rRF24/examples/scanner/"));
+ while (!Serial) {
+ // some boards need this to wait for Serial connection
+ }
+ Serial.println(F("RF24/examples/scanner/"));
 
- //
  // Setup and configure rf radio
- //
+ if (!radio.begin()) {
+ Serial.println(F("radio hardware not responding!"));
+ while (true) {
+ // hold in an infinite loop
+ }
+ }
+ radio.stopConstCarrier(); // in case MCU was reset while radio was emitting carrier wave
+ radio.setAutoAck(false); // Don't acknowledge arbitrary signals
+ radio.disableCRC(); // Accept any signal we find
+ radio.setAddressWidth(2); // A reverse engineering tactic (not typically recommended)
+ for (uint8_t i = 0; i < 6; ++i) {
+ radio.openReadingPipe(i, noiseAddress[i]);
+ }
 
- radio.begin();
- radio.setAutoAck(false);
+ // set the data rate
+ Serial.print(F("Select your Data Rate. "));
+ Serial.print(F("Enter '1' for 1 Mbps, '2' for 2 Mbps, '3' for 250 kbps. "));
+ Serial.println(F("Defaults to 1Mbps."));
+ while (!Serial.available()) {
+ // wait for user input
+ }
+ uint8_t dataRate = Serial.parseInt();
+ if (dataRate == 50) {
+ Serial.println(F("Using 2 Mbps."));
+ radio.setDataRate(RF24_2MBPS);
+ } else if (dataRate == 51) {
+ Serial.println(F("Using 250 kbps."));
+ radio.setDataRate(RF24_250KBPS);
+ } else {
+ Serial.println(F("Using 1 Mbps."));
+ radio.setDataRate(RF24_1MBPS);
+ }
+ Serial.println(F("***Enter a channel number to emit a constant carrier wave."));
+ Serial.println(F("***Enter a negative number to switch back to scanner mode."));
 
  // Get into standby mode
  radio.startListening();
  radio.stopListening();
- radio.printDetails();
-
- //delay(1000);
- // Print out header, high then low digit
- int i = 0;
- while (i < num_channels) {
- Serial.print(i >> 4, HEX);
- ++i;
- }
- Serial.println();
- i = 0;
- while (i < num_channels) {
- Serial.print(i & 0xf, HEX);
- ++i;
- }
- Serial.println();
- //delay(1000);
-}
+ radio.flush_rx();
 
-//
-// Loop
-//
+ // printf_begin();
+ // radio.printPrettyDetails();
+ // delay(1000);
 
-const int num_reps = 100;
-bool constCarrierMode = 0;
+ // Print out vertical header
+ printHeader();
+}
 
 void loop(void) {
  /****************************************/
- // Send g over Serial to begin CCW output
- // Configure the channel and power level below
+ // Send a number over Serial to begin Constant Carrier Wave output
+ // Configure the power amplitude level below
  if (Serial.available()) {
- char c = Serial.read();
- if (c == 'g') {
+ int8_t c = Serial.parseInt();
+ if (c >= 0) {
+ c = min(125, max(0, c)); // clamp channel to supported range
  constCarrierMode = 1;
  radio.stopListening();
  delay(2);
- Serial.println("Starting Carrier Out");
- radio.startConstCarrier(RF24_PA_LOW, 40);
- } else if (c == 'e') {
+ Serial.print("\nStarting Carrier Wave Output on channel ");
+ Serial.println(c);
+ // for non-plus models, startConstCarrier() changes address on pipe 0 and sets address width to 5
+ radio.startConstCarrier(RF24_PA_LOW, c);
+ } else {
  constCarrierMode = 0;
  radio.stopConstCarrier();
- Serial.println("Stopping Carrier Out");
+ radio.setAddressWidth(2); // reset address width
+ radio.openReadingPipe(0, noiseAddress[0]); // ensure address is looking for noise
+ Serial.println("\nStopping Carrier Wave Output");
+ printHeader();
+ }
+
+ // discard any CR and LF sent
+ while (Serial.peek() != -1) {
+ if (Serial.peek() == '\r' || Serial.peek() == '\n') {
+ Serial.read();
+ } else { // got a charater that isn't a line feed
+ break; // handle it on next loop() iteration
+ }
  }
  }
+
  /****************************************/
 
  if (constCarrierMode == 0) {
@@ -125,27 +185,52 @@ void loop(void) {
  // Listen for a little
  radio.startListening();
  delayMicroseconds(128);
+ bool foundSignal = radio.testRPD();
  radio.stopListening();
 
- // Did we get a carrier?
- if (radio.testCarrier()) {
+ // Did we get a signal?
+ if (foundSignal || radio.testRPD() || radio.available()) {
  ++values[i];
+ radio.flush_rx(); // discard packets of noise
  }
  }
  }
 
-
  // Print out channel measurements, clamped to a single hex digit
- int i = 0;
- while (i < num_channels) {
+ for (int i = 0; i < num_channels; ++i) {
  if (values[i])
  Serial.print(min(0xf, values[i]), HEX);
  else
  Serial.print(F("-"));
-
- ++i;
  }
  Serial.println();
 
- } //If constCarrierMode == 0
-}
+ } // if constCarrierMode == 0
+ else {
+ // show some output to prove that the program isn't bricked
+ Serial.print(F("."));
+ delay(1000); // delay a second to keep output readable
+ }
+} // end loop()
+
+void printHeader() {
+ // Print the hundreds digits
+ for (int i = 0; i < num_channels; ++i)
+ Serial.print(i / 100);
+ Serial.println();
+
+ // Print the tens digits
+ for (int i = 0; i < num_channels; ++i)
+ Serial.print((i % 100) / 10);
+ Serial.println();
+
+ // Print the singles digits
+ for (int i = 0; i < num_channels; ++i)
+ Serial.print(i % 10);
+ Serial.println();
+
+ // Print the header's divider
+ for (int i = 0; i < num_channels; ++i)
+ Serial.print(F("~"));
+ Serial.println();
+}