Hey there, let's unpack your questions step by step—this is a super common point of confusion for folks new to embedded systems, so you’re in good company.

First, let's clarify a key detail your code implies but doesn’t show: TempLong is almost certainly a C union that lets you access the same block of memory as both a 32-bit ULONG and an array of 4 unsigned bytes. It probably looks something like this (even if it’s defined elsewhere in your codebase):

typedef union {
    ULONG Long;          // 32-bit value (matches your SPI read return type)
    unsigned char Byte[4]; // Split into 4 individual bytes
} LongByteUnion;

LongByteUnion TempLong;

1. How does Byte[] work, and why use index [0]? #

Unions in C let multiple variables share the same memory address. So when you assign a value to TempLong.Long, the Byte array directly maps to the raw bytes of that 32-bit value in memory.

The index [0] vs [1] depends entirely on your system’s endianness:

• Little-endian (most common in embedded systems like ARM): The least significant byte (LSB) of the 32-bit value is stored at the lowest memory address. So Byte[0] = LSB, Byte[1] = next byte up, Byte[3] = most significant byte (MSB).
• Big-endian: The MSB is stored at the lowest address, so Byte[0] would be the highest byte of the 32-bit value.

In your code, the check uses Byte[0] & 0x01—this means the code is assuming the status bit you care about (bit 0 of the watchdog status register) is in the first byte of the SPI read result (which aligns with little-endian, or with the SPI peripheral returning data starting from the LSB).

2. Why isn’t TempLong.Byte[0] matching 0x04 or 0x40? #

You’re mixing up two critical things:

• WDOG_STATUS is the register address (0x0440), not the value stored in that register.
• SPIReadRegisterIndirect(WDOG_STATUS, 1) reads the content of the register at address 0x0440, and stores that value in TempLong.Long.

When you print TempLong.Byte[0] and see 0, that means the lowest byte of the watchdog status register’s current value is 0. Looking at your code:

if ((TempLong.Byte[0] & 0x01) == 0x01) 
    WatchDog = 0;
else 
    WatchDog = 1;

This implies that bit 0 of the watchdog status register is 0 (so WatchDog gets set to 1). You’ll need to check your chip’s reference manual to find out exactly what bit 0 of the WDOG_STATUS register represents (e.g., "watchdog timeout detected" or "watchdog active").

3. Resources to learn more #

Here’s what I’d recommend for getting a solid grasp:

• C Union Basics: Pick up a good C programming book like C Primer Plus—its chapter on unions explains type punning clearly. The C standard (ISO/IEC 9899) also covers unions, but it’s pretty dry for beginners.
• Byte Order/Endianness: Look up tutorials on "little vs big endian for embedded systems"—most break this down with microcontroller-specific examples.
• Chip Reference Manual: This is non-negotiable! Your chip’s datasheet or technical reference manual (TRM) will tell you:
  • How registers are structured (which bits correspond to which status flags)
  • Whether the SPI peripheral returns data in little or big endian order
  • Exactly what each status bit in WDOG_STATUS and AL_STATUS means
• Embedded C Best Practices: Books like Embedded Systems Programming by Michael Barr dive into common tricks like union-based byte splitting, and when to use (and avoid) type punning.

内容的提问来源于stack exchange，提问作者Komorebi