Argthtjtr

I'm currently reworking a project from someone who graduated a few years back and I'm supposed to change the function of his work for a bit.

I have trouble understanding these few lines from SPI communication, how does this work? :

    *ptr = (3<<4) | (1<<7);             //clear

    *(ptr +SPI_FIFO) = udata2>>8;

    *(ptr +SPI_FIFO) = udata2;

    while (!(*ptr & (1 << 16)));    // Transfer DONE



    *ptr &= ~(1<<7);



    *ptr = (3<<4) | (1<<7) | (1<<0);            //clear

    *(ptr +SPI_FIFO) = udata1>>8;

    *(ptr +SPI_FIFO) = udata1;

    while (!(*ptr & (1<<16)));              // Transfer DONE

    *ptr &= ~(1<<7);

To explain what I know: The function 'send' expects 2 float values in interval <-1;1> and through circuits it changes output voltage from minimum of -12.5V to maximum of 12.5V.
When I tried to send various values to function from interval it got stuck on:

     while (!(*ptr & (1 << 16)));

As I investigated the code more I realized that either I'm dumb or the person who wrote this is dumb because how does this work ?

    *(ptr +SPI_FIFO) = udata2>>8;

    *(ptr +SPI_FIFO) = udata2;

Any help is appreciated.
Thank you.

If needed the whole code is below.

SPI.h:

#include <sys/mman.h>

#include <fcntl.h>

#include <unistd.h>





#ifndef _SPI

#define _SPI



#define IOBASE   0x20000000     

#define GPIO_BASE (IOBASE + 0x200000)       

#define SPI0_BASE (IOBASE + 0x204000)       

#define TIMER_BASE (IOBASE + 0x3000)        



//SPI

#define SPI_CS      0

#define SPI_FIFO    1

#define SPI_CLK     2

#define SPI_DLEN    3

#define SPI_LTOH    4

#define SPI_DC      5







class SPI

{

    int fd;             

    volatile unsigned int* ptr;

    volatile unsigned int* uk_GPIO;

public:

    SPI();          

    ~SPI();     

    void inline send(float, float);

    int connected(void);

};



#endif

SPI.cpp:

#include "SPI.h"

#include  <cstdlib>



SPI::SPI()                  

{

    if ((fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0)

        {

        ptr = 0;                

        printf("SPI ERROR");

        return;

        }

    ptr = (volatile unsigned int *)mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,fd,SPI0_BASE);    

    uk_GPIO = (volatile unsigned int *)mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,fd,GPIO_BASE);

    if (ptr == MAP_FAILED || uk_GPIO== MAP_FAILED)          

        {

        ptr = 0;                

        uk_GPIO = 0;

        return;

        }

    *(uk_GPIO) = (*(uk_GPIO) & 0x001FFFFF) | 0x24800000;    

    *(uk_GPIO+1) = (*(uk_GPIO+1) & 0xFFFFFFC0) | 0x24;  

    *(ptr + SPI_CLK) = 32     ; 

    munmap((void*)uk_GPIO,4096);                

    return;                     



}



void inline SPI::send(float data1, float data2)

{



    unsigned short udata1 = 0x7FFF + 0x7FFF*(data1);

    unsigned short udata2 = 0x7FFF + 0x7FFF*(data2);



    *ptr = (3<<4) | (1<<7);             //clear

    *(ptr +SPI_FIFO) = udata2>>8;

    *(ptr +SPI_FIFO) = udata2;

    while (!(*ptr & (1 << 16)));    // Transfer DONE



    *ptr &= ~(1<<7);



    *ptr = (3<<4) | (1<<7) | (1<<0);            //clear

    *(ptr +SPI_FIFO) = udata1>>8;

    *(ptr +SPI_FIFO) = udata1;

    while (!(*ptr & (1<<16)));              // Transfer DONE

    *ptr &= ~(1<<7);



    //printf ("read  %2.2x%2.2x  n", *(ptr + SPI_FIFO), *(ptr + SPI_FIFO));

}

SPI::~SPI()                     

{

    munmap((void*)ptr,4096);

    close(fd);                  

}



int SPI::connected(void)                    

{

    if (ptr == 0 || uk_GPIO == 0)

        return -1;

    else

        return 1;

}

You need to refer to the BCM2835 ARM Peripherals document.

It specifies many of the Pi's hardware interfaces.

In this case SPI appears to be the main SPI device documented from page 148.

*ptr = (3<<4) | (1<<7);             // 1

*(ptr +SPI_FIFO) = udata2>>8;       // 2

*(ptr +SPI_FIFO) = udata2;          // 3

while (!(*ptr & (1 << 16)));        // 4

ptr is a word pointer(32 bits) to the base of the SPI registers (the CS register).

1. clears the FIFOs and starts SPI.


2. writes the MSB of udata2 to the hardware FIFO.


3. writes the LSB of udata2 to the hardware FIFO.


4. spins until the CS register indicates the transfer is complete.

Note that writing to the hardware FIFO address adds a byte to the transmit FIFO, reading from the hardware FIFO address removes a byte from the receive FIFO.

It may be worthwhile to point out that this code may have been written before the availability of the Pi Linux SPI driver. I would suggest you now use the Linux SPI driver.