Stm32f103 Problem mit Spi2

[grundschüler (Gast)]

ich versuche inzwischen schon länger, bei einem stm32f103VET8 spi2 in 
Gang zu setzen. Diese thread nicht weiter: 
Beitrag "STM32 - SPI2 will nicht"

Ich habe den code alternativ auf spi1 umgestellt und umgelötet - das lcd 
läuft auf anhieb.

Was ist an meinem spi2-code falsch bzw. anders als am spi1-code, der 
funktioniert?

#define xspi2 0
void lcd_spi_write(u8 dat){
#if xspi2
  SPI2->DR=dat;
  while (SPI2->SR & 1<<(7)) ;
  return SPI2->DR;
#else
  SPI1->DR=dat;
  while (SPI1->SR & 1<<(7)) ;
  return SPI1->DR;
#endif
}

void lcd_spi_init()
{
  SPI_InitTypeDef  SPI_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Configure SPI1 pins: SCK and MOSI with default alternate function (not remapped) push-pull */
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
#if xspi2
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
#else
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif

  /* Configure MISO as Input with internal pull-up */
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

#if xspi2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
#else
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
 GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif

      SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
      SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
      SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
      SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
      SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
      SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
      SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
      SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
      SPI_InitStructure.SPI_CRCPolynomial = 7;


#if xspi2
 SPI_Init(SPI2, &SPI_InitStructure);
 SPI_CalculateCRC(SPI2, DISABLE);
 SPI_Cmd(SPI2, ENABLE);
#else
SPI_Init(SPI1, &SPI_InitStructure);
 SPI_CalculateCRC(SPI1, DISABLE);
 SPI_Cmd(SPI1, ENABLE);
 #endif
}


int main(void){
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

#if xspi2
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
#else
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
#endif
    lcd_CS_INIT();
    lcd_CS_HIGH();
    lcd_spi_init();
    lcd_init();
    lcd_clear(RED);


    while(1){

 /*   nur zum testen
  lcd_CS_HIGH();
      lcd_spi_write(0x0f);
      wait;
      lcd_CS_LOW();
         lcd_spi_write(0xf0);
     wait;*/
    }
}

[hp-freund (Gast)]

#define xspi2 0
und
#if xspi2

kontrollier das mal.

[Martin (Gast)]

Gebe meinem Vorredner recht:

#define xspi2
void lcd_spi_write(u8 dat){
#ifdef xspi2
  SPI2->DR=dat;
  while (SPI2->SR & 1<<(7)) ;
  return SPI2->DR;
#else
  SPI1->DR=dat;
  while (SPI1->SR & 1<<(7)) ;
  return SPI1->DR;
#endif
}

void lcd_spi_init()
{
  SPI_InitTypeDef  SPI_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Configure SPI1 pins: SCK and MOSI with default alternate function (not remapped) push-pull */
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
#ifdef xspi2
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
#else
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif

  /* Configure MISO as Input with internal pull-up */
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

#ifdef xspi2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
#else
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
 GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif

      SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
      SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
      SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
      SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
      SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
      SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
      SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
      SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
      SPI_InitStructure.SPI_CRCPolynomial = 7;


#ifdef xspi2
 SPI_Init(SPI2, &SPI_InitStructure);
 SPI_CalculateCRC(SPI2, DISABLE);
 SPI_Cmd(SPI2, ENABLE);
#else
SPI_Init(SPI1, &SPI_InitStructure);
 SPI_CalculateCRC(SPI1, DISABLE);
 SPI_Cmd(SPI1, ENABLE);
 #endif
}


int main(void){
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

#ifdef xspi2
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
#else
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
#endif
    lcd_CS_INIT();
    lcd_CS_HIGH();
    lcd_spi_init();
    lcd_init();
    lcd_clear(RED);


    while(1){

 /*   nur zum testen
  lcd_CS_HIGH();
      lcd_spi_write(0x0f);
      wait;
      lcd_CS_LOW();
         lcd_spi_write(0xf0);
     wait;*/
    }
}

[hp-freund (Gast)]

oder auch xspi2 ungleich 0 definieren...

[grundschüler (Gast)]

