Cat guard for plant pots

// A round grid that lies on the soil of a plant pot to keep cats out. Split into loose
// segments so it fits around an existing plant, with spikes underneath to pin it down.
// The grid pattern is plain rings and spokes, drawn in 2D from circles and straight
// rectangles; rounding is one offset pass over the finished drawing, as a final polish.

/* [Size] */
// Outer diameter of the guard. Match it to the inside of the pot.
diameter = 200; // [80:5:400]
// Diameter of the hole in the middle, around the stem.
hole_d = 40; // [10:2:200]
// Thickness of the plate.
thickness = 3; // [2:0.5:6]
// Width of the bars.
bar_w = 3; // [2:0.5:8]

/* [Grid] */
// Concentric rings, counting the rim around the hole and the outer rim.
rings = 4; // [2:1:10]
// Radial spokes in each segment.
spokes_per_segment = 4; // [2:1:10]

/* [Split] */
// Number of loose segments the guard is cut into.
segments = 4; // [2, 3, 4]
// Width of the cut between segments.
gap = 1; // [0.5:0.1:3]
// The whole guard, or one segment flipped into print orientation.
part = "all"; // [all, one]

/* [Spikes] */
// Length of the spikes below the plate. Zero removes them.
spike_len = 25; // [0:1:60]
// Width of a spike at its base.
spike_w = 4; // [2:0.5:10]
// A spike on every n-th ring, counted from the outer rim inward.
spike_ring_step = 2; // [1:1:5]
// A spike on every n-th spoke.
spike_spoke_step = 2; // [1:1:6]

/* [Polish] */
// Radius the bar corners are rounded to. Zero keeps them sharp.
round_r = 0.5; // [0:0.25:2]

/* [Quality] */
// Facets on the rings. More is smoother and slower.
smoothness = 96; // [32:16:192]

/* [Colour] */
// Display only, the STL carries no colour.
color_grid = "ForestGreen"; // [ForestGreen, Silver, Gainsboro, White, DimGray, Black, SlateGray, FireBrick, SteelBlue, Goldenrod]

/* [Hidden] */
hole = min(hole_d, diameter - 4 * bar_w - 10);
r_out = diameter / 2 - bar_w / 2;   // centre line of the outer rim
r_in = hole / 2 + bar_w / 2;         // centre line of the rim around the hole
spokes = segments * spokes_per_segment;
seg_a = 360 / segments;
r_polish = min(round_r, bar_w / 2 - 0.3);

// Ring i, with 0 the outer rim and rings-1 the rim around the hole.
function ring_r(i) = r_out - i * (r_out - r_in) / (rings - 1);
// Spoke j, half a pitch off the cuts so a cut never runs along a spoke.
function spoke_a(j) = (j + 0.5) * 360 / spokes;

// The polish: a closing pass rounds the concave corners, an opening pass the convex ones.
module polish2d(r) {
  if (r > 0)
    offset(r = r, $fn = 24) offset(r = -2 * r, $fn = 24) offset(r = r, $fn = 24) children();
  else
    children();
}

// ---- Grid pattern ----
// Swap this module for another pattern; everything else keeps working as long as it
// stays inside the disc and leaves the hole open.
module grid2d() {
  for (i = [0 : rings - 1])
    difference() {
      circle(r = ring_r(i) + bar_w / 2, $fn = smoothness);
      circle(r = ring_r(i) - bar_w / 2, $fn = smoothness);
    }
  for (j = [0 : spokes - 1])
    rotate(spoke_a(j))
      translate([hole / 2, -bar_w / 2]) square([(diameter - hole) / 2, bar_w]);
}

// The cuts that split the disc into segments.
module cuts2d() {
  for (k = [0 : segments - 1])
    rotate(k * seg_a) translate([0, -gap / 2]) square([diameter, gap]);
}

module plate() {
  linear_extrude(height = thickness)
    polish2d(r_polish) difference() { grid2d(); cuts2d(); }
}

// ---- Spikes ----
// Four-sided pyramids hanging below the plate at ring/spoke crossings.
module spike() {
  translate([0, 0, 0.5]) mirror([0, 0, 1]) rotate(45)
    cylinder(h = spike_len + 0.5, d1 = spike_w * sqrt(2), d2 = 0.8, $fn = 4);
}

module spikes() {
  if (spike_len > 0)
    for (i = [0 : rings - 1], j = [0 : spokes - 1])
      if (i % spike_ring_step == 0 && j % spike_spoke_step == 0)
        rotate(spoke_a(j)) translate([ring_r(i), 0, 0]) spike();
}

module guard() {
  plate();
  spikes();
}

// One segment: the wedge between the first two cuts.
module wedge() {
  linear_extrude(height = 2 * spike_len + 2 * thickness + 2, center = true)
    polygon(concat([[0, 0]], [for (a = [0 : 2 : seg_a]) (diameter / 2 + 5) * [cos(a), sin(a)]]));
}

// ---- Layout ----
if (part == "one") {
  // Flipped onto its plate side, spikes up: the print orientation.
  color(color_grid) rotate(-seg_a / 2) translate([0, 0, thickness]) mirror([0, 0, 1])
    intersection() { guard(); wedge(); }
} else {
  color(color_grid) guard();
}