formatting

hardware/3D_printing/antenna_mount.scad

@@ -1,5 +1,5 @@
 wave_length=125/2;
-antenna_width=10;
+antenna_width=10-0.2;
 antenna_stalk_width=10-0.25;
 antenna_base_length=23;
 
@@ -9,7 +9,8 @@ height=antenna_width+8;
 ziptie_width=3.5;
 ziptie_depth=2.5;
 
-screw_r=5.5/2;
+dry_screw_r=5.5/2; //dry wall
+screw_r=3.5/2; //m3
 backing=2;
 edges=2;
 
@@ -75,8 +76,8 @@ difference() {
 
 rotate([0,0,tx_theta]) antenna_cutout();
 
-k1=antenna_width/2+ziptie_depth+(screw_r+backing);
-k2=wave_length/2+antenna_base_length-screw_r*2;
+k1=antenna_width/2+ziptie_depth+(dry_screw_r+backing);
+k2=wave_length/2+antenna_base_length-dry_screw_r*2;
 translate([k1,-k2,0]) screw_hold();
 translate([-k1,k2,0]) screw_hold();
 translate([k2,-k1,0]) screw_hold();

spf/baseline_algorithm.py

@@ -50,9 +50,7 @@ def get_top_n_points(
     line_representations, n, width, threshold=3, mn=4, lines_per_step=2
 ):
     final_points = []
-    line_to_point_assignments = (
-        np.zeros(len(line_representations), dtype=int) - 1
-    )
+    line_to_point_assignments = np.zeros(len(line_representations), dtype=int) - 1
     line_to_point_distances = np.zeros(len(line_representations), dtype=int) - 1
     for point_idx in range(n):
         img = np.zeros((width + 1, width + 1))
@@ -77,12 +75,9 @@ def get_top_n_points(
                         )
                         if (
                             line_to_point_assignments[line_idx] == -1
-                            or distance_to_line
-                            < line_to_point_distances[line_idx]
+                            or distance_to_line < line_to_point_distances[line_idx]
                         ):
-                            line_to_point_assignments[line_idx] = (
-                                len(final_points) - 1
-                            )
+                            line_to_point_assignments[line_idx] = len(final_points) - 1
                             line_to_point_distances[line_idx] = distance_to_line
                 if (
                     line_to_point_assignments[line_idx] == -1
@@ -179,9 +174,7 @@ def lines_to_points(lines, t):
         rng = np.random.default_rng(12345 + line_idx_a * 1337)
         a_i, a_m, (x1, y1), _ = lines[line_idx_a]
         points_for_this_line = []
-        for line_idx_b in rng.choice(
-            np.arange(t), size=min(30, t), replace=False
-        ):
+        for line_idx_b in rng.choice(np.arange(t), size=min(30, t), replace=False):
             if line_idx_b >= len(lines):
                 continue
             if line_idx_a == line_idx_b:

spf/grbl/grbl_interactive.py

@@ -42,7 +42,7 @@
 
 
 def a_to_b_in_stepsize(a, b, step_size):
-    if np.isclose(a,b).all():
+    if np.isclose(a, b).all():
         return [b]
     # move by step_size from where we are now to the target position
     points = [a]
@@ -104,7 +104,7 @@ def to_steps(self, p):
         if (self.polygon is not None) and not self.polygon.contains_point(
             p, radius=0.01
         ):  # todo a bit hacky but works
-            print("OUT OF BOUNDS",p)
+            print("OUT OF BOUNDS", p)
             raise ValueError
         # motor_steps = ( distance_between_pivot and point ) - (distance between pivot and calibration point)
         a_motor_steps = np.linalg.norm(self.pA - p) - np.linalg.norm(
@@ -123,13 +123,9 @@ def binary_search_edge(self, left, right, xy, direction, epsilon):
         try:
             steps = self.to_steps(p)
             # actual = self.from_steps(*steps)
-            return self.binary_search_edge(
-                midpoint, right, xy, direction, epsilon
-            )
+            return self.binary_search_edge(midpoint, right, xy, direction, epsilon)
         except ValueError:
-            return self.binary_search_edge(
-                left, midpoint, xy, direction, epsilon
-            )
+            return self.binary_search_edge(left, midpoint, xy, direction, epsilon)
 
     def get_boundary_vector_near_point(self, p):
         if self.polygon is None:
@@ -167,13 +163,10 @@ def get_bounce_pos_and_new_direction(self, p, direction):
 
         # parallel component stays the same
         # negatate the perpendicular component
-        bvec = self.dynamics.get_boundary_vector_near_point(
-            last_point_before_bounce
-        )
+        bvec = self.dynamics.get_boundary_vector_near_point(last_point_before_bounce)
         bvec_perp = np.array([bvec[1], -bvec[0]])
         new_direction = (
-            np.dot(direction, bvec) * bvec
-            - np.dot(direction, bvec_perp) * bvec_perp
+            np.dot(direction, bvec) * bvec - np.dot(direction, bvec_perp) * bvec_perp
         )
         new_direction /= np.linalg.norm(new_direction)
         return last_point_before_bounce, new_direction
@@ -190,9 +183,7 @@ def single_bounce(self, direction, p, step_size=5):
         percent_random = 0.05
         new_direction = (
             1 - percent_random
-        ) * new_direction + percent_random * np.array(
-            [np.sin(theta), np.cos(theta)]
-        )
+        ) * new_direction + percent_random * np.array([np.sin(theta), np.cos(theta)])
 
         return to_points, new_direction
 
@@ -255,9 +246,7 @@ def update_status(self, skip_write=False):
         try:
             motor_position_str = response.split("|")[1]
         except Exception as e:
-            print(
-                "FAILED TO PARSE", response, "|e|", e, time.time() - start_time
-            )
+            print("FAILED TO PARSE", response, "|e|", e, time.time() - start_time)
             return self.update_status(skip_write=not skip_write)
         b0_motor_steps, a0_motor_steps, b1_motor_steps, a1_motor_steps = map(
             float, motor_position_str[len("MPos:") :].split(",")
@@ -292,24 +281,19 @@ def wait_while_moving(self):
                 return
             time.sleep(0.01)
 
-    def move_to(
-        self, points
-    ):  # takes in a list of points equal to length of map
+    def move_to(self, points):  # takes in a list of points equal to length of map
         gcode_move = ["G0"]
         for c in points:
             motors = self.channel_to_motor_map[c]
             a_motor_steps, b_motor_steps = self.dynamics.to_steps(points[c])
             gcode_move += [
-                "%s%0.2f %s%0.2f"
-                % (motors[0], b_motor_steps, motors[1], a_motor_steps)
+                "%s%0.2f %s%0.2f" % (motors[0], b_motor_steps, motors[1], a_motor_steps)
             ]
         cmd = " ".join(gcode_move)
         time.sleep(0.01)
         self.s.write((cmd + "\n").encode())  # Send g-code block to grbl
         time.sleep(0.01)
-        grbl_out = (
-            self.s.readline()
-        )  # Wait for grbl response with carriage return
+        grbl_out = self.s.readline()  # Wait for grbl response with carriage return
         time.sleep(0.01)
         # print("MOVE TO RESPONSE", grbl_out)
 

spf/grbl/mm_per_step.py

@@ -7,9 +7,7 @@
 steps_per_revolution = 360 / degrees_per_step
 micro_stepping = 16
 steps_per_mm = (
-    micro_stepping
-    * steps_per_revolution
-    / (teeth_per_revolution * spacing_per_tooth)
+    micro_stepping * steps_per_revolution / (teeth_per_revolution * spacing_per_tooth)
 )
 
 

spf/grbl_sdr_collect.py

@@ -154,9 +154,7 @@ def bounce_grbl(gm):
         signal_matrix[1] *= np.exp(1j * sdr_rx.phase_calibration)
         current_time = time.time() - time_offset  # timestamp
 
-        beam_thetas, beam_sds, beam_steer = beamformer(
-            pos, signal_matrix, args.fc
-        )
+        beam_thetas, beam_sds, beam_steer = beamformer(pos, signal_matrix, args.fc)
 
         avg_phase_diff = get_avg_phase(signal_matrix)
         xy = gm.position["xy"]

spf/model_training_and_inference/01_generate_data.py

@@ -15,9 +15,7 @@
     parser.add_argument(
         "--carrier-frequency", type=float, required=False, default=2.4e9
     )
-    parser.add_argument(
-        "--signal-frequency", type=float, required=False, default=100e3
-    )
+    parser.add_argument("--signal-frequency", type=float, required=False, default=100e3)
     parser.add_argument(
         "--sampling-frequency", type=float, required=False, default=10e6
     )
@@ -29,12 +27,8 @@
         choices=["linear", "circular"],
     )
     parser.add_argument("--elements", type=int, required=False, default=11)
-    parser.add_argument(
-        "--random-silence", type=bool, required=False, default=False
-    )
-    parser.add_argument(
-        "--detector-noise", type=float, required=False, default=1e-4
-    )
+    parser.add_argument("--random-silence", type=bool, required=False, default=False)
+    parser.add_argument("--detector-noise", type=float, required=False, default=1e-4)
     parser.add_argument(
         "--random-emitter-timing", type=bool, required=False, default=False
     )
@@ -52,20 +46,12 @@
         default="bounce",
         choices=["orbit", "bounce"],
     )
-    parser.add_argument(
-        "--detector-speed", type=float, required=False, default=10.0
-    )
-    parser.add_argument(
-        "--source-speed", type=float, required=False, default=0.0
-    )
+    parser.add_argument("--detector-speed", type=float, required=False, default=10.0)
+    parser.add_argument("--source-speed", type=float, required=False, default=0.0)
     parser.add_argument("--sigma", type=float, required=False, default=1.0)
     parser.add_argument("--time-steps", type=int, required=False, default=100)
-    parser.add_argument(
-        "--time-interval", type=float, required=False, default=0.3
-    )
-    parser.add_argument(
-        "--samples-per-snapshot", type=int, required=False, default=3
-    )
+    parser.add_argument("--time-interval", type=float, required=False, default=0.3)
+    parser.add_argument("--samples-per-snapshot", type=int, required=False, default=3)
     parser.add_argument("--sessions", type=int, required=False, default=1024)
     parser.add_argument(
         "--output", type=str, required=False, default="sessions-default"
@@ -74,9 +60,7 @@
     parser.add_argument("--cpus", type=int, required=False, default=8)
     parser.add_argument("--live", type=bool, required=False, default=False)
     parser.add_argument("--profile", type=bool, required=False, default=False)
-    parser.add_argument(
-        "--fixed-detector", type=float, required=False, nargs="+"
-    )
+    parser.add_argument("--fixed-detector", type=float, required=False, nargs="+")
 
     args = parser.parse_args()