hp-freund schrieb:
> #define xspi2 0
> und
> #if xspi2
>
> kontrollier das mal.

das ist nur das define, um zwischen spi1 und spi2 umzuschalten:

#define xspi2 0 => führt den code für SPi1 aus
#define xspi2 1 => führt den code für SPi2 aus

Irgendwo muss ein Fehler im code für Spi2 sein, obwohl er entsprechend 
dem spi1-code aufgebaut ist. Es kommen zwar Signale auf sck, mosi und 
cs, aber das lcd wird nicht initialisiert.

[hp-freund (Gast)]

Wissen auch alle deine lcd_xx Funktionen das sie auf SPI2 zugreifen 
sollen?

[grundschüler (Gast)]

hp-freund schrieb:
> Wissen auch alle deine lcd_xx Funktionen das sie auf SPI2 zugreifen
sollen

Es ist doch nur eine einzige lcd-Funktion, die auf Spi zugreift, nämlich 
"lcd_spi_write(dat)", Lesefunktionen gibt es nicht, Miso ist nicht 
verbunden. lcd_spi_write sollte das eigentlich wissen.

[hp-freund (Gast)]

Was ist mit:
lcd_CS_INIT();
lcd_CS_HIGH();
lcd_CS_LOW();
lcd_init();
?

[grundschüler (Gast)]

hp-freund schrieb:
> lcd_CS_INIT();
> lcd_CS_HIGH();
> lcd_CS_LOW();
> lcd_init();

#define lcd_CS_port     B
#define lcd_CS_pin      6
#define lcd_CS_INIT()    pinDIRout(lcd_CS_port,lcd_CS_pin)  
#define lcd_CS_HIGH()    pinSET(lcd_CS_port,lcd_CS_pin);spimode_0
#define lcd_CS_LOW()    pinCLR(lcd_CS_port,lcd_CS_pin);spimode_3

kann nicht Fehlerursache sein, weil durch den Wechsel von spi1 auf spi2 
nicht beeinflusst. cs funktioniert,  lcd_init ist für spi1 u. spi2 
identisch.

Ich muss wohl das Signal, das bei spi2/mosi/sck rauskommt, genauer 
untersuchen. Mit meinem china-dso geht das leider nicht. Vielleicht ein 
zweiter uc als slave.

[hp-freund (Gast)]

grundschüler schrieb:
> lcd_init ist für spi1 u. spi2 identisch.

Wirklich? Zeig mal.
Ist da nicht etwas in der Art von Display_IoInit_If() drin?

[Jojo S. (Gast)]

Martin schrieb:
> while (SPI2->SR & 1<<(7)) ;

#define  SPI_SR_TXE  ((uint8_t)0x02)      /*!< Transmit buffer Empty */

Bit7 ist das Busy Flag, vor dem Senden soll aber das TX Empty abgefragt 
werden.

[grundschüler (Gast)]

hp-freund schrieb:
> Display_IoInit_If

Jojo S. schrieb:
> Bit7 ist das Busy Flag, vor dem Senden soll aber das TX Empty abgefragt
> werden.

das ist zutreffend. Mit dem busy-flag ist der code mglw. langsamer, 
funktioniert aber sicher. Wenn es mal geht, kann man das optimieren.

hp-freund schrieb:
> Wirklich? Zeig mal.

gerne:

