next topic »

[on:]

Is there a way to be sure if I am using the *hardware* SPI and getting that fast SPI speed? I have it all on the pins assigned as needed, but I am still having a speed issue in my program. When I have the display on, there is some slowdown, even if I only send a tiny bit of data to the display. (Using an Uno)

Can I be sure I'm enabling the fast hardware SPI here in this sample code?

Code:

#define LOAD 10      
#define DIN 11      
#define DOUT 12      
#define SPICLOCK 13  

int counterNumber1 = 0;
int counterNumber10 = 0;

void setup()
{
  int clr;
  pinMode(DIN, OUTPUT);    
  pinMode(SPICLOCK,OUTPUT);
  pinMode(LOAD,OUTPUT);
  digitalWrite(LOAD,HIGH); //disable device

  // SPCR = 01010000
  //interrupt disabled,spi enabled,msb 1st,master,clk low when idle,
  //sample on leading edge of clk,system clock/4 (fastest)
  SPCR = (1<<SPE)|(1<<MSTR);
  clr=SPSR;
  clr=SPDR;
  delay(10);

  //clear MAX7219 and format to receive data
  write_7seg(0x0C,1);
  write_7seg(0x09,0xFF);
  write_7seg(0x0A,0x0F);
  write_7seg(0x0B,0x04);
}

void loop()
{
  write_7seg(1, counterNumber1);
  write_7seg(2, counterNumber10);  
  delay (10)
}

//spi transfer function (from ATmega168 datasheet)
char spi_transfer(volatile char data)
{
  SPDR = data; // Start the transmission
  while (!(SPSR & (1<<SPIF))) // Wait the end of the transmission
  {
  };
  return SPDR; // return the received int
}

//MAX7219 data transfer function
int write_7seg(int digAddress, int displayValue)
{
  digitalWrite(LOAD,LOW); //MAX7219 chip select is active low
  //2 int data transfer to MAX7219
  spi_transfer(digAddress);
  spi_transfer(displayValue);
  digitalWrite(LOAD,HIGH); //release chip, signal end transfer
}

[Reply #1 on:]

The fastest speed of the hardware SPI interface is actually F_OSC/2 - which is 8 MHz for a normal arduino.

If you need top-speed, use direct port manipulation for twiddling the chip-select line. You also seem to feed 'int'-s to a function that would run as well with an uint8_t. SPI sends bytes, no need for ints.

[Reply #2 on:]

From what I can see you are currently running at fosc/4, you can get to fosc/2 by setting the SPI2X bit in the SPSR.

To see what rate you are running at (I assume you don't have any proper equipment) just write a loop to send 100000 bytes and time it.

______
Rob

[Reply #3 on:]

Thank you both for you replies. I took quite a lot of that code from elsewhere, so I don't fully understand your comments.
I don't need absolute max speed, but I'd like to avoid bottlenecks anywhere I can.

If you can be more specific about what to change, I'd really appreciate that!

[Reply #4 on:]

I haven't done it but looking at the data sheet I would say that

SPSR = 1;

or

SPSR  = (1 << SPI2X); // same thing because SPI2X is bit 0 and the other bits are RO (read only)

Should give you fosc/2, however...

When I have the display on, there is some slowdown, even if I only send a tiny bit of data to the display.

What is slowing down? There's nothing else happening in the code you posted. Is there more to this than meets the eye?


______
Rob

[Reply #5 on:]

(This is just a test routine - the slowdowns are in the real program.)

I haven't used bitshift before so am trying to make sense of these lines:

SPSR  = (1 << SPI2X); // same thing because SPI2X is bit 0 and the other bits are RO (read only)
and
SPCR = (1<<SPE)|(1<<MSTR);

[Reply #6 on:]

For example (1 << 2) means the value 1 shifted left 2 times,

00000001 << 2 == 00000100 == 4

The "values" SPI2X, SPE, MSTR etc are just #defines for numbers in a file somewhere so

(1<<SPE)

is just 1 shifted left by SPE bits.

That's fine to get a single bit set in a register but it clears all the other bits so to set multiple bits you have to OR several of these expressions.

Let's assume SPE = 2 and MSTR = 4 (they probably aren't but I couldn't be bothered looking them up)

(1<<SPE)|(1<<MSTR) == (1<<2)|(1<<4) == 00000010 | 00010000 == 000100010 == 0x12  ERROR fixed

so the value 0x12 is written into the register.

In my previous example

SPSR  = (1 << SPI2X); // same thing because SPI2X is bit 0 and the other bits are RO (read only)

SPI2X is actually defined as 0 so  (1 << SPI2X) ==  (1 << 0) == 1.

There's no real need to use these expressions but it saves using magic numbers, after a while you will look at  (1 << SPI2X) and know exactly what it means, if you write SPSR = 1 you will forever have to look it up in the data sheet.

______
Rob

[Reply #7 on:]

VERY useful answer - thanks.

Is this right though?
"Let's assume SPE = 2 and MSTR = 4 (they probably aren't but I couldn't be bothered looking them up)
(1<<SPE)|(1<<MSTR) == (1<<1)|(1<<4) == 00000010 | 00010000 == 000100010 == 0x12"

Should it be this? :
(1<<SPE)|(1<<MSTR) == (1<<2)|(1<<4) == 00000100 | 00001000 == 00001100 == 0x12"

In the end, do I want to set SPCR as I have, then set the SPSR right after?
  // SPCR = 01010000
  //interrupt disabled,spi enabled,msb 1st,master,clk low when idle,
  //sample on leading edge of clk,system clock/4 (fastest)
  SPCR = (1<<SPE)|(1<<MSTR);
  SPSR  = (1 << SPI2X); //toggle this 0 to a 1 in order to switch on "SPI2X" register value
  clr=SPSR;
  clr=SPDR;

ALSO, as an example, if I wanted to slow things down I would set that rightmost SPRO bit on, by basically making that 0 a 1 like so:
  SPCR = (1<<SPE)|(1<<MSTR) |(1<< SPRO);

Thanks!

[Reply #8 on:]

Should it be this? :

Yep, well done, you spotted the deliberate error

In the end, do I want to set SPCR as I have, then set the SPSR right after?

Yes although the order doesn't matter AFAIK.

ALSO, as an example, if I wanted to slow things down I would set that rightmost SPRO bit on, by basically making that 0 a 1 like so:
  SPCR = (1<<SPE)|(1<<MSTR) |(1<< SPRO);

That seems right, should give you fosc/8.

_____
Rob

[Reply #9 on:]

Awesome, your assistance was really great, and very much appreciated!