1

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;
}

2

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.

  • Thank you this is certainly helpful. I have one more question, what is it that changes the value of CS register so it indicates the completion of transfer? I'm clearly stuck at that, I never leave the 4th point. – Dominik Ficek Mar 30 at 11:21
  • Bit 16 being set in the CS register indicates the transfer is complete. See page 154. The hardware sets it. – joan Mar 30 at 11:25
  • I would highly recommend switching to the available linux driver if possible – crasic Mar 31 at 6:44

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.