Displaya 16-Bit Mode?

[marcel (Gast)]

Servus,

ich habe hier eine Displayroutine gefunden. Das Display wird via SPI 
angesteuert. Die Hauptroutinen sehen wie folgt aus:

//*********4W_SPI_Write()
void SPI_Write(unsigned char dat)
{
  unsigned char t = 8;
  do
  {
    SDI = (bit)(dat & 0x80);
    dat <<= 1;
    SCLK = 0;  
    //SPI_Delay();
    SCLK = 1;
    //SPI_Delay();
  
  } while ( --t != 0 );
  //SCLK = 1;
  //SDI = 1;
}


//////////////SPI Write command
void LCD_CmdWrite(uchar cmd)
{  
  SCLK = 1;  
  SDI = 1;  
  SCS = 0;
  //SPI_Delay();
  SPI_Write(0x80); 
  SPI_Write(cmd);
  SCS = 1;
  //SPI_Delay();
}

//////////////SPI Write data or  parameter
void LCD_DataWrite(uchar Data)
{
  SCLK = 1;  
  SDI = 1;    
  SCS = 0;
  SPI_Write(0x00); 
  SPI_Write(Data);
  //SPI_Delay();
  SCS = 1;
}

Die SPI_Write Funktion kann einfach durch eine Funktion ersetzt werden, 
die 8 Bit in den SPI-Buffer schreibt.

Meine Frage: Wenn ich das richtig verstehe werden zum Senden 1 Bytes 
vorher 8-Bit gesendet (entweder 0x80 oder 0x00), wobei das erste Bit der 
8-Bit zur Unterscheidung zwischen Daten und Kommandos dient.

Ist dies richtig so? Sowas habe ich bisher noch nicht gesehen. Entweder 
kenne ich Displays im 9-bit SPI Mode, wobei das erste Bit für 
Daten/Kommandos genutzt wird oder heirfür wird eine separate Leitung 
spendiert. Das hier aber 16 Bit gesendet werden ist mir nicht geläufig. 
Wenn dies so stimmen würde, müßte ich dann meinen SPI auch im 16-BIT 
MOde initialisieren??

MFG

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

marcel schrieb:
> Das Display
Welches?

[marcel (Gast)]

Lothar Miller schrieb:
> marcel schrieb:
>> Das Display
> Welches?

http://www.buydisplay.com/download/manual/ER-TFTM043-3_Datasheet.pdf

[Karl H. (kbuchegg)]

marcel schrieb:

> Meine Frage: Wenn ich das richtig verstehe werden zum Senden 1 Bytes
> vorher 8-Bit gesendet (entweder 0x80 oder 0x00), wobei das erste Bit der
> 8-Bit zur Unterscheidung zwischen Daten und Kommandos dient.
> Ist dies richtig so?

Sieht zumindest so aus.

> Sowas habe ich bisher noch nicht gesehen. Entweder
> kenne ich Displays im 9-bit SPI Mode, wobei das erste Bit für
> Daten/Kommandos genutzt wird oder heirfür wird eine separate Leitung
> spendiert.

Kommt aufs Display an. Stell dir einfach vor, dass im Display 2 Bit 
Schieberegister sitzen. Aus dem einen kommen die 8 Datenleitungen raus, 
aus dem anderen die Steuerleitungen. Die da zb Kommando/Daten aber auch 
'Schreiben/Lesen' sind. 2 Stück Standard 8-Bit Schieberegister können 
einfacher sein, als ein spezielles mit einer unüblichen Bitzahl. Zudem 
ist man bei der Ansteuerung universeller. Denn 8 Bit bzw. Vielfache von 
8 kann jeder. Bei nicht durch 8 teilbaren Werten muss man andrerseits 
wieder tricksen.

> Das hier aber 16 Bit gesendet werden ist mir nicht geläufig.
> Wenn dies so stimmen würde, müßte ich dann meinen SPI auch im 16-BIT
> MOde initialisieren??

