Lecture 06 · Digital temperature sensing

1Where Lab 6 Sits

Lab 4 and Lab 5 were about moving power around: a pin commands, a transistor switches, a motor turns. The MCP9808 is the opposite kind of device. It draws so little current that its V_DD pin connects directly to the Pi's 3.3 V supply — no driver, no separate supply, no flyback diode.

What is difficult this week is not the power, it is the conversation. Until now every pin meant one thing: high or low, on or off. From this week a pin carries a protocol — a shared agreement about when a bit is valid, how a device is addressed, and how it says yes. Lab 6 is also, as the handout says plainly, a practical exercise in reading a datasheet, and that is a skill this course is deliberately building.

1.1  Task map

2Parallel and Serial Communication

2.1  Two ways to move a byte

To move eight bits from one chip to another there are two obvious schemes.

Parallel: use eight wires, one per bit, and send D7 through D0 all at once. One clock tick moves a whole byte.

Serial: use one wire and send the bits one after another, most significant first. Eight ticks move a byte.

2.2  So which is faster?

Intuitively parallel should win by a factor of eight. The history says otherwise, and the comparison is worth remembering:

The serial interface replaced the parallel one and is several times faster. The same story repeats everywhere: USB replaced the parallel printer port, PCI Express replaced PCI, serial Ethernet replaced parallel backplanes.

This matters for the rest of the course. Every sensor from here on — the MCP9808 this week, the LIS3DH in Lab 7, the MCP3008 in Lab 8 — uses two or four wires instead of eight or sixteen, and that is why several of them can share the same header.

3Asynchronous and Synchronous

Serial links divide into two families by how the receiver knows when to sample.

UART is how your laptop talks to a microcontroller over USB, and it is worth knowing that a “USB serial” connection is a UART with a protocol converter in the cable or on the board. On Windows it appears as a COM port in Device Manager; on macOS and Linux it appears as a device file. On the Pi you will use a terminal or VS Code rather than a separate terminal emulator.

Lab 6 uses I²C; Lab 8 uses SPI. Both are synchronous, and comparing them is a natural report discussion.

4The I²C Bus

I²C — Inter-Integrated Circuit — needs exactly two signal wires no matter how many devices are attached:

• SDA — serial data
• SCL — serial clock

Every device connects to the same two lines, in parallel. A controller (the Raspberry Pi) starts every transaction and generates the clock; each peripheral has an address and answers only when called. A temperature sensor, an accelerometer, a display and a real-time clock can all share those two wires — which is exactly what happens in Lab 7, where the MCP9808 joins the LIS3DH on the same bus.

4.1  Open drain, pull-ups, and why the bus is active low

This is the piece of I²C that explains the rest of it, so it is worth getting straight.

Every device connects to SDA and SCL through an open-drain output: a transistor that can pull the line down to ground, but has no ability to drive it up. Pulling the line high is the job of the pull-up resistors — one on SDA, one on SCL, both to V_DD = 3.3 V.

The pull-up value is a compromise. Too large, and the rise time is slow because the resistor must charge the bus capacitance, rounding the edges and limiting the clock rate. Too small, and the current when a device pulls low becomes excessive. A few kilohms is typical.

5I²C Timing

Four events define the protocol. All of them are about the relationship between SDA and SCL, never about either line alone.

5.1  START and STOP

5.2  When data is valid

5.3  The ninth bit: ACK and NAK

Every byte on an I²C bus is nine clock pulses, not eight. After the eight data bits, the transmitter releases SDA and issues one more clock, during which the receiver answers:

Notice that a low means yes. That is the active-low convention of §4.1 again: acknowledging takes deliberate effort — a device must pull the line down — whereas silence leaves the pull-up resistor to produce a high. An absent, misaddressed or dead device therefore returns NAK automatically, simply by doing nothing.

5.4  A complete register read

Reading a register from an I²C sensor takes two phases in one transaction, which is exactly what the repeated START is for:

1. START
2. Send the 7-bit device address with the write bit, so the sensor listens — then ACK
3. Send the register address you want (this is the “pointer”) — then ACK
4. Repeated START
5. Send the same device address with the read bit — then ACK
6. Read the first data byte — the controller sends ACK to say “another, please”
7. Read the second data byte — the controller sends NAK to say “that is enough”
8. STOP

Step 6 and 7 are worth pausing on: the ACK after the first byte is what tells the sensor to keep going, and the NAK after the second is what ends the read. The MCP9808's registers are 16 bits wide, so a temperature read is exactly two bytes — a high byte and a low byte.

In your program a library performs all of this in one call, but knowing the sequence is what lets you interpret a logic-analyser trace, and it is why the transaction can fail in several distinct ways.

6Device Addressing

The first byte after START carries a 7-bit device address in bits 7–1, with bit 0 as the direction flag:

6.1  The address pins

