SPI mit PIC ohne MSSP

[Marten M. (mcgonahy148)]

Hallo zusammen,

Auf welche Probleme stößt man, wenn man ein SPI Signal generieren will, 
ohne die eingebaute Schnittstelle?

Oder gibt's wen, der hier schon was erstellt hat mit nem Pic18?


Gruß,
Marten

[Holger (Gast)]

> Auf welche Probleme stößt man, wenn man ein SPI Signal generieren will,
> ohne die eingebaute Schnittstelle?

Man muß herausfinden wie man mit zwei Portpins wackelt.

[Max H. (hartl192)]

Marten Mcgonahy schrieb:
> Auf welche Probleme stößt man, wenn man ein SPI Signal generieren will,
> ohne die eingebaute Schnittstelle?
Abhängig von der gewünschte Übertragungsrate und dem was der PIC 
nebenher machen muss könnte es sein, dass der PIC zu langsam ist.

[Peter X. (peter_x)]

Marten Mcgonahy schrieb:
> Auf welche Probleme stößt man, wenn man ein SPI Signal generieren will,
> ohne die eingebaute Schnittstelle?

Wenn man selbst nicht grafft hat, wie eine SPI Schnittstelle 
funktioniert

[Max H. (hartl192)]

Gefunden :-)

Hier ist ein Beispiel wie man Soft-SPI implementieren könnte:

#define SOFT_SPI_SDO LATXbits.LATXy
#define SOFT_SPI_SCK LATXbits.LATXy
#define SOFT_SPI_SDI PORTXbits.RXy

unsigned char softSpiTransfer(unsigned char spi_data)
{
  unsigned char bit_cnt;
  for(bit_cnt = 0; bit_cnt < 8; bit_cnt++)   
  {
    if(spi_data & 0x80)  // Writes bit
      SOFT_SPI_SDO = 1;
    else
      SOFT_SPI_SDO = 0;

    spi_data = spi_data << 1;   

    SOFT_SPI_SCK = 1;  // SCK high

    if(SOFT_SPI_SDI)  // Reads input
      spi_data |= 1;         
    else
      spi_data &= ~1;

    SOFT_SPI_SCK = 0;  // SCK low                       
  }
  return(spi_data);               
}

Hat zwar 100% CPU Auslastung während dem Senden/Empfangen, bei vielen 
Anwendungen wird das aber kein Problem sein.

[Joe F. (easylife)]

Marten Mcgonahy schrieb:
> Hallo zusammen,
> Auf welche Probleme stößt man, wenn man ein SPI Signal generieren will,
> ohne die eingebaute Schnittstelle?

auf keine.

[Volker S. (vloki)]

Max H. schrieb:
> Hier ist ein Beispiel wie man Soft-SPI implementieren könnte:

Hier noch eines:

#define SPI_DOUT LATXbits.LATXy
...

#ifndef SPI_WAIT
    #define SPI_WAIT {_asm nop ... nop _endasm} //ndamit es nicht zu schnell geht ;-)
#endif

#define SPI_OUT() {                 \
     SPI_DOUT = spiData.bit7;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit6;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit5;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit4;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit3;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit2;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit1;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
  SPI_DOUT = spiData.bit0;    \
  SPI_CLK = 1;SPI_WAIT;       \
  SPI_CLK = 0;                \
}// end SPI_OUT()

#define SPI_IN() {                  \
        spiData.all = 0;            \
        SPI_CLK = 1;                \
        spiData.bit7 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit6 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit5 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit4 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit3 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit2 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit1 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
        SPI_CLK = 1;                \
        spiData.bit0 = SPI_DIN;     \
        SPI_CLK = 0;SPI_WAIT;       \
}// end SPI_IN()

spiData als Bitfeld ...

[Marten M. (mcgonahy148)]

Morgen,

OK... Stichwort Soft SPI ist also das richtige Wort dafür.

Also f bzw Takt ist kein Problem, 1hz ist auch okay und reiner Master 
Mode.

Bei 8 bis 16 bit spi sollte sich die Auslastung in Grenzen halten.

Aber jetzt noch was anderes....wie geht man eigentlich mit Interrupts 
um, bei Generierung serieller Daten? Also auch wenn die mssp zum Einsatz 
kommt... Wenn nun mitten drin ein IR ommt, dann is die Übertragung ja 
wieder Muell. Also dann nach IR einfach nochmal schicken?


Gruß,
Marten

[Volker S. (vloki)]

Das MSSP Modul arbeitet autonom und ist von einem IR nicht betroffen.

Auch die Softwarelösung (auf der Massterseite) ist bei synchroner 
Übertragung (mit einem Taktsignal) unkritisch weil Zeitverzögerungen, 
welche durch Interrupts entstehen könnten, den Slave nicht 
interessieren.
Der Slave kann sich nur am Takt orientieren.
Der Zustand der Daten beim aktiven Takt wird durch zeitliche 
Verschiebungen nicht verfälscht.

[Marten M. (mcgonahy148)]

Volker SchK schrieb:
> Das MSSP Modul arbeitet autonom und ist von einem IR nicht betroffen.
>
> Auch die Softwarelösung (auf der Massterseite) ist bei synchroner
> Übertragung (mit einem Taktsignal) unkritisch weil Zeitverzögerungen,
> welche durch Interrupts entstehen könnten, den Slave nicht
> interessieren.
> Der Slave kann sich nur am Takt orientieren.
> Der Zustand der Daten beim aktiven Takt wird durch zeitliche
> Verschiebungen nicht verfälscht.

Ok...gut zu wissen...das wusste ich nicht, dass der MSSP nicht 
unterbrochen wird.

Und bei der SW-Lösung hast du schon recht, der Slave reagiert ja dann 
nur auf die Flanken...die kommt halt dann später, verfälscht aber jetzt 
nicht die Daten. Nur wenn es zeitkritisch wäre, wäre das natürlich ein 
Problem.

Guter Input auf alle Fälle! Besten Dank euch!!!

[Jens P. (picler)]

Wenn du die Funktionsweise von SPI verstanden hättest, wäre deine Frage 
gegenstandslos.

SPI ist im wesentlichen ein statisches Seriell zu 
Parallel-Schieberegister. Du legst an den Dateneingang ein Bit an und 
wackelst ein paar µs oder h später mit dem Clk-Pin. Das einzige Problem, 
worauf du achten musst, ist die Zeit zwischen Bitausgabe und Wackeln vom 
Clock. Wenn die Zeit zu kurz ist, kann es passieren, dass das Datenbit 
noch keinen gültigen Pegel hat. Allerdings bewegt sich das je nach 
Portpin etc. im Bereich kleiner 1 µs, also großer 1MHz. Die rein 
statische Arbeitsweise von SPI ist auch der große Vorteil gegenüber 
einer rein seriellen Übertragung. Denn dort gibt es festgelegte 
Bitlängen.