Kommt auf deine SPI an. Hat die denn einen 16 Bit Modus?
Sonst eben: 2 Stück 8 Bit Taktungen und gut ists. Das LCD kann ja 
sowieso nicht unterscheiden (ausser an einem ganz kurzen Timingdelay am 
Clock), ob du jetzt 1 Befehl oder deren 2 benutzt, um die SPI Hardware 
zu befüllen.

[Mike (Gast)]

marcel schrieb:
> Ist dies richtig so?

Das sollte dir das Datenblatt zu dem Display verraten. Wenn die 
Display-Routine bisher funktioniert hat, spricht einiges dafür.

[marcel (Gast)]

was mir halt unklar ist, warum die Chipselect Leitung vor den 16 Bit 
nach unten gezogen wird und erst danach wieder hoch. Das sind doch dann 
eindeutig 16 Bit die gesendet werden. Deswegen die Frage nach dem 16-Bit 
Modus.

CS_LOW
8Bit // (0x80 oder 0x00)
CS_High

und dann

CS_LOW
8Bit // DAten
CS_High

hätte ich verstehen können.

Aber so bin ich mir noch unklar über den Modus, da im Datenblatt auch 
nichts vom 16-Bit Modus steht.

[Karl H. (kbuchegg)]

marcel schrieb:
> was mir halt unklar ist, warum die Chipselect Leitung vor den 16 Bit
> nach unten gezogen wird und erst danach wieder hoch.

Es geht zwar nicht aus dem von dir verlinkten Datenblatt hervor, aber 
normalerweise ist genau dieses das Kennzeichen für das Gerät: Achtung, 
die nächsten Bits sind für dich.

> Das sind doch dann
> eindeutig 16 Bit die gesendet werden. Deswegen die Frage nach dem 16-Bit
> Modus.

Ja, macht ja nichts.
Die Sache funktioniert ja grundsätzlich so:
solange die Chip Select Leitung falsch steht, kann sich an der Daten 
bzw. Taktleitung tun was will, das interessiert das LCD nicht.
Erst mit der Aktivierung des Chip Select schaltet das LCD seine Eingänge 
'scharf'.
Ab da gibt es jetzt 2 Möglichkeiten.
Entweder das LCD zählt die Taktpulse mit und erklärt sich mit dem 16. 
Taktpuls als befriedigt. Oder aber es taktet einfach mit dem Takt die 
Datenleitungen seinerseits in ein Schieberegister (mit 16 Bit Länge) 
ein, egal wieviele Takte und das was beim Deaktivieren des Chip Select 
in den 16 Bit dieses Schieberegisters rauskommt, das wird anhand der 
Position im Schie beregister benutzt.

Du machst du jetzt mehr draus, als tatsächlich dahinter steckt.

> CS_LOW
> 8Bit // (0x80 oder 0x00)
> CS_High

Wo siehst du das?
Genau DAS passiert eben nicht.

CS geht auf Low, dann werden 16 Bits rausgetaktet, wobei jeder 
Datenpegel von einem Puls auf der Taktleitung gefolgt sind.
Und erst dann, wenn alle 16 draussen sind, geht CS wieder auf High.

Das da 16 Bits übertragen werden, hat aber nichts mit einem 8 Bit oder 
16 Bit Modus des Senders zu tun. Das LCD wil 16 Bits haben (in der Form, 
dass die Clock Leitung 16 mal gepulst wird). Ob du das im Sender mit 
einem Modus machst, der 16 Bit kann, oder mit einer SPI Einheit die nur 
8 Bit kann (und daher dann 2 mal angesprochen wird), oder einer 
Hardwrae, die nur 4 Bit auf einmal raustakten kann (und dann 4 mal 
hintereinander benutzt wird) oder mit einer die gar nur 1 Bit raustakten 
kann (und dann 16 mal benutzt wird), ist ja dem LCD wurscht. Das 
interessiert sich immer nur für den nächsten Clock Puls. Egal wie der 
zustande kommt.

> hätte ich verstehen können.

ganz im Gegenteil. Das wäre noch viel ungewöhnlicher. Denn dann bräuchte 
man wieder einen Mechanismus, mit dem man das erste Byte vom 2-ten Byte 
unterscheiden können muss.