The MCP9808's three address pins A2, A1 and A0 occupy bits 3, 2 and 1 of the address byte, and are pulled low by default — giving 000 and therefore the base address 0x18. Tying them high in the eight possible combinations gives eight addresses, 0x18 through 0x1F, so eight of these sensors can share one bus.

Leave them unconnected for this lab. Their existence is worth understanding, though: it is the standard answer to “what if I need two of the same chip?”, and it is why an address collision between two different chip types is a real design constraint.

7The MCP9808

Inside the package are four blocks, and the datasheet describes each one:

1. An analog temperature sensor — a bandgap circuit whose output voltage depends on absolute temperature.
2. An ADC that digitises it.
3. A set of registers holding the result, the configuration, and the alert limits.
4. An I²C interface giving access to those registers.

This is the general shape of every modern digital sensor, and recognising it is more useful than memorising any one part. In Lab 7 the LIS3DH has exactly the same architecture with an accelerometer at the front; in Lab 8 the MCP3008 is essentially block 2 on its own, exposed over SPI.

7.1  The breakout board and its four wires

Only four connections are needed:

The remaining breakout pins — Alert, A0, A1, A2 — are left unconnected. Alert is an open-drain output the sensor can assert when a temperature limit is crossed, which is a hardware alternative to the software threshold you will implement in Task 4.

8The Register Map

All communication with the MCP9808 is reading from, or writing to, a numbered 16-bit register. The register address is a single byte — the “pointer” of §5.4 — and the data is two bytes.

8.1  The configuration register

Register 0x01 is 16 bits of behaviour settings. Lab 6 does not require you to change it, but reading the bit map is good datasheet practice and explains what the sensor can do:

9The Ambient Temperature Register

Register 0x05 is where Task 3 lives. Its sixteen bits are not a plain integer — the top four are flags and the bottom twelve are a fixed-point number.

10Decoding a Temperature

The register arrives as two bytes: an upper byte (bits 15–8) and a lower byte (bits 7–0). The decoding differs above and below zero, and Task 3 requires both to be right.

10.1  Positive temperatures

10.2  Negative temperatures

When bit 12 is set, the twelve magnitude bits hold a two's complement value, and simply reading them as a positive number gives nonsense. Two equivalent routes work:

• Subtract from the range. Assemble the raw value as though it were positive, then subtract it from the full range — the “256 − value” step in the example below — and negate.
• Test the sign bit. If bit 12 is set, subtract the full scale from the assembled value directly. This is the more idiomatic approach in Python and generalises to other sensors, including the LIS3DH in Lab 7.

11Resolution and Conversion Time

Register 0x08 selects how finely the ADC resolves, and there is a direct cost in speed:

The conversion time also sets a floor on sampling rate. Task 4 asks for readings every 0.2 s, which is 200 ms — comfortably longer than the 130 ms conversion but not enormously so. Poll much faster than the conversion time and you simply re-read the same value, producing a plot with visible flat steps. If you see stair-stepping in your data, this is why, and saying so is a good observation.

12Bringing the Bus Up

Task 1 and the start of Task 2 are pure system setup. None of it needs an internet connection.

# 1. Enable the I2C interface: Interface Options -> I2C -> <Yes>, then reboot
sudo raspi-config

# 2. After the reboot, confirm the bus device exists
ls /dev/i2c-*

# 3. Scan bus 1 for devices. The MCP9808 appears as 18.
i2cdetect -y 1

# 4. Read a register directly from the command line -- no Python needed.
#    Device 0x18, register 0x06 (manufacturer ID), word read.
#    Note: i2cget returns a word byte-swapped; 0x5400 here means 0x0054.
i2cget -y 1 0x18 0x06 w

13From a Reading to a Dataset

Task 4 turns a working sensor into an experiment. Each part is small; together they are the standard shape of a data-acquisition program.

13.1  Unit conversion

Label both values with units in the output. An unlabelled column of numbers is the most common presentation fault in lab reports, and it costs marks for no good reason.

13.2  The threshold warning

Task 4 asks for a critical temperature — 28 °C is suggested — above which the program prints a distinct warning. Put the threshold in a named constant at the top of the file rather than burying the number in a comparison, so you can demonstrate it by touching the sensor and, if the room is warm, retune it in one place.

Worth noticing: the MCP9808 can do this in hardware. Registers 0x02–0x04 hold the limits, bits 15–13 of the temperature register report the comparisons, and the Alert pin can be asserted without the Pi involved at all. Your software check and the sensor's hardware alert are two solutions to the same problem — and contrasting them is a genuinely good discussion point.

13.3  Logging, plotting and the CSV

The requirements are 100+ measurements, elapsed time in seconds since the program started, a plot with a smooth line and individual markers, a title and labelled axes with units, a horizontal dashed line at the threshold, and a temp_data.csv with the headers “Time (s)” and “Temperature (C)”.