void lcd_init(void)
{
lcd_spi_init();
//Portrait//landscape

#if ( DISP_ORIENTATION == 0 )//0° grad
    lcd_write_reg(0x0003,(1<<12) );   /* importance */
#endif
#if ( DISP_ORIENTATION == 1 )//90°
    lcd_write_reg(0x0003,(1<<12)|(1<<5)|(1<<3) );   /* importance */
#endif
#if ( DISP_ORIENTATION == 2 )//180°
    lcd_write_reg(0x0003,(1<<12)|(1<<4)|(1<<5) );   /* importance */
#endif
#if ( DISP_ORIENTATION == 3 )//270°
    lcd_write_reg(0x0003,(1<<12)|(1<<4)|(1<<3) );   /* importance */
#endif

    lcd_write_reg(0x04,0x0000); /* Scalling Contral */
    lcd_write_reg(0x08,0x0202); /* Display Contral 2 */
    lcd_write_reg(0x09,0x0000); /* Display Contral 3 */
    lcd_write_reg(0x0a,0x0000); /* Frame Cycle Contal */
    lcd_write_reg(0x0c,(1<<0)); /* Extern Display Interface Contral 1 */
    lcd_write_reg(0x0d,0x0000); /* Frame Maker Position */
    lcd_write_reg(0x0f,0x0000); /* Extern Display Interface Contral 2 */     
    _delay_ms(50); 
    lcd_write_reg(0x07,0x0101); /* Display Contral */
    _delay_ms(50);    
    lcd_write_reg(0x10,(1<<12)|(0<<8)|(1<<7)|(1<<6)|(0<<4)); /* Power Control 1 */
    lcd_write_reg(0x11,0x0007);                              /* Power Control 2 */
    lcd_write_reg(0x12,(1<<8)|(1<<4)|(0<<0));                /* Power Control 3 */
    lcd_write_reg(0x13,0x0b00);                              /* Power Control 4 */
    lcd_write_reg(0x29,0x0000);                              /* Power Control 7 */
    lcd_write_reg(0x2b,(1<<14)|(1<<4)); 
  
    lcd_write_reg(0x50,0);       /* Set X Start */
    lcd_write_reg(0x51,239);      /* Set X End */
    lcd_write_reg(0x52,0);      /* Set Y Start */
    lcd_write_reg(0x53,319);      /* Set Y End */
  _delay_ms(50);
    lcd_write_reg(0x60,0x2700); /* Driver Output Control */
    lcd_write_reg(0x61,0x0001); /* Driver Output Control */
    lcd_write_reg(0x6a,0x0000); /* Vertical Srcoll Control */
    
    lcd_write_reg(0x80,0x0000); /* Display Position? Partial Display 1 */
    lcd_write_reg(0x81,0x0000); /* RAM Address Start? Partial Display 1 */
    lcd_write_reg(0x82,0x0000); /* RAM Address End-Partial Display 1 */
    lcd_write_reg(0x83,0x0000); /* Displsy Position? Partial Display 2 */
    lcd_write_reg(0x84,0x0000); /* RAM Address Start? Partial Display 2 */
    lcd_write_reg(0x85,0x0000); /* RAM Address End? Partial Display 2 */
    
    lcd_write_reg(0x90,(0<<7)|(16<<0)); /* Frame Cycle Contral */
    lcd_write_reg(0x92,0x0000);         /* Panel Interface Contral 2 */
    lcd_write_reg(0x93,0x0001);         /* Panel Interface Contral 3 */
    lcd_write_reg(0x95,0x0110);         /* Frame Cycle Contral */
    lcd_write_reg(0x97,(0<<8)); 
    lcd_write_reg(0x98,0x0000);         /* Frame Cycle Contral */    
    lcd_write_reg(0x07,0x0133); 
//  }    
    _delay_ms(100);   /* delay 50 ms */    
}

[hp-freund (Gast)]

Wenn das richtige lcd_spi_init(); aufgerufen wird ist das ja schon mal 
in Ordnung.
lcd_write_reg wäre dann die nächste Frage. Geht mir jetzt aber ein wenig 
zu weit.

Ich würde jetzt als Nächstes das lcd_init(); in eine Endlosschleife 
legen und die Ausgaben prüfen.

[grundschüler (Gast)]

hp-freund schrieb:
> Ich würde jetzt als Nächstes das lcd_init(); in eine Endlosschleife
> legen und die Ausgaben prüfen.

danke erstmal für die Unterstützung. Ich habe für heute genug von STM. 
Ich lass das ganze zunächst auf spi1. Vielleicht probier ich das ganze 
mit ein paar Tagen Abstand noch einmal mit spi2.

[Jojo S. (Gast)]

Laut Doku ist das Busy für den Slavemode, der Slave soll das Ende 
signalisieren wenn Busy aus ist.

[grundschüler (Gast)]

Jojo S. schrieb:
> Laut Doku ist das Busy für den Slavemode, der Slave soll das Ende
> signalisieren wenn Busy aus ist.