Du liest da etwas zuviel in den Chip Select hinein. Chip Select bedeutet 
einfach nur: Achtung! - Die nächsten Bits sind für dich.
Mit einer Aufteilung in Bytes hat ein Chip Select erst mal nichts zu 
tun.

[Purzel H. (hacky)]

Meine Erfahrung mit dem SPI Modus ist, dass da alle moeglich ist. 8, 16, 
24, 32 bit am stueck. Es gibt auch solche Modi, da muss der Chipselect 
vor oder waehrend dem letzt bit hoch, und solch geschichten. Daher immer 
das Datenblatt genau (!) lesen und auch so implementieren. Nicht einfach 
SPI Mode, und passt schon. Dann mit dem Scope verifizieren. Dh 
Testpunkte auf der Leiterplatt vorsehen um die Probe einzustecken.
Falls es mit einem vorgesehenen SPI Mode nicht geht, haendisch mit dem 
Pin wackeln.

[Mike (Gast)]

Siebzehn Für Fuenfzehn schrieb:
> Meine Erfahrung mit dem SPI Modus ist, dass da alle moeglich ist. 8, 16,
> 24, 32 bit am stueck

Und wenn da hintereinander 16 Stk 74xx595 dran hängen, sind es 256 Bit 
am Stück ;-)

[marcel (Gast)]

OK, danke für die Antworten.
Versuche jetzt seit längerer Zeit das oben angesprochene Dispaly mit 
einem PIC32 im 4 wire SPI Mode anzusprechen, ohne Erfolg.

Ich poste mal meinen Code, vielleicht fällt Jemanden etwas aus. Die 
Hardwarekonfigs habe ich alle dementsprechend angepasst.

#define _SUPPRESS_PLIB_WARNING 1

#include <p32xxxx.h>
#include <stdio.h>
#include <stdlib.h>
#include <plib.h>


#define color_brown   0x40c0
#define color_black   0x0000
#define color_white   0xffff
#define color_red     0xf800
#define color_green   0x07e0
#define color_blue    0x001f
#define color_yellow  color_red|color_green
#define color_cyan    color_green|color_blue
#define color_purple  color_red|color_blue


// Configuration Bit settings

// SYSCLK = 80 MHz (8MHz Crystal / FPLLIDIV * FPLLMUL / FPLLODIV)
// PBCLK = 80 MHz (SYSCLK / FPBDIV)
// Primary Osc w/PLL (XT+,HS+,EC+PLL)
// WDT OFF
// Other options are don't care
#pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_1 // Primary Oszillator -> HS: High Speed crystal
#define SYS_FREQ (80000000L)

// SPI
#define LCD_CS_OUT              mPORTBSetPinsDigitalOut(BIT_12)
#define LCD_CS_0                mPORTBClearBits(BIT_12)
#define LCD_CS_1                mPORTBSetBits(BIT_12)



void Delay1ms(unsigned int i)
{
    unsigned char j;
  while(i--)
    for(j=0;j<125;j++);
}


void Delay10ms(unsigned int i)
{  while(i--)
  Delay1ms(10);
}

void Delay100ms(unsigned int i)
{  while(i--)
  Delay1ms(100);
}

//*********4W_SPI_Write()
unsigned char SPI_Write(unsigned char dat)
{
    SPI1BUF = dat;                     // write to shift register to begin transmission
    while( !SPI1STATbits.SPIRBF);    // wait for transfer to complete
    return SPI1BUF;
}

//////////////SPI Write command
void LCD_CmdWrite(unsigned char cmd)
{

        LCD_CS_0;
  //SPI_Delay();
  SPI_Write(0x80);
  SPI_Write(cmd);
        LCD_CS_1;  
}

//////////////SPI Write data or  parameter
void LCD_DataWrite(unsigned char Data)
{
        LCD_CS_0;
  SPI_Write(0x00);
  SPI_Write(Data);
        LCD_CS_1;
}


///////////////Background color settings
void Text_Background_Color1(unsigned int b_color)
{

  LCD_CmdWrite(0x60);//BGCR0
  LCD_DataWrite((unsigned char)(b_color>>11));

  LCD_CmdWrite(0x61);//BGCR0
  LCD_DataWrite((unsigned char)(b_color>>5));

  LCD_CmdWrite(0x62);//BGCR0
  LCD_DataWrite((unsigned char)(b_color));
}


