I don't understand a line of code in an SPI driver

Question

uint32_t data;

SPDR = ((uint8_t*) & data)[x];

I can see what this line does - it can be put in a for loop to read each byte of "data" into SPDR, but I don't quite understand how it works.

Answer 1

data is 4-bytes, (uint8_t*) & data is converting it to a pointer of 1-byte values, x which you haven't shown, is indexing into the 1-byte array of values.

Answer 2

Lets split it up into its separate parts:

• &data gives you a pointer to data, the type is uint32_t *
• (uint8_t*) turns that uint32_t pointer into a pointer to uint8_t (or an array of unsigned bytes)
• The indexing takes one of the bytes in the "array"

If you put it in a loop, it takes one byte at a time from the four-byte uint32_t value, and assigns it to SPDR.

Answer 3

As StackOverflow's Tag Info says

Serial Peripheral Interface (SPI) is a serial, synchronous, full duplex bus commonly used in embedded systems. It is most often used for communication between a microcontroller and peripheral hardware such as memories, shift registers, sensors, displays etc, but can also be used for MCU to MCU communication.

Transmissions normally involve two shift registers of some given word size, such as eight bits, one in the master and one in the slave; they are connected in a ring. Data is usually shifted out with the most significant bit first, while shifting a new least significant bit into the same register. After that register has been shifted out, the master and slave have exchanged register values. Then each device takes that value and does something with it, such as writing it to memory. If there is more data to exchange, the shift registers are loaded with new data[1] and the process repeats. Transmissions may involve any number of clock cycles. When there is no more data to be transmitted, the master stops toggling its clock. Normally, it then deselects the slave. Transmissions often consist of 8-bit words. A master can initiate multiple such transmissions if it wishes/needs. However, other word sizes are also common, such as 16-bit words for touchscreen controllers or audio codecs, like the TSC2101 from Texas Instruments; or 12-bit words for many digital-to-analog or analog-to-digital converters.

SPDR = ((uint8_t*) & data)[x]; 

will result in a cast of uint32_t pointer into a pointer to uint8_t - that is pointer to 8-bits. Pointer arithmetic is based on a pointer type, and array subsripting is based on pointers arithmetic

---

C Standard n1124 § 6.5.2.1/2 Array subscripting

A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th element of E1 (counting from zero).

---

so indexing the array will move a pointer about sizeof (*pointer), thus 1 byte. This way you can traverse all 4 bytes in 32 bit thing.

Answer 4

I'm still having problems with this. Take the following:

uint16_t EN_A_WrRd_OP16(uint8_t opcode,uint16_t write_data)
{
    uint16_t read_data;
    uint8_t i;

    EN_A_CS_Low();
    SPIC_DATA=opcode;
    while (!(SPIC_STATUS&SPI_IF_bm));
    for (i=0;i<2;i++)
    {
        SPIC_DATA=((uint8_t*)&write_data)[i];
        while (!(SPIC_STATUS&SPI_IF_bm));    
        ((uint8_t*)&read_data)[i]=SPIC_DATA;
    }
    EN_A_CS_High();
    return read_data;        
    }

Going round the loop twice to read SPIC_DATA, it reads 0x34 then 0x12. However, on exiting the loop, read_data contains 0x0000! If I do it the “long” way and replace the loop with the following:

    SPIC_DATA=write_data;
    while (!(SPIC_STATUS&SPI_IF_bm));
    read_data=SPIC_DATA;
    SPIC_DATA=write_data>>8;
    while (!(SPIC_STATUS&SPI_IF_bm));
    read_data|=SPIC_DATA<<8;

it works correctly i.e read_data returns with the value 0x1234.