Der verwendete code stammt von Fat-Elm-Chan, der fragt das bsy-flag ab. 
Müsste eigentlich auch so funktionieren.

Nachdem auch spi1 nicht mehr zuverlässig lief, habe ich die Stm-Vorlage 
ausprobiert:

void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data)
{
  /* Check the parameters */
  assert_param(IS_SPI_ALL_PERIPH(SPIx));
  
  /* Write in the DR register the data to be sent */
  SPIx->DR = Data;
}

Diese ist etwa 10% langsamer, der Chip lässt sich aber mit hw-spi - 
zumindest spi1 - wieder programmieren.  Möglicherweise ist dieses 
merkwürdige stm-assert_param für den zuverlässigen Betrieb erforderlich.

[Jojo S. (Gast)]

das assert prüft nur ob der parameter ein gültiger Pointer ist, also 
&SPI1, 2 oder 3.
ST erwähnt im Handbuch mehrfach das TXE Flag zu verwenden, warum sollen 
die lügen?
'Note: Do not use the BSY flag to handle each data transmission or 
reception. It is better to use the
TXE and RXNE flags instead.'
'Note: The software must ensure that the TXE flag is set to 1 before 
attempting to write to the Tx
buffer. Otherwise, it overwrites the data previously written to the Tx 
buffer.'

Ein Unterschied ist ja noch das SPI1/2 um den Faktor 2 unterschiedlich 
schnell sind, da kann das durchaus ein Timingproblem sein. Du hast ja 
geschrieben das auch Daten gesendet werden, aber falsche. Das wäre der 
Effekt wenn die Daten schon während der Übertragung verändert werden.
Hast du denn schon probiert das TXE Flag anstelle des BSY abzufragen?

[grundschüler (Gast)]

Jojo S. schrieb:
> TXE Flag anstelle des BSY

Ich habe alle erdenklichen Variationen TXE RXNE BSY ausprobiert. 
Prescaler zwischen 2 und 256.

Das Problem ist, dass der Fehler nicht 100% reproduzierbar ist. D.h. 
identischer code geht mal, beim nächsten Flashen dann wieder nicht. 
Gerade funktioniert das LCD mit Prescaler_2/kompletter Bildaufbau 
0,17sec recht ordentlich. Als nächstes werde ich den enc28j60 
anschließen. Probleme gibts dann wahrscheinlich mit dem Wechsel zwischen 
Spimode_0 und Spimode_3.

[grundschüler (Gast)]

habe das Projekt noch mal neu aufgesetzt. Auf einmal gehts. Bildaufbau 
0,11sec mit optimiertem code:

#if STM32F103==1 && use_bitbang==0
  SPI2->CR1 |=  _BV(11);  /* Set SPI to 16-bit mode */

  for( index = 0; index < ((uint32_t)lcd_max_width*lcd_min_width); index++ )  {
      while ((SPI2->SR & _BV(1))) ;//0_rxne 1_txe 7_bsy
      SPI2->DR = Color;
    }
    SPI2->DR;//fifo leeren

  SPI2->CR1 &= ~ _BV(11);  /* Set SPI to 8-bit mode */
#else
...

[hp-freund (Gast)]

Schön.
Auch wenn das mit dem code von oben recht wenig zu tun hat :-)

[grundschüler (Gast)]

Das Problem war, dass sich
     SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
nicht mit der txe/rxne-abfrage verträgt.

     while ((SPI2->SR & _BV(1))) ;//0_rxne 1_txe 7_bsy
ist offensichtlich falsch. gewartet werden soll, solange tx not empty 
ist.

er funktionierte zeitweilig aber trotzdem: Stm-Mysterium

Im fullduplex-modus funktioniert es dann einwandfrei. Entschädigt wird 
man durch eine enorme spi-Geschwindigkeit: 100-facher Bildaufbau in 
7sec.

[Jojo S. (Gast)]

Wäre vielleicht noch durch DMA zu toppen? Allerdings sind 36 MHz SPI 
auch schon recht zügig, wieviel verträgt das Display denn?
Jedenfalls danke für die Auflösung. Wenn ich meinen STM mal wieder 
rauskrame erinnere ich mich hoffentlich noch an diesen Thread :-)