////////////////Write command and parameter
void Write_Dir(unsigned char Cmd,unsigned char Data)
{
  LCD_CmdWrite(Cmd);
  LCD_DataWrite(Data);
}

/////////////PLL setting
void PLL_ini(void)
{
    LCD_CmdWrite(0x88);
    LCD_DataWrite(0x0a);

    Delay1ms(1);
    LCD_CmdWrite(0x89);
    LCD_DataWrite(0x02);
    Delay1ms(1);
}

/////////////LCM initial
void LCD_Initial(void)
{

        PLL_ini();
  LCD_CmdWrite(0x10);   //SYSR   bit[4:3]=00 256 color  bit[2:1]=  00 8bit MPU interface
  LCD_DataWrite(0x0C);   //                 1x 64k color             1x  16bit

  LCD_CmdWrite(0x04);    //PCLK
  LCD_DataWrite(0x82);   //
//        DelayMs(1);
        Delay1ms(1);

  //Horizontal set
  LCD_CmdWrite(0x14);   //HDWR//Horizontal Display Width Setting Bit[6:0]
  LCD_DataWrite(0x3b); //Horizontal display width(pixels) = (HDWR + 1)*8       0x27
  LCD_CmdWrite(0x15);   //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
  LCD_DataWrite(0x02); //(HNDR + 1)*8 +HNDFCR
  LCD_CmdWrite(0x16);   //HNDR//Horizontal Non-Display Period Bit[4:0]
  LCD_DataWrite(0x03); //Horizontal Non-Display Period (pixels) = (HNDR + 1)*8
  LCD_CmdWrite(0x17);   //HSTR//HSYNC Start Position[4:0]
  LCD_DataWrite(0x01); //HSYNC Start Position(PCLK) = (HSTR + 1)*8
  LCD_CmdWrite(0x18);   //HPWR//HSYNC Polarity ,The period width of HSYNC.
  LCD_DataWrite(0x03); //HSYNC Width [4:0]   HSYNC Pulse width(PCLK) = (HPWR + 1)*8

  //Vertical set
  LCD_CmdWrite(0x19); //VDHR0 //Vertical Display Height Bit [7:0]
  LCD_DataWrite(0x0f); //Vertical pixels = VDHR + 1  0xef
  LCD_CmdWrite(0x1a); //VDHR1 //Vertical Display Height Bit [8]
  LCD_DataWrite(0x01); //Vertical pixels = VDHR + 1   0x00
  LCD_CmdWrite(0x1b); //VNDR0 //Vertical Non-Display Period Bit [7:0]
  LCD_DataWrite(0x0F); //Vertical Non-Display area = (VNDR + 1)
  LCD_CmdWrite(0x1c); //VNDR1 //Vertical Non-Display Period Bit [8]
  LCD_DataWrite(0x00); //Vertical Non-Display area = (VNDR + 1)
  LCD_CmdWrite(0x1d); //VSTR0 //VSYNC Start Position[7:0]
  LCD_DataWrite(0x0e); //VSYNC Start Position(PCLK) = (VSTR + 1)
  LCD_CmdWrite(0x1e); //VSTR1 //VSYNC Start Position[8]
  LCD_DataWrite(0x06); //VSYNC Start Position(PCLK) = (VSTR + 1)
  LCD_CmdWrite(0x1f);   //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
  LCD_DataWrite(0x01); //VSYNC Pulse Width(PCLK) = (VPWR + 1)

  LCD_CmdWrite(0x8a);//PWM setting
  LCD_DataWrite(0x80);
  LCD_CmdWrite(0x8a);//PWM setting
  LCD_DataWrite(0x81);//open PWM
  LCD_CmdWrite(0x8b);//Backlight brightness setting
  LCD_DataWrite(0xff);//Brightness parameter 0xff-0x00
}



void NextStep(void)
{
    Delay1ms(100);
    Delay1ms(100);
    Delay1ms(100);
}


//full display test
void Test(void)
{  ///display red
  Text_Background_Color1(color_red);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display green
  Text_Background_Color1(color_green);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display blue
  Text_Background_Color1(color_blue);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display white
  Text_Background_Color1(color_white);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display cyan
  Text_Background_Color1(color_cyan);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display yellow
  Text_Background_Color1(color_yellow);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display purple
  Text_Background_Color1(color_purple);//Background color setting
  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
  ///display black
  Text_Background_Color1(color_blue);//Background color setting
//  Write_Dir(0x8E,0x80);//Began to clear the screen (display window)
  NextStep();
}




 /*
 Initialize SPI module in pic32
 */
 void InitSPI(void)
 {
 // 8 Bit, Master-Mode, eanable SPI-1
 // nano_CS_LAT_BIT=1;      //nano deselected
// OpenSPI1(SPI_MODE16_ON | MASTER_ENABLE_ON , SPI_ENABLE);

     /* Idle state for clock is high, active is low
     /* Transmit happens from active clock state to idle clock state*/


// OpenSPI1(SPI_MODE8_ON | MASTER_ENABLE_ON  | CLK_POL_ACTIVE_LOW | SPI_CKE_ON, SPI_ENABLE);
 OpenSPI1(SPI_MODE8_ON | MASTER_ENABLE_ON  | CLK_POL_ACTIVE_LOW | SPI_CKE_ON  | SEC_PRESCAL_1_1 | PRI_PRESCAL_4_1 | SPI_SMP_ON , SPI_ENABLE);
//     OpenSPI1(SPI_MODE8_ON | MASTER_ENABLE_ON  | CLK_POL_ACTIVE_HIGH | SPI_CKE_ON | SEC_PRESCAL_8_1 | PRI_PRESCAL_16_1, SPI_ENABLE);
 ConfigIntSPI1(SPI_TX_INT_EN | SPI_RX_INT_EN | SPI_FAULT_INT_EN);
// EnableIntSPI1;
 }
//
////////////////Foreground color settings
void Text_Foreground_Color1(unsigned int b_color)
{

  LCD_CmdWrite(0x63);//BGCR0
  LCD_DataWrite((unsigned char)(b_color>>11));

  LCD_CmdWrite(0x64);//BGCR0
  LCD_DataWrite((unsigned char)(b_color>>5));

  LCD_CmdWrite(0x65);//BGCR0
  LCD_DataWrite((unsigned char)(b_color));
} 

 
/*
 * 
 */
int main() {
    LCD_CS_OUT;
    InitSPI();
    LCD_CS_1;

        Delay100ms(5);

  LCD_Initial();

  Write_Dir(0x01,0x80);//display on

        while(1)
        {
            //full display test
       Test();
                         Text_Foreground_Color1(color_white);//Set the foreground color
       Text_Background_Color1(color_black);//Set the background color

        }


}

[marcel (Gast)]

Konkret bleiche ich immer in der Schleife:

//*********4W_SPI_Write()
unsigned char SPI_Write(unsigned char dat)
{
    SPI1BUF = dat;                     // write to shift register to begin transmission
    while( !SPI1STATbits.SPIRBF);    // wait for transfer to complete
    return SPI1BUF;
}

Irgendetwas muss mit den SPI Leitungen/Initialisierunge noch im Argen 
sein. Jemand der sich mit dem Controller auskennt und auf Anhieb eine 
Idee hat?

[marcel (Gast)]

Niemanden, dem etwas auffällt oder ne Idee hat, welche SPI 
Konfigurationen fehlerhaft sein könnten?

[grundschüler (Gast)]

hast du die Reset-Leitung des Lcd verbunden? Ohne Reset funktionieren 
die meisten lcds nicht.

[Michael K. (Gast)]

Such Dir das Datenblatt zum RA8875.
Überprüfe auf welche Betriebsart der auf dem Display eingestellt ist und 
dann schau Dir an was der genau erwartet.

Das ist die einzige Möglichkeit weiter zu kommen wenn Du nicht auf 
fertige LIBs setzen kannst oder der Chip einfach nicht mit Dir spricht.

Die Hersteller verwenden gerne wohl klingende Namen für Ihre 
Ansteuerungen, die sich dann nur leider völlig anders verhalten als es 
ein z.B. SPI normalerweise tut.
Die Dokumentation der Displays ist oft so schlecht das man gerade noch 
erfährt wie der Controller heißt, aber schon nicht mehr wie der 
gejumpert ist.

Schau Dir auch mit dem Oszi an was wirklich an Signalen bei Dir 
rauskommt sonst kannst Du bis in alle Ewigkeit die Fehler suchen.

Als letzte Lösung frage beim Hersteller nach Code zum Testen.
Eine Handvoll 8051 ASM Code war für mich mal die einzige Möglichkeit 
herauszufinden wie der Dreck angesteuert wird.

[Purzel H. (hacky)]

Nochwas. Das Reset timing ist immer etwas speziell : Plane eine lange 
Zeit fuer die Reset sequenz, gemaess Datenblatt. Dass kann schon mal 
100ms nach Powerup oder dem ersten Befehl sein.
Und. Warte nicht auf das Display. Die Ready Leitung kannst du vergessen. 
Machs mit einem Timer. Dh einem timerinterrupt. Ich verwende eine 
Display Statusmaschine, die wird alle 10ms zu meinem Tick im main einen 
Schritt weitergefuehrt. Dh alle 10ms geht ein Befehl raus. Das kann 
Cursor Position, oder Daten sein. Ich mach so alle 500ms einen refresh 
eines Character displays. Fuer einen graphischen display geht man dann 
vielleicht auf 1ms oder so.

[grundschüler (Gast)]

pol und pha stimmen?

hat dein controller vielleicht einen fifo? dann sieht die Spi-routine 
mglw. anders aus, weil der fifo geleert werden muss.

Zum testen kannst du statt des hw-spi einen sw-spi einsetzen. das müsste 
dann einfacher funktionieren:

#define pol 0
#define pha 0
char SWSPI_Transfer (char SPI_byte)
{
 unsigned char SPI_count; // counter for SPI transaction
 for (SPI_count = 8; SPI_count > 0; SPI_count--) // single byte SPI loop
 {
#if pha==0
if(SPI_byte & 0x80){swmosi_h;}else{swmosi_l;}
#endif
      #if pol
      swsck_l; // set SCK high
      #else
      swsck_h; // set SCK high
      #endif

#if pha==0
SPI_byte = SPI_byte << 1; // shift next bit into MSB
if(swmiso_v) SPI_byte++; // capture current bit on MISO
#else
if(SPI_byte & 0x80){swmosi_h;}else{swmosi_l;}
#endif

      #if pol
      swsck_h; // set SCK high
      #else
      swsck_l; // set SCK high
      #endif
#if pha==1
SPI_byte = SPI_byte << 1; // shift next bit into MSB
if(swmiso_v) SPI_byte++; // capture current bit on MISO
#endif
}
return (SPI_byte);
} // END SPI_Transfer

[grundschüler (Gast)]

pardon, ich

grundschüler schrieb:
> zum testen kannst du statt des hw-spi einen sw-spi einsetzen

pardon, du willst ja den sw-spi durch einen hw-spi ersetzen. 
Funktioniert es denn mit dem sw-spi?

[marcel (Gast)]

SW-SPI funktioniert, aber das ist nicht das was ich gerne möchte. Es ist 
ja eine Beispiel Routine unter dem obigen Link gepostet -> Diese 
funktioniert auch, aber ich persönlich finde das etwas unschön. Ich habe 
eigentlich nur die

unsigned char SPI_Write(unsigned char dat)

Routine umgeschrieben.

Ist die Reset Leitung Pflicht?
Im Datenblatt des Controllers steht die Reset Leitung nicht als Belegung 
mit dabei, ebenso wird sie in der Beispielroutine nicht verwendet.

[grundschüler (Gast)]

marcel schrieb:
> Ist die Reset Leitung Pflicht?

wenn das lcd mit dem sw-spi funktioniert reicht das An- und Ausschalten 
offenbar für den lcd-reset, kannst du dann so lassen.

für hw-spi pha, pol und fifo prüfen, dann müsste es gehen