Help with SPI

system · June 3, 2012, 11:15pm

I have a module that requires SPI communication and I'm trying to get it to communicate with the Arduino. Based on the specs provided below can someone verify I have the code setup properly? Once I get confirmation, I can then ask a question regarding the commands.

Specs on SPI device and Mega as Master:
First bit of the packet is always set to 0
Bitorder: MSB
Data Mode: Mode 11 (1,0/Mode 2)
Device Max Clock Freq: 2mhz (recommended 1mhz)
Mega Clock Speed 16 MHz so need /16 divider
SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS/CS)
Running Arduino 1.0 with build in SPI support (spi.h)

Here is what I have so far:

     Serial.println("SPI Begin...");
     SPI.begin();
     SPI.setBitOrder(MSBFIRST);
     SPI.setDataMode(SPI_MODE2); // 1,0
     SPI.setClockDivider(SPI_CLOCK_DIV16); // 1mhz

Thanks!

nickgammon · June 4, 2012, 3:53am

Looks OK so far.

system · June 4, 2012, 4:05am

Great.

So next part. The module has a dataReadyPin which goes high when I need to read it. I have that setup as a INPUT pin 31.

So in the loop I have the following:

 // don't do anything until the data ready pin is high:
  if (digitalRead(dataReadyPin) == HIGH) {
     // need to read register 00.
  }

So when the dataReadyPin goes high, I need to issue a read command. This is where I'm not sure what to do. I've been reading up on SPI and looking at examples however I'm not sure I really understand.

Here is where I'm stuck.

I need read Register 00 when the dataReadyPin goes high.

A read command format is:

             7 bit        8 bit               16 bit
---------------------------------------------------------------
|   0    |   CMD   |    Reg Addr    |       Reg Data          |
---------------------------------------------------------------
        /           \
       /             \
      /               \
      3 bit       4 bit
    ---------------------- 
   |  chip addr |    1   |
    ----------------------

So I'm guessing I need to send:

    digitalWrite(SS, LOW);
    int tempData = SPI.transfer(0b01000000);
    digitalWrite(SS, HIGH);
    Serial.println(tempData);

But that isn't doing anything -- does it look right?

Also, how do I read another register, like 17?

Thanks!!!

nickgammon · June 4, 2012, 4:44am

This isn't so good:

    digitalWrite(SS, LOW);
    int tempData = SPI.transfer(0b01000000);
    digitalWrite(SS, HIGH);
    Serial.println(tempData);

You appear to have 32 bits, right? 4 bytes. So you need 4 x SPI.transfer. Something like:

    digitalWrite(SS, LOW);
    SPI.transfer(1);   // read
    SPI.transfer(0x22);   // register 22
    byte a = SPI.transfer(0);   // get 8 bits
    byte b = SPI.transfer(0);   // get other 8 bits
    digitalWrite(SS, HIGH);
    Serial.println(tempData);

I would read that as the read/write bit being the low-order one, but reading the datasheet might help clear that up. If I knew what the link to the datasheet was. Hint.

system · June 4, 2012, 4:56am

No data sheet

nickgammon · June 4, 2012, 5:25am

It's pretty vague. It seems to be you should transfer one 0xFF and then the rest of what I showed. Maybe that will work.

system · June 4, 2012, 5:34am

I'll try that -- agree it's all really vague -- hence the issues I'm having.

nickgammon · June 4, 2012, 6:41am

You might not have a datasheet, but you have something which you are releasing in dribs and drabs. How about posting everything you have?

Sounds to me a bit like you send 0xFF for a while, and then the '0' bit indicates the start of "real" data. So it is like a synchronization point.

system · June 5, 2012, 3:13am

Nick,

I found this timing diagram (see attachment image file) -- I think that should help. You see how the request command has 4 bytes (32 bits).

This is the read command structure:

             7 bit        8 bit               16 bit
---------------------------------------------------------------
|   0    |   CMD   |    Reg Addr    |       Reg Data          |
---------------------------------------------------------------
        /           \
       /             \
      /               \
      3 bit       4 bit
    ---------------------- 
   |  chip addr |    1   |
    ----------------------


Chip addr = 0-7 (default is 0)
Command Type = 1 (Read)
Reg Addr = 0x00-0xFF
Reg Data = Not Used

Once that command is sent, then you have to send 0xFF (NOP) commands until you get back data. How would you write that logic?

This is what I have but it doesn't work:

// don't do anything until the data ready pin is high:
  if (digitalRead(dataReadyPin) == HIGH) {
    
    // SEND READ COMMAND (send 4 bytes / 32 bits)
    digitalWrite(SS, LOW);
    SPI.transfer(0b01000000);   // read command  (1 byte)
    SPI.transfer(0x00);   // register 00 (1 byte)
    SPI.transfer(0x00);  // upper data (not used) (1 byte)
    SPI.transfer(0x00);  // upper data (not used) (1 byte) 
    digitalWrite(SS, HIGH);
    
    // READ REGISTERS  (send NOP '0xFF' until data comes back)
    digitalWrite(SS, LOW);
    for (int i=0; i<50; i++){
      int response = SPI.transfer(0xFF);   // send NOP (2 byte)
      Serial.println(response);
      delay(10);
    }
    digitalWrite(SS, HIGH);
  } else {
    Serial.println("LOW");
    delay(50);
  }

Thoughts?

nickgammon · June 5, 2012, 4:04am

I don't understand their spec. How does it know to send something back?

system · June 5, 2012, 4:16am

I believe you "poll" after you send -- look at the timing in the previous post. You send a read, then you have to poll with 0xFF until you get back a correct message? This is all I have -- copied and pasted everything... not sure how to proceed.

Excerpt:

SPI Specifics
The NOP character is defined as 0xFF. While sending a command to the system the controller
receives the data that is set to one. Until valid data is available after a read register command was issued,
the system returns only data set to one. To get data from the system the controller polls
after sending a read register command until the controller receives valid data (not all data are set to one).
While polling, the controller must send only data set to one. In the beginning, read answer should be
received after the master has clocked for 16 bytes.

The system is SPI slave and the Host MCU is SPI master. The Host MCU sends a
command to the system at any time. If something changes in the system, then the Host MCU
should be notified. When Host MCU is notified; there is a hardware signal called SPI_REQ, which enables
the system to bring high to indicate that the Host MCU should read the system registers. The complete SPI
interface consists of:

• From Host MCU to system

Chip select

Receive data

Clock
• From system to Host MCU

Transmit data

SPI_REQ

Read Register Answer Polling
After the Host MCU sends the read register command, the controller starts polling the system to get the
read register answer by sending NOPs (OxFF). The read register answer is valid; when the first byte of the
controller receives information is not a NOP. The examples below (see file attachment) illustrate the read register sequence in the
case that the read register answer is valid and in the case the read register answer is not ready.

Start-up Sequence
Start-up sequence is important to establish between the Host MCU and the system. Start-up
sequence is as follows:

• Power up system
• SPI_REQ signal stays low
• Host MCU watches SPI_REQ signal
• If SPI_REQ signal is low, then Host MCU keeps watching. Do not start SPI communications
• When SPI_REQ goes high, then Host MCU issues read commands
• Host MCU must empty the message buffer by reading register 00 until SPI_REQ goes low
• Host MCU must run two operations in parallel

If SPI_REQ goes high, then read the message buffer by reading register 00 until SPI_REQ goes low

Read Reg_17 to check system status. If Reg_17 is not equal to 0x21 then Host MCU runs two
operations in parallel. The Host MCU must not send a write command.

If Reg_17 is "ready", 0x21, then Host MCU can start normal operation by sending write commands
• Normal operational loop, watch SPI_REQ signal, read Reg_00 when SPI_REQ goes high. Read or
write individual registers as needed.

system · June 5, 2012, 5:30am

Also, I think I have the SPI mode incorrect -- the timing.gif looks like I should be using Mode 3 (what is Mode 11 -- Mode 3)?

nickgammon · June 6, 2012, 11:37pm

Yes, mode 3 I think (in binary, 11).

system · June 7, 2012, 3:51am

Tested with Mode 3 -- same issue. I think my read command is not correct.

Shouldn't this work?

    // SEND READ COMMAND (send 4 bytes / 32 bits)
    digitalWrite(SS, LOW);
    SPI.transfer(0b01000000); // read command (1 byte)
    SPI.transfer(0b00000000);   // register 00 (1 byte)
    //SPI.transfer(0x00);  // upper data (not used) (1 byte)
    //SPI.transfer(0x00);  // upper data (not used) (1 byte) 
    digitalWrite(SS, HIGH);
    //delay(20);
    
    // READ REGISTERS  (send NOP '0xFF' until data comes back)
    digitalWrite(SS, LOW);
    for (int i=0; i<50; i++){
      int response = SPI.transfer(0xFF);   // send NOP (2 byte)
      Serial.println(response);
      delay(10);
    }
    digitalWrite(SS, HIGH);

Topic		Replies	Views
SPI - what is Data Ready? Networking, Protocols, and Devices	1	3320	May 6, 2021
SPI Communication with Arduino and maxim chip. Programming	14	4319	May 5, 2021
Help communicating with SPI sensor Networking, Protocols, and Devices	15	4572	May 6, 2021
SPI Question Networking, Protocols, and Devices	3	584	May 6, 2021
SPI transfer 3rd Party Boards	5	3280	May 6, 2021

Help with SPI

Related topics