SPI mit mehreren Slaves intelligent selektieren

[Karsten K. (karsten42)]

Moin Moin,

Ich habe ein SPI-Master mit bis zu 8 gleiche SPI Slaves. Somit sind also 
8 CS Leitungen zu bedienen je nachdem welcher Slave gerade dran ist. Das 
bringt bei generischen read/write funktionen ewig lange switch/case oder 
if-else if blöcke mit sich. Siehe hier ein Beispiel für zwei SPI slaves 
die mit der variablen "mcp" ausgewählt werden.

..
#include utils.h

#define MCP2515_CA_A B,2
#define MCP2515_CA_A D,5

uint8_t can_read_status(uint8_t type, uint8_t mcp)
{
  uint8_t data;
  
  if(mcp)
    RESET(MCP2515_CS_A);
  else
    RESET(MCP2515_CS_B);
  
  spi_putc(type);
  data = spi_putc(0xff);
  
  if(mcp)
    SET(MCP2515_CS_A);
  else
    SET(MCP2515_CS_B);
  
  return data;
}

Meine Idee ist es nun anstatt der code intensiven if/else blöcke ein 
Array über einen index ( wie z.B. die variable mcp ) anzusprechen. Die 
Macros RESET/SET expandieren zu

PORTB &= ~(1 << 2)// Reset 
PORTB |= (1 << 2) // Set

Der Preprocessor macht aus den PORTB Makro für RESET dann:

(*(volatile uint8_t *)((0x05) + 0x20)) &= ~(1<<2);

Jetzt könnte man ja diesen Ausdruck in ein array aus strukturen packen 
in Form von

struct dynport {

 xxxxxx port // PORT
 uint8_t pin //  terminal
}

...

struct dynport ports[] {

  { PORTD, 2},
  { PORTA, 3},
  ....
}

Die Frage ist nun wie ich den Typ von port in struct dynport definieren 
muss???

Oder gibt es da eine elegantere Lösung?


Daaanke für jeden erhellenden Tipp :-)

Gruß
Karsten

[Der (Gast)]

Laut gedacht:

Wie wäre es mit einer Funktion / Makro:
RESET_CURRENT_CS(mcp);
SET_CURRENT_CS(mcp);
und in dieser dann eine switch/case Anweisung

[Karl H. (kbuchegg)]

Karsten K. schrieb:


> Jetzt könnte man ja diesen Ausdruck in ein array aus strukturen packen
> in Form von
>

> struct dynport {
> 
>  xxxxxx port // PORT
>  uint8_t pin //  terminal
> }
> 
> ...
> 
> struct dynport ports[] {
> 
>   { PORTD, 2},
>   { PORTA, 3},
>   ....
> }
>

>
> Die Frage ist nun wie ich den Typ von port in struct dynport definieren
> muss???

Um die Frage zu beantworten.
Der korrekte Datentyp wäre ein
  volatile uint8_t*

also ein

struct dynport {
  volatile uint8_t* port;
  uint8_t           pin;
};

struct dynport ports[] {
{
  { &PORTD, 2 },
  { &PORTA, 3 },
   ....
};

  *(ports[0].port) &= ( 1 << ports[0].pin );

>
> Oder gibt es da eine elegantere Lösung?

Im zweiten Teil der Funktion musst du ja keine Fallunterscheidung mehr 
machen.

  if(mcp)
    SET(MCP2515_CS_A);
  else
    SET(MCP2515_CS_B);

du wendest SET einfach auf alle an, auch auf die, die du vorher nicht 
mit RESET behandelt hast. Damit vereinfacht sich das an dieser Stelle. 
Und die Auswahl des zu benutzenden SPI-Clients lagerst du in eine 
Funktion aus, die von allen SPI-Funktionen aufgerufen wird.

Denn: obiger Zugriff

  *(ports[0].port) &= ( 1 << ports[0].pin );

ist nämlich genau von der Sorte, die man eigentlich nicht haben möchte. 
Alles ist variabel. Damit bleibt dem Compiler überhaupt nichts anderes 
übrig als das alles in der maximalen Langform zu implementieren. 
Optimierbar ist da überhaupt nichts mehr.

[Peter D. (peda)]

Du legst einfach alle 8 /CS auf den gleichen Port und übergibst dann der 
SPI-Funktion nur die Maske, also 0x01, 0x02 .. 0x80.

#define SPI_CS_PORT PORTA

void spi_task( uint8_t mask )
{
  SPI_CS_PORT = ~mask;  // select one SPI slave
  // do SPI stuff here
  SPI_CS_PORT = 0xFF;  // deselect all SPI slave
}

[Karsten K. (karsten42)]

Hallo Karl Heinz, Hallo Peter

Danke für die Info!
Ich bin da wohl im Wald und sehe nur Bäume! Ich war soooo auf PORT[x] 
und entspr. Anschluss fixiert.

Herzlichen Dank für eure überragende Hilfe!

Gruß
Karsten