Decode the structure and language of the Apple logic board schematic

A simple circuit fits on one page. But an Apple logic board carries hundreds of chips and thousands of connections — so the schematic is multi-page (iPhone X = 85 sheets). What doesn't fit in a single picture is split into an organized document:

• Table of contents (ToC): Which block is on which page? Like 'charging sheet 23, NAND sheet 16'. You go to the block you're looking for from here — the first stop before diving into the circuit.
• Sheets: Each page is a block/function (power, SOC, camera...). In its corner there is a title block (page name + number).
• Testpoint / probe pages: A map of the points to be measured — useful in the MEASURE step.
• Bootstrapping / config page: BOM options, fuse/variant settings — the board's 'personalization' notes.

The most critical point — how pages connect: A net (signal/rail) can start on one page and continue on another. This is managed by the off-page connector (off-page connection arrow) and the cross-reference page number beside it: 'this trace comes from sheet 17 / goes to sheet 40.'

Today's question: If we decode the structure (map) and the language (alphabet + grammar) of this document, can we find our way even on a page we don't know?

Multi-page + cross-reference is the foundation of tomorrow's trace following: following a trace from both ends becomes possible across pages through these arrows.

Each part has two labels: a name (designator) and a value. The first letter of the designator tells the type of the part — this is universal and standard:

Each name is unique (R1, R2, R3...) and is the address for finding that part on the board. The value is the part's most important property: ohms for a resistor, farads for a capacitor, the chip name for an IC, frequency for a crystal.

How you see this on an Apple board (real iPhone X examples):

• U1000 = an IC (the A11 processor). U2700 = an IC (PMU).
• J3200 = a connector (battery). J5700 = connector (display).
• Y1000 = a crystal (24 MHz). L6110 = a coil (0.47 µH). Q3350 = a transistor (BATFET).
• R5901 = a resistor. C... = capacitor.

Reading tip: When you see a designator, first read the letter — you instantly know the part type (U=chip, J=connector, L=coil). Since the IC symbol is always the same (a pinned rectangle), what identifies an IC is the designator + value (chip name). The designator points to the same part in the schematic, in the boardview, and on the physical board — the address that links the three worlds.

Net = an electrical node connecting two (or more) terminals to each other; shown with a line in the schematic. Two rules:

• Node/dot: At a crossing of two lines, if there is a dot they are connected; if there is no dot the wires just pass over each other and are not connected. This distinction is critical.
• Net name/label — the most important rule: Nets with the same name are connected to each other even if there is no visible wire between them. Instead of drawing everything with wires in a complex schematic, a net is given a name; every place carrying the same name is the same net.

Nets are named by their function (SparkFun example: VCC, 5V, RX, TX). On an Apple board this language is richer:

• Power rails start with PP_: PP_VDD_MAIN (the main backbone), PP3V0_NAND, PP_BATT_VCC. Voltage/function is read from the name.
• Signals by function: SPMI... (PMU communication), PCIE_AP_TO_BB (A11→baseband data).
• _L suffix = active-low: the signal is active when it is low (0) (e.g. ..._RESET_L resets when low). This suffix is very common at the board level.
• Ground (voltage node): GND/IOG — single-terminal symbol; every same-named ground is connected.

Reading tip — tomorrow's key: The 'same name = connected' rule means that a net appearing with the same name on sheet 5 and on sheet 40 is the same net. The off-page connector + cross-reference page number manages exactly this. That's why you can follow a trace across pages (tomorrow): you follow the net name, not the wire.

You've opened a schematic page you've never seen before. No panic; use the document and the language.

Step 1 — Locate yourself: Look at the page's title block (which block, which sheet number). If needed, go back to the ToC and see where this block fits.

Step 2 — Recognize the parts: Scan the designator letters — the U's (chips) are the page's 'players', the J's (connectors) are input/output, L/R/C are peripheral components. A large U is usually the page's main chip.

Step 3 — Read the nets: Look at the net names. Those starting with PP_ are power; those ending with _L are active-low; function names (RESET/CLK/DATA) tell the signal's job. Check whether there's a dot (connected) / no dot (not connected).

Step 4 — See the off-page: If a net goes toward the edge and ends with an off-page connector + cross-reference page number, that net continues on another page. Note its name — tomorrow you'll follow that name.

Step 5 — Summarize: 'This page describes this block; the main chip(s) are these; this net comes in here, that net goes to that page.' If you can describe the page in one sentence, you've found your way.

The essence of today — the map + language of the document:

• Document structure: An Apple schematic is multi-page (iPhone X = 85 sheets); ToC (which block is where) + sheets (each one a block) + testpoint pages + bootstrapping/config. Pages connect via off-page connector + cross-reference page number.
• Designator language: First letter = part type (R/C/L/D/Q/U/Y/J/S); name unique and the 'address'; value = the most important property (chip name for an IC). Apple: U1000/J3200/Y1000/L6110/Q3350.
• Net language: Line=net; dot=connected, dot-less crossing=not connected; same name = connected (even without a wire). Apple: PP_ power rails, _L active-low, function-named signals, GND/IOG ground.
• Finding your way: title block → designators (players) → net names (jobs) → off-page (where it goes).

You got to know the document and learned its language. Tomorrow we put this language into motion: following a net from both ends — from its source to its load — across pages. Today's 'same name = connected' rule is the very engine of that following.