Kommunikation Xmega <--> Stm32f4

[Wanninger (Gast)]

Hallo Leute,

Bin gerade auf der Suche nach einem Weg einen 9 Bit Wert
schnellstmöglich von einem Xmega zu einem Stm32F4 zu übertragen.

Der erste Gedankengang wäre erstmal ein 9 Bit parallelinterface gewesen,
mit 2 zusätzlichen Statusleitungen (DREQ und DRDY).

Jetzt stellt sich die Frage wie ich im Xmega am besten mit der DREQ 
Anfrage
Umgehe, ein interrupt wird mit den ca. 20 Takten latenzzeit zu langsam 
sein.

DMA kann wahrscheinlich nur mit 8 Bit umgehen, da hab ich mich aber noch 
nicht genügend befasst damit...

Polling würde zuviel Ressourcen verbrauchen.

Habt ihr schonmal eine ähnliche Anforderung gehabt?

Noch ein paar Details zur Anwendung:

Xmega:
32 MHz

Quadratureencoderintereface zum Stm32 da dieser leider keinen 
Indexeingang
zur Verfügung stellt und die Interruptindexlösung im Stm32 für diese 
Anwendung nicht in frage kommt.

Stm32:
168 MHz

Einlesen des 9 Bit Wertes Weiterverarbeitung...

[Falk B. (falk)]

@ Wanninger (Gast)

>Bin gerade auf der Suche nach einem Weg einen 9 Bit Wert
>schnellstmöglich von einem Xmega zu einem Stm32F4 zu übertragen.

Was ist den der Gesamtsinn dieser Datenübertragung? Siehe 
Netiquette.

https://www.mikrocontroller.net/articles/Netiquette#Klare_Beschreibung_des_Problems

>Der erste Gedankengang wäre erstmal ein 9 Bit parallelinterface gewesen,
>mit 2 zusätzlichen Statusleitungen (DREQ und DRDY).

Kann man machen.

>Jetzt stellt sich die Frage wie ich im Xmega am besten mit der DREQ
>Anfrage
>Umgehe, ein interrupt wird mit den ca. 20 Takten latenzzeit zu langsam
>sein.

Wwenn es sowieso so schnell wie nur irgend möglich sein soll, nutzt man 
so oder so keine Interrupt sondern läßt den Xmega in einer Schleife 
rödeln.

>Polling würde zuviel Ressourcen verbrauchen.

Welche denn? CPU Zeit? Du willst doch so schnell wie möglich sein, da 
MUSS die CPU 100% Power investieren.

>Habt ihr schonmal eine ähnliche Anforderung gehabt?

Ja.

>Quadratureencoderintereface zum Stm32 da dieser leider keinen
>Indexeingang
>zur Verfügung stellt und die Interruptindexlösung im Stm32 für diese
>Anwendung nicht in frage kommt.

Aha. Du willst also mit dem Xmega einen Quadraturencoder mit Index 
einlesen und an den STM32 senden. Das macht man sinnvollerweise aber so, 
das der Xmega den STM32 sinnvoll entlastet, sonst hat man ja nichts 
gewonnen!

>Einlesen des 9 Bit Wertes Weiterverarbeitung...

Das schafft man relativ einfach und resourcenschonenend mit dem UART. 
Der kann 9 Bit Werte senden, wenn es sein muss auch mit mehreren Mbit/s. 
Den kann vor allem der STM32 relativ einfach per Interrupt oder gar DMA 
empfangen.

[Dr. Sommer (Gast)]

Wanninger schrieb:
> Quadratureencoderintereface zum Stm32 da dieser leider keinen
> Indexeingang
> zur Verfügung stellt

Kannst du nicht mit einem zusätzlichen Input Capture Channel das 
aktuelle Counter Register speichern wenn der Indexeingang sich ändert? 
Oder alternativ einfach einen DMA per Timer auslösen und den aktuellen 
Wert sichern lassen? Ansonsten, die Interrupt-Latenz ist beim F4 12 
Takte, sicher dass das nicht reicht?

Wanninger schrieb:
> DMA kann wahrscheinlich nur mit 8 Bit umgehen, da hab ich mich aber noch
> nicht genügend befasst damit...
Beim Xmega kenn ich mich nicht aus, aber DMA kann typischerweise mehr 
als nur ein Speicherwort (egal ob das jetzt 8 oder 32 bit groß ist) 
kopieren, denn sonst wäre das ja ziemlich sinnlos. Du solltest den DMA 
anweisen können zwei Werte (Port-Inputs) kopieren zu können.
Alternativ nimmst du halt keinen Xmega, sondern noch einen STM32(F0 oder 
so), dessen DMA kann sowieso 32bit. Den kannst du dann ja auch 100% 
auslasten mit der Drehencoder-Abfrage, wobei ich nicht glaube dass das 
nötig ist...

[Wanninger (Gast)]

Hallo,

vielen Dank für eure Antworten,

nun habe ich versucht den Registerinhalt vom
Quadraturezählregister TCD1_CNT per DMA parallel vom
PORTA ausgeben zu lassen, was auch wunderbar funktioniert,
leider funktioniert das nur beim lowbyte des Counterregisters.

Das highbyte des Counterregisters soll am PORTB ausgegeben werden.

Hat von euch jemand eine Ahnung wie ich speziell das Highbyte des
Counterregisters per DMA übertragen kann?

anbei der Code:

EVSYS_CH2MUX = 0x8C;            //CPU / 4096
  
  DMA_CTRL |= (1<<7);              //DMA Enable
  DMA_CH0_CTRLA |= (1<<7) | (1<<5);      //repeat mode; DMA CH0 Enable
  DMA_CH0_TRIGSRC = 0x03;            //EVSYS CH2 
  //DMA_CH0_TRFCNT = 0x0001;
    
  DMA_CH0_SRCADDR0 = 0x60;          //Source = TCD1.CNT
  DMA_CH0_SRCADDR1 = 0x09;
  DMA_CH0_SRCADDR2 = 0x00;
  
  DMA_CH0_DESTADDR0 = 0x04;            //Destination = PORTA.OUT
  DMA_CH0_DESTADDR1 = 0x06;
  DMA_CH0_DESTADDR2 = 0x00;

[Wanninger (Gast)]

Hallo Leute,

Werde jetzt doch die Lösung mit dem stm32f4 und dem Timer capture
+ interrupt nehmen, muss dann halt eine genaue interrupt laufzeitanalyse 
+ prioritätsanalyse anstellen.

Das Problem ist halt die Zeitkritische Anwendung selbst und ich wollte 
mir mit der externen vorverarbeitung per Xmega eine zusätzliche 
Fehlerquelle wegstreichen...


Vielen Dank für eure Unterstützung!

[Ursus P. (unwichtig)]

SPI? STM32 als Slave rappeln lassen?