13.4  The optional live plot

For extra credit, the plot updates in real time and scrolls to show the most recent N seconds. The idea is to update the data behind an existing plot rather than redrawing the figure each time — redrawing from scratch is what makes naive live plots slow and jerky. Keep a fixed-length buffer of the most recent points, and set the x-limits from the newest timestamp so the window scrolls. The repository's existing animated temperature-plotting scripts are a reasonable place to look for the pattern.

14Common Mistakes and Debugging

14.1  Things that damage hardware

• V_DD and GND swapped. Destroys the sensor immediately. Check twice before powering on.
• 5 V to the sensor's V_DD. Puts 5 V logic on the Pi's I²C lines, which are 3.3 V only and not tolerant.
• Wiring a live bus. Power the Pi down first, as Task 2 instructs.

14.2  A debugging order that works

1. Does /dev/i2c-1 exist? No → enable I²C and reboot.
2. Does i2cdetect -y 1 show 18? No → it is a wiring or power fault, not a code fault.
3. Does the manufacturer ID read back as 0x0054? No → byte order or library usage. Yes → the whole chain works and the problem is in your decoding.
4. Does the raw register look plausible? Print the two bytes in hex before converting. Compare against §10 by hand.
5. Does the decoding handle both signs? Feed it the two known byte pairs from §10.

14.3  Things that waste your afternoon

• SDA and SCL swapped. Nothing is damaged, and nothing is detected.
• 7-bit versus 8-bit address confusion (§6).
• Byte order reversed when combining the two bytes into a 16-bit value — the number moves wildly for tiny temperature changes.
• Forgetting to mask off bits 15–13 before arithmetic. The flags are usually zero at room temperature, so this bug hides until you set a limit register or the temperature crosses one.
• Sampling faster than the conversion time and wondering why the data is stair-stepped (§11).
• Warming the sensor with a finger and expecting instant response — the package has thermal mass and takes seconds.
• Loose breadboard jumpers. Intermittent I²C failures are very often mechanical.

14.4  Before you leave

Copy your scripts, the CSV and the plots to your own computer; verify they open there; then remove your directory from the shared Pi and shut down cleanly.

15Self-Check

1. Give three reasons a serial link can outperform a parallel one, and cite the PATA/SATA numbers.
2. What distinguishes an asynchronous link from a synchronous one? Which family does I²C belong to, and what does that spare you from configuring?
3. Why are the pull-up resistors mandatory on an I²C bus, and what would happen without them?
4. Describe the START and STOP conditions in terms of SDA and SCL. Why can neither be mistaken for data?
5. During data transfer, when is SDA permitted to change, and when does the receiver sample?
6. On the ninth clock, what does a low SDA mean? Why does a missing device automatically produce the opposite?
7. The MCP9808's address is 0x18. Write the full first byte for a read and for a write, in binary and hex.
8. List the bit fields of the ambient temperature register: which bits are flags, which is the sign, which are integer, which are fractional?
9. Decode upper = 0xC1, lower = 0x1C. Then decode upper = 0x3E, lower = 0xFC.
10. Which two registers hold fixed known constants, what are they, and how does that help you debug?
11. Distinguish the sensor's configured resolution from the resolution your decoding reports. Which does Task 3 concern?
12. Why does sampling every 50 ms at the finest resolution setting not give you finer time detail?

16Practical Engineering Connections

1. I²C everywhere. Laptop battery gauges, monitor identification (EDID over I²C), phone sensor hubs, server temperature monitoring and camera modules all use this bus. It is roughly forty years old and completely unavoidable.
2. Serial beat parallel. SATA over PATA, USB over the parallel port, PCI Express over PCI, HDMI over VGA — the same engineering argument each time.
3. Register-based devices. Almost every modern peripheral — sensors, radios, power controllers, displays — is a set of numbered registers behind a serial interface. Learn the pattern once and every new datasheet gets easier.
4. Fixed-point arithmetic. The MCP9808's integer-plus-fraction format is how embedded systems represent non-integers without floating-point hardware, and it appears in audio codecs, motor controllers and DSP throughout.
5. Two's complement. The negative-temperature handling is the same representation every processor uses for signed integers, and the same trap appears with every signed sensor — including the accelerometer in Lab 7.
6. Resolution versus speed. The trade in register 0x08 is universal to ADCs: more bits take longer. You will meet it again directly in Lab 8.
7. Hardware alerts. The Alert pin lets a sensor interrupt a processor instead of being polled — the basis of low-power design, where a device sleeps until something happens.
8. Known-value debugging. Reading an ID register to prove the channel works before trusting the data is the same discipline as a calibration standard, a checksum or a test pattern. It is how experienced engineers avoid debugging two things at once.

PHYS 351 · Lecture 06 Notes · © Ran Yang, Ph.D. · yangran.org/teaching/phys351/