SPI per Software

avrfreaks.net
--> Anmeldung erforderlich, aber viel Beispielsource zu verschiedenen
Themen
--> Englischkenntnisse erforderlich

Gruß, Alex

AT89C52 !

Hallo,

hat noch niemand sowas gemacht?

Gruß Ralf

doch, sicher.
Aber geh doch andersherum ran: wenn du verstanden hast, wie das
physikalisch funktioniert, klappt das auch mit der Programmierei. Wenn
du dich mit C beschäftigen willst, nutzt es dir doch nichts,
vorgekauten Kram zu bekommen. Nichts ist dafür besser als eigene
Erfolgserlebnisse.

@Peter:

Mach mir ein Beispiel, und ich sag dir, ob ich es verstanden habe ;-)
Nein, im Ernst, ich verstehe dich. FOR, IF, &, |(oder), sowie << und >>
(shiften bzw. rolieren), ist alles klar. Mein Problem war eher, dass ich
den Lösungsansatz suche, inzwischen habe ich eine der Routinen zum
laufen bekommen, aber auf diese Lösungsart bin ich nicht gekommen, weil
ich sie so nicht ERWARTET habe. Da hilft denke ich nur Input von denen,
die es können.

@Crazy Horse:

Wie ich Peter bereits sagte, auf den Lösungsansatz muss man gefasst
sein. Aber das mit den Erfolgserlebnissen, da hast du freilich recht.

Gruß Ralf

hier mal ein Beispiel für das SPI-Schreiben, die Grundroutine write_spi
und ein Funktion, die diese benutzt.

Hi Crazy Horse,

also... Ist die Routine zum SPI-Schreiben nicht ein bisschen dick?
Meine sieht so aus:

SPI_OUT(unsigned char output) {
  unsigned char i;

  for (i = 8; i; i--) {
  SCK = 0;
  MOSI = output & 0x01;
  output = output >> 1;
  SCK = 1;
  }
}

Oder übersehe ich irgendwo etwas in deiner Routine? Ich nehme an, du
machst weiche Ware für einen AVR oder so, vielleicht macht die Routine
da so mehr Sinn.

Gruß Ralf

"Das Beispiel von crazy horse ist auch eine, wenn auch nicht sehr
effektiv" - ich wusste, dass das von dir kommt :-)

weiss ich selbst, aber man versteht es eigentlich recht gut, wie es
funktioniert. Man braucht auch keinen extra loop-Zähler.

@Ralf: nicht immer ist ein einfacher aussehendes C-Programm auch die
optimale Lösung im Endergebnis, kommt natürlich auch auf den Compiler
an.
Konkret, (rein Interese halber habe mal beides compiliert) und siehe
da:
dein C-Code erzeugt 4 words mehr Maschinencode (absolut 19 zu 23) und
benötigt 271 Takte statt 193 bei meinem.

@crazy horse:

Ich wollte dir auch nicht auf die Hufe... äh... Füsse treten. Du hast
den Code jetzt für einen AVR generiert, oder? Ich werd bei Gelegenheit
mal deinen für den 8051 generieren, mal sehen, ob meiner da auch so
groß ist im Gegensatz zu deinem. In dem Fall würde ich deinen nehmen,
wenn da kein Copyright drauf ist :-)

Gruß Ralf

Ach was :-)
Ja, war für nen AVR (2313) mit CodeVision.

Noch ein Test, ohne extra loop-counter

void write_spi (unsigned char data_out){       //msb first
unsigned char mask;
for (mask=0x80; mask; mask=mask>>1)
    {sclk=0;
    if (data_out & mask) mosi=1;
    else mosi=0;
    sclk=1;
    }
}
schlägt mit 16 words und 159 Takten (mit Aufruf und return) zu Buche.

Auch knuffig. Ich muss jetzt mal anfangen, die Sache real (sprich nicht
Simulator) auszutesten, und mal sehen was dabei rauskommt.
Hoffentlich tuts auch...

Gruß Ralf

Kannst du mal das Listing anhängen?
Deine Lösung erzeugt bei mir das schlechteste Ergebnis (29 words, 439
Takte). Da besteht offensichtlich deutlicher Optimierungsbedarf am
Compiler.

Ist schon etwas älter aber hatte ähnliches problem und fand diese seite 
bei google.

meine lösung für CPHA=1 und CPOL=1 
(http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus)

1

void SOFT_SPI_init(void){

2

  // MOSI und CLK auf Ausgang setzen

3

  SOFT_SPI_MOSI_DDR |=(1<<SOFT_SPI_MOSI_BIT);

4

  SOFT_SPI_CLK_DDR  |=(1<<SOFT_SPI_CLK_BIT);

5

6

  // MOSI und CLK auf HIGH setzen

7

  SOFT_SPI_MOSI_PORT|=(1<<SOFT_SPI_MOSI_BIT);

8

  SOFT_SPI_CLK_PORT |=(1<<SOFT_SPI_CLK_BIT);

9

10

  // MISO auf Eingang setzen

11

  SOFT_SPI_MISO_DDR &=~(1<<SOFT_SPI_MISO_BIT);

12

}

13

14

unsigned char SOFT_SPI_WriteRead(unsigned char dataout)

15

{

16

  uint8_t datain=0;

17

  //das Byte wird Bitweise nacheinander Gesendet MSB zuerst

18

  for (uint8_t a=8; a>0; a--){                

19

      datain<<=1;                      //Schieben um das Richtige Bit zusetzen

20

      SOFT_SPI_CLK_PORT &=~(1<<SOFT_SPI_CLK_BIT);     // Clock auf LOW

21

22

      if (dataout & 0x80){                //Ist Bit a in Byte gesetzt

23

        SOFT_SPI_MOSI_PORT |=(1<<SOFT_SPI_MOSI_BIT);   //Set Output High

24

      }

25

      else{

26

        SOFT_SPI_MOSI_PORT &=~(1<<SOFT_SPI_MOSI_BIT);   //Set Output Low

27

      }

28

      _delay_us(1);

29

      if (SOFT_SPI_MISO_PIN & (1<<SOFT_SPI_MISO_BIT))   //Lesen des Pegels 

30

        {

31

        datain |= 1;

32

        }

33

34

      _delay_us(1);

35

      SOFT_SPI_CLK_PORT |=(1<<SOFT_SPI_CLK_BIT);       // Clock auf High

36

      _delay_us(2);

37

      dataout<<=1;                     //Schiebe um nächstes Bit zusenden

38

    }

39

40

  return datain;

41

}

mit den Delay zeiten kann man noch etwas spielen.