aboutsummaryrefslogtreecommitdiff
path: root/module-design.typ
blob: d6e737b9670ab9d7cb389803aa2dbffc5d86d753 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#import "@preview/unify:0.8.1": numrange, qty, qtyrange

= Module design <module-design>

The preceding sections established what SAME is: its signal standards, precision
tiers, power distribution, and mechanical format. This section addresses how
SAME modules are designed to meet these specifications — particularly the
demanding requirements of the Metrologic tier.

The challenge is substantial. The Metrologic tier demands $qty(10, "ppm")$
precision, $qty(90, "dB")$ signal-to-noise ratio, and
$qty(0.014, "ppm per hour")$ drift over a DC to $qty(20, "kHz")$ bandwidth.
These specifications, taken together, require that a $qty(20, "V")$ signal range
be resolved to $qty(200, "uV")$, that noise remain below $qty(632, "uV") upright("RMS")$,
and that accumulated drift not exceed $qty(10, "ppm")$ over thirty days of
continuous operation. Achieving this with commodity through-hole components —
resistors, capacitors, and op-amps available from any electronics distributor —
would appear to be impossible. The tolerances of standard components are
measured in percent, not parts per million. The temperature coefficients of
common resistors would exhaust the entire drift budget in minutes, not months.

Yet it is possible. The gap between component specifications and system
requirements is bridged not by exotic parts but by topology: the deliberate
arrangement of ordinary components into configurations where their errors
cancel, track, or become irrelevant to the computation. A resistor's absolute
value may be uncertain to 1%, but its ratio to an adjacent resistor from the
same batch, at the same temperature, can be stable to $qty(10, "ppm")$. An
amplifier's offset voltage may drift by microvolts per degree, but a servo loop
can continuously measure and nullify that drift faster than it accumulates.
A multiplier's nonlinearity may be limited by transistor physics to
$qty(0.1, "percent")$, but encoding the multiplication in the time domain rather
than the amplitude domain sidesteps those physics entirely.

These techniques are not novel. They are the accumulated wisdom of precision
analog design, developed by metrologists and instrumentation engineers over
seven decades. What SAME contributes is their systematic application within
constraints that matter for sustainability and sovereignty: through-hole
construction that can be assembled and repaired with basic equipment, open
documentation that enables understanding rather than mere replication, and
component choices that will remain available as specific part numbers inevitably
become obsolete.

This section proceeds in six parts.
+ #ref(<module-design-terminology>) establishes terminology. Precision analog
  design has a specialized vocabulary; ambiguous terms lead to ambiguous
  analysis. We define our terms once, carefully, and use them consistently
  throughout.
+ #ref(<module-design-modules-categories>) categorizes the three types of SAME
  modules — Interface, Compute, and Control — and specifies the requirements
  particular to each category. Not all modules face identical constraints; a
  control module generating voltages from a front-panel knob operates under
  different rules than a compute module performing four-quadrant multiplication.
+ #ref(<error-budgeting-and-system-level-compensation>) develops the error
  budget framework. We enumerate every source of error in a precision analog
  signal path, quantify each source using commodity component specifications,
  and construct the naive error budget that results from conventional design.
  This budget exceeds our specifications by factors ranging from $11$ to $4000$.
  The purpose of this exercise is not despair but clarity: we must know
  precisely where the errors arise before we can systematically eliminate them.
+ #ref(<error-compensation-strategies>) presents the five fundamental
  compensation strategies that close the gap between naive and Metrologic
  performance. Each strategy is developed from physical principles, analyzed
  mathematically, and specified with design rules sufficient to implement it
  correctly.
+ #ref(<advanced-compensation-topologies>) extends these techniques for
  applications demanding performance beyond the base Metrologic specification.
  They can push precision into the 1-5ppm range for specialized applications.
  These techniques are optional — the base compensation strategies suffice for
  Metrologic tier — but they demonstrate that the approach has headroom.
+ #ref(<implicit-computation>) introduces implicit computation, a
  design philosophy where mathematical operations emerge from feedback
  equilibrium rather than explicit signal processing. Division, for example, can
  be implemented explicitly using logarithms (with their associated
  nonlinearity) or implicitly using a multiplier in a feedback loop (where the
  loop forces the quotient to whatever value satisfies the multiplication).
  Implicit designs often achieve superior precision because the feedback loop
  continuously corrects errors that would accumulate in an explicit signal
  chain.

The reader seeking to understand how the reference implementation in
#ref(<reference-implementation>) achieves its specifications, or to design new
modules, will find the theoretical foundation here. We make no apology for the
depth of what follows. Precision is not achieved by accident or by following
recipes without understanding. It is achieved by understanding the physics
deeply enough to make the physics work for you rather than against you.

== Terminology <module-design-terminology>

== Module categories <module-design-modules-categories>

== Error budgeting and system-level compensation
<error-budgeting-and-system-level-compensation>

== Error compensation strategies <error-compensation-strategies>

== Advanced compensation topologies <advanced-compensation-topologies>

== Implicit computation <implicit-computation>