[grundschüler (Gast)]

Jojo S. schrieb:
> 36 MHz SPI

240x320x2Bytesx100/7sec ~=2,2 Mbyte/sec. Ein bischen 
TFT-Register-Überbau ist noch dabei. Der Stm ist jedenfalls deutlich 
schneller als ein 100-Mhz LPC1768 mit dem gleichen Code (10sec per SSP).

DMA ist der übernächste Schritt, jetzt kommt erstmal sdio.

[Jojo S. (Gast)]

grundschüler schrieb:
> Der Stm ist jedenfalls deutlich
> schneller als ein 100-Mhz LPC1768 mit dem gleichen Code (10sec per SSP).

Das passt, der LPC kann max 12,5 MHz, der STM 18 MHz. Ist also 44 % 
schneller und damit werden aus 7 s dann 10 s.
Mehr geht also nicht, beim STM und SPI1 musst du min. einen Teiler von 4 
einstellen um nicht über die 18 MHz zu kommen. Die ~2,2 MB/s sind ~17,6 
MHz, also schon am Limit. Die CPU ist jetzt allerdings nur mit dem 
Display beschäfftigt, wäre die beim DMA frei für andere Rechnerei oder 
wird der Bus trotzdem (teilweise) blockiert?
Beim SPI Takt ist mir noch aufgefallen das tw (Pulsweite SCK) mit 50-60 
ns angegeben ist, wie geht das bei 18 MHz Takt (= 55 ns Periodendauer)?

Nachtrag:
wobei die 12,5 MHz beim LPC nur für die SPI Schnittstelle gelten, die 
SSP die auch SPI kann soll 50 MBit/s schaffen. Ganz schön verwirrend das 
SPI Zeugs.

[grundschüler (Gast)]

Jojo S. schrieb:
> SPI1 musst du min. einen Teiler von 4

das mit den unterschiedlichen Geschwindigkeiten zwischen spi1 und spi2 
habe ich im manual nicht gefunden. Das TFT hängt jetzt an spi2. Ich 
werde das aber noch einmal wechseln und bei spi1 verschiedene 
Geschwindigkeiten ausprobieren. Vielleicht geht die Begrenzung aber auch 
über die Stm-assert-Parameter. Für irgendwas müssen die ja nützlich 
sein.

> wäre die beim DMA frei für andere Rechnerei
müsste eigentglich so sein, es gibt ja auch mehrere AHB-Busse.

> 12,5 MHz beim LPC nur für die SPI Schnittstelle
Kann ich nicht bestätigen. LPC-Spi ist gefühlt deutlich langsamer. SSP 
war bei 10sec. Wenn ich mein Projekt fertig habe, werde ich mal die 
verschiedenen Geschwindigkeiten bitbang/hwSpi für avr stm und lpc 
gegenüberstellen.

Weißt du wie das mit spi3 und der SWD-Programmierschnittstelle -beide 
A13,A14 - läuft? Kann man dann nicht mehr programmieren?

An spi3 soll ein At45DB32MBit-Speicher, der würde das Board deutlich 
aufwerten:
http://www.ebay.de/itm/291221786470?_trksid=p2057872.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT

[grundschüler (Gast)]

Mysterium spi2: Mit einem mal ging nichts mehr auf spi2. Mittels 
spi-Selbsttestprogramm konnte festgestellt werden, dass spi2 erst dann 
anläuft, wenn nach der Initialisierung nochmals die spi2-Geschwindigkeit 
mit
SPI2->CR1|=7<<3;// /256
eingestellt wird. Warum, ist für mich nicht nachvollziehbar, denn in der 
Initialisierung war das schon genau so drin:
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;

Der Spi-Selbsttest:

#if zucSTM32
//input-Register
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin = 0xffff;
GPIO_Init(GPIO(E), &GPIO_InitStructure);


u8 r=0;
n=0;
SPI2->CR1&=~(7<<3);
lcd_clear(GRAY0);
//spi_SLOW();

//SPI_Cmd(SPI2, DISABLE);
SPI1->CR1|=7<<3;// /256 fullspeed==0<<3
SPI2->CR1|=7<<3;// /256 fullspeed==0<<3
//SPI_Cmd(SPI2, ENABLE);

//while(PIND&0x10);//warten auf cs low
while(GPIOE->IDR&_cs);


//cli();

//SPDR=0b01010101;
SPI1->DR=0b01010101;
SPI2->DR=0b01010101;
while(
//!cs_val &&
n < maxarray){//beschreiben des Speichers
//array[n]=PIND;
array[n]=GPIOE->IDR;
n++;
}

//sei();

//spi_FAST();
SPI1->CR1&=~(7<<3);// /4 fullspeed
SPI2->CR1&=~(7<<3);SPI2->CR1|=(1<<3);// 
for (i=0;i<120;i++){
tmp=array[i];
  ck=(tmp&(_ck))<<4;//16
  lcd_pixel(i+1,150-ck,BLACK);
  if (old_ck!=ck){//bei Sprung
    for(j=0;j<16+1;j++)lcd_pixel(i,150-j,BLACK);
  }//sprung
  old_ck=ck;


  mosi=(tmp&(_mosi));//16
  lcd_pixel(i+1,170-mosi,RED);
  if (old_mosi!=mosi){//bei Sprung
    for(j=0;j<16+1;j++)lcd_pixel(i,170-j,RED);
  }
  old_mosi=mosi;

  cs=(tmp&(1<<0));//16
  lcd_pixel(i+1,190-cs,GREEN);
}//for

//Auswertung
old_ck=255;
for (n=0;n<120;n++)
{
tmp=array[n];
ck=tmp&_ck;
mosi=(tmp&(_mosi));
//lgi(1+n%25,14,n);lw("-");lcd_bitweise(tmp);
  if (old_ck<ck){//bei Sprung aufwärts ->2.edge
  r<<=1;  if (mosi) r++;
    for(j=0;j<5+1;j++)lcd_pixel(n,157-j,BLACK);
  }//sprung
  old_ck=ck;
}//for

lg(9,1);lcd_bitweise(r);
#endif

[holger (Gast)]

>Mysterium spi2:

SPI2 läuft ohne Probleme auch ohne Tricks.

[grundschüler (Gast)]

holger schrieb:
>>Mysterium spi2:


es kommt zu Überlagerungen zwischen den spi-Registern. Die 
Geschwindigkeit Spi1 ändert sich über das SPI2-Register:

lcd_init();
SPI2->CR1&=~(7<<3);SPI2->CR1|=(2<<3);// spi2 schnell, spi1 schnell
//SPI1->CR1&=~(7<<3);// spi2 langsam, spi1 langsam
lcd_clear(RED);

[ismaell (Gast)]

holger schrieb:
> Mysterium spi2:
>
> SPI2 läuft ohne Probleme auch ohne Tricks.

So siehts aus.
Ich nutze bei SPI1 eeprom und den enc28j60 und beim spi2 den Touch, ich 
arbeite mit dem STM32F103ZET6.


solche Probleme wie grundschüler hat naja...  .

[grundschüler (Gast)]

ismaell schrieb:
> solche Probleme wie grundschüler hat naja...  .

Danke für diesen Beitrag.

Inzwischen läuft spi2 wieder. Das Problem lag an der Schreibsequenz:

u8 xlcd_spi_write ( u8 dat ){

SPI2->DR = dat;
//_delay_us(50);//ok
while (!(SPI2->SR & 1<<0));//0_rxne 1_txe 7_bsy// ok
//while (!(SPI2->SR & 1<<1));//0_rxne 1_txe 7_bsy//not ok
//  while ((SPI2->SR & _BV(7))) ;//0_rxne 1_txe 7_bsy//not ok
return (u8)SPI2->DR;/**/
//SPI1->DR = dat;
//while (SPI1->SR & _BV(7)) ;
//return (u8)SPI1->DR;
}

Während bei spi1 bsy- und tx-Flag so funktionieren wie man das erwartet, 
geht bei spi2 nur mit dem rx-Flag. Warum, ist mir unerklärlich.