Fifo über SPI verschicken

[Hugo Zahnfee (Gast)]

Hallo,

ich möchte gerne einen Fifo per SPI von einem Slave auf einen Master 
übertragen. Der Fifo auf dem Slave soll slavefifo hier heissen. Die 
Werte in dem slavefifo sind 16bit breit.

Per SPI kann ich nur 8bit Daten versenden. Hat jemand von Euch einen 
Link zu einer fertigen Routine, wie man größere Datenmengen darüber 
versenden kann?

[Hugo Zahnfee (Gast)]

Mein eigenes C-Programm auf dem Slave sieht bisher so aus:

#include "mbed.h"
#include "ringbuffer.h"

SPISlave device(p11, p12, p13, p14);            // mosi, miso, sclk, ssel 
Serial pc(USBTX, USBRX);

RingBuffer mybuffer;

#define order_getfifolength  220
#define order_hole_elemente  221

void SendeElemente(uint16_t Anzahl) {
    uint16_t Zaehler,
             Element_16bit;
    uint8_t  Element1_8bit,
             Element2_8bit;
    
    for (Zaehler=0; Zaehler<Anzahl; Zaehler++) {
        Element_16bit = mybuffer.get();
        Element1_8bit = Element_16bit>>8;
        Element2_8bit = Element_16bit & 0xFF;
        device.reply(Element1_8bit);
        device.reply(Element2_8bit);
    }
}

int main() {
   pc.baud (115200); 
   
   device.frequency(1000000);
   
   pc.format   (8, SerialBase::None, 1);
   uint8_t i, befehl, elem1, elem2;
   
   uint16_t Anz_Elements=0;
   bool DatenSenden;
    
   pc.printf("\n\r  Programm xxx wurde neu gestartet... ");
   
   // Fifo mit Werten fuellen:
   for (i=0; i<30; i++) {
        mybuffer.put(0xF00+i);
        pc.printf("\n\r  (%i)     ", 0xF00+i);
   }
   
   // for (i=0; i<20; i++) { device.reply(i); }
   
   while (1) {   // Hauptschleife
    if (device.receive()) {  // Liegen Daten am SPI-Port an?, if(0)
        befehl = device.read();
        
        switch (befehl) {
            case (order_getfifolength):   
                Anz_Elements = mybuffer.Anzahl();
                elem1 = Anz_Elements>>8;
                elem2 = Anz_Elements & 0xFF;
                pc.printf ("\n\r fifo-laenge (%i),  elem1(%i), elem2(%i)", Anz_Elements, elem1, elem2);
                elem1=70;
                device.reply(elem1);
                device.reply(elem2);
                DatenSenden = true;
                while (DatenSenden) {
                    if (device.receive()) {
                        device.reply(elem2);
                        while (DatenSenden) {
                            // Warten, bis letztes Bit gesendet. 
                            if (device.receive()) {DatenSenden = false;}
                        }
                    } // ende if(device_receive)
                    
                } // Ende while(DatenSenden)
                

                // device.reply(Anz_Elements & 0xFF);
                break;
            case (order_hole_elemente):
                pc.printf ("\n\r hole data aus fifo ...");
                break;
            
        } // Ende switch
    } // Ende if(0)
   
   
   } // Ende Hauptschleife
  
  
}

Mein Pythonprogramm auf dem Raspberry Pi bisher so:

import RPi.GPIO as GPIO

import spidev
import time

val16 = 0b1100001101010101
val16 = 0b0000000100000000

Anzahl_Werte_in_fifo = 30

order_getfifolength = 220
order_hole_elemente = 221


spi = spidev.SpiDev()
spi.open (0, 1)
spi.max_speed_hz = 1000000

#antwort = spi.xfer2([0xFF])
#print (antwort)
#print ("44544")
a = val16>>8
b = val16 & 0xFF
c = (a<<8) + b
#print (bin(val16))
#print (bin(a))
#print (bin(b))
#print (bin(c))

print ("\n spi-readbytes-test:")
#result = spi.readbytes(25)
#print (result)

# Anzahl holende Werte senden:


# Sende Befehl, um Anzahl Elemente in Fifo zu ermitteln:
spi.xfer2([order_getfifolength])
time.sleep(0.01)
result=[]
result.append (spi.readbytes(1)[0])
result.append (spi.readbytes(1)[0])
print (result)
print (spi.readbytes(1))
anzahl = (result[0]<<8)+result[1]
print ("\n Die Anzahl der Elemente im Fifo ist: %s, result(%s)" %(str(anzahl), str(result)) )
time.sleep(1)
spi.xfer2([order_hole_elemente])

# Lese Anzahl der Werte (16bit)
result=[]
result = spi.xfer2([0, 0])
result=[]
result.append(12)
result.append(10)
print (result)
# 2x 8bit-Werte zu 16-bit Zahl zusammenfassen...
Anzahl_Elemente = (result[0]<<8)+result[1]

Anzahl_Elemente=30

Ergebnisse_8bit=[]
Ergebnisse_8bit = spi.readbytes(Anzahl_Elemente*2)
#print (Ergebnisse_8bit)

Ergebnisse_16bit=[]
for j in range (0, Anzahl_Elemente*2, 2):
    Ergebnisse_16bit.append( (Ergebnisse_8bit[j]<<8)+Ergebnisse_8bit[j+1] )

#print (Ergebnisse_16bit)

spi.close()

[Stefan S. (chiefeinherjar)]

Warum nicht einfach 2x 8 Bit versenden und dann beim Empfänger wieder 
zusammensetzen? Bzw. im Zweifelsfalle eben nicht den Hardware-SS-Pin zu 
nehmen sondern eben einen beliebigen anderen Pin und dann eben eben zu 
Beginn der Übertragung diesen Pin auf LOW ziehen, erst die ersten 8 Bit 
und dann die zweiten 8 Bit übertragen und dann diesen Pin eben auf HIGH 
ziehen.

Wo liegt das Problem?

[Hugo Zahnfee (Gast)]

Was ich gut hinbekommen habe, das ist die Zerlegung der 16bit-Werte in 
zwei 8bit-Werte mit dem Shifen >>8 und dem Unden & 0xFF - und das 
Zusammenbauen auf der Master-Seite.

Jetzt geht es darum, eine Möglichkeit zu finden, viele Werte 
hintereinander gut zu übertragen.

Mein Problem ist die Sache mit dem SPI-Port. Ich kann mir die Länge der 
zu übertragenden Daten ermitteln - nehmen wir mal an, ich möchte 30 
Stück aus meinem Fifo lesen.

Also muss der Master 60 mal 8bit-Werte holen (30 mal 16bit aus dem 
Fifo).

Ein einfacher schöner Befehl wäre, wenn ich auf dem Raspberry Pi unter 
Python das machen könnte:

spi.readbytes(Anzahl*2).

Dann bekomme ich eine Liste in Python mit 60 Elementen. Leider 
funktioniert das auf der Slave-Seite nicht, die Daten dann so 
bereitzustellen, dass ich den spi.readbytes-Befehl ausführen kann. Es 
kommt dann nur ein Wert an.

Auf der Slave-Seite muss ich mit dem Befehl

.reply(value); den Wert an den SPI-Port schreiben, damit er bei der 
nächsten Leseoperation ausgewertet werden kann.

Ich komme halt momentan auf keine neue Idee, wie ich das hinkriegen 
kann.

[Hugo Zahnfee (Gast)]

Stefan Schmidt schrieb:
> Warum nicht einfach 2x 8 Bit versenden und dann beim Empfänger wieder
> zusammensetzen?

das klappt ja schon.

Stefan Schmidt schrieb:
> Bzw. im Zweifelsfalle eben nicht den Hardware-SS-Pin zu
> nehmen sondern eben einen beliebigen ...

Meinst Du, ich muss mir einen Software-SPI-Port entwickeln und nicht den 
Hardware-SPI benutzen?

[H. D. (lactobacillus)]

Hugo Zahnfee schrieb:
> Stefan Schmidt schrieb:
>> Bzw. im Zweifelsfalle eben nicht den Hardware-SS-Pin zu
>> nehmen sondern eben einen beliebigen ...
>
> Meinst Du, ich muss mir einen Software-SPI-Port entwickeln und nicht den
> Hardware-SPI benutzen?

Entweder du bleibst bei 8-Bit oder du benutzt ein eigenes 
16-BIT-Software-SPI.

--> Zerleg es is 2 Teile und nimm Hardware-SPI

[Hugo Zahnfee (Gast)]

Die Kombination funktioniert:

Microcontroller (C):

for (i=0; i<30; i++) { device.reply(i); }

Master (Python):

for kkkk in range (0, 30):
    result.append(spi.readbytes(1)[0])

Was nicht geht ist das hier:

Microcontroller(C):

for (i=0; i<30; i++) { device.reply(i); }

Master (Python):

result = spi.readbytes(30)

[/c]


Ich verstehe einfach nicht, warum das mit dem spi.readbytes(30) nicht in 
einem Rutsch funktionieren tut :-(

[Stefan S. (chiefeinherjar)]

In Python kenne ich mich nicht wirklich aus, aber prinzipiell habe ich 
es wie folgt implementiert gehabt:
Ich habe einen beliebigen freien Pin (beispielsweise Pin PC1) mit dem 
SS-Pin vom Slave verbunden. Die restlichen Hardware-SPI-Pins habe ich 
beibehalten und alles entsprechend verkabelt.

Dann habe ich unmittelbar vor dem Aktivieren der Übertragung mittels SPI 
einfach den Pin PC1 auf Low gezogen und die ersten 8 Bit ganz normal 
übertragen.
Nach dem die Übertragung fertig ist wird ja der eigentliche 
Hardware-SS-Pin wieder auf High gezogen. Dies juckt den Slave ja nicht, 
da der Pin PC1 immer noch auf low ist.
Daraufhin habe ich erneut eine SPI-Übertragung mit den zweiten 8 Bit 
gestartet und NACH DEM diese beendet war den Pin PC1 auf High gezogen.

So sieht es für den Slave aus, als ob die 16 Bit am Stück übertragen 
wurden. Hauptsache der SS-Pin VOM SLAVE ist Low während der gesamten 
Übertragung(en).

[Stefan S. (chiefeinherjar)]

In C würde das, was ich beschrieben habe so aussehen, wobei "command" 
der 16 Bit Befehl/Wert ist, welcher übertragen werden soll.

for(int i = 0; i<2; i++){
   PORTC &= ~(1<<PC1); //PIN PC1 auf Low ziehen um dem Slave den Start der Übertragung zu signalisieren
   uint8_t byte_to_send = (command && 0x00FF); //Die unteren 8 Bit maskieren
   spi_send(byte_to_send); //Übertragen der unteren 8 Bit
   byte_to_send = command >> 8; //Die oberen 8 Bit maskieren
   spi_send(byte_to_send); // Übertragen der oberen 8 Bit
   PORTC |= (1<<PC1); //PIN PC1 auf High ziehen um dem Slave die Beendigung der Übertragung zu Signalisieren
}

[sushi (Gast)]

Hugo Zahnfee schrieb:
> Die Kombination funktioniert:
> Microcontroller (C):
>
> for (i=0; i<30; i++) { device.reply(i); }
>
> Master (Python):
>
> for kkkk in range (0, 30):
>     result.append(spi.readbytes(1)[0])
>
> Was nicht geht ist das hier:
>
> Microcontroller(C):
>
> for (i=0; i<30; i++) { device.reply(i); }
>
> Master (Python):
>
> result = spi.readbytes(30)


Also es scheint daran zu liegen, dass dein uC die Daten nicht 
rechtzeitig in den Buffer legen kann. Mit der funktionierenden Variante 
wird vermutlich für jedes Byte die SS Leitung auf Low gezogen und nach 
dem einen Byte wieder losgelassen. Das passiert 30 mal. Dabei hat der uC 
genug Zeit seinen Buffer zu füllen.
Bei der nicht funktionieren Variante wird die SS Leitung nur einmal Low 
gezogen, dann werden schnell 30 Bytes versendet und danach wird die SS 
Leitung losgelassen.

[Stefan S. (chiefeinherjar)]

sushi schrieb:
> Bei der nicht funktionieren Variante wird die SS Leitung nur einmal Low
> gezogen, dann werden schnell 30 Bytes versendet und danach wird die SS
> Leitung losgelassen.

Das wird das Problem sein. Ich habe mir den Quelltext nicht genau 
angesehen, aber ausgehend davon, dass der µC nur einen Puffer von 8 Bit 
hat muss natürlich JEDES MAL die SS-Leitung losgelassen werden.

Ich habe ursprünglich nur auf die Anforderung geantwortet gehabt, mehr 
als 8 Bit auf einmal zu versenden. Habe angenommen, dass ein IC/Slave 
angesprochen werden sollte, welches eben einen (beispielsweise) 16 Bit 
langen Befehl braucht bzw. dessen Puffer groß genug ist.

[sushi (Gast)]

Es kann aber auch sein, dass dein Chip dir per Interrupt Bescheid gibt, 
dass dein Puffer sich leert, und du dann dort schnell weitere Bits 
hineinschieben kannst...

[isidor (Gast)]

Stefan Schmidt schrieb:
> Das wird das Problem sein. Ich habe mir den Quelltext nicht genau
> angesehen, aber ausgehend davon, dass der µC nur einen Puffer von 8 Bit
> hat muss natürlich JEDES MAL die SS-Leitung losgelassen werden.

So ist es. Ein SPI Slave hat keine andere (sichere) Möglichkeit
signalisiert zu bekommen dass ein Datum eintrifft. Es sei denn
er zählt die Clocks einzeln mit.

[Hugo Zahnfee (Gast)]

sushi schrieb:
> Bei der nicht funktionieren Variante wird die SS Leitung nur einmal Low
> gezogen, dann werden schnell 30 Bytes versendet und danach wird die SS
> Leitung losgelassen.

Ach so - Du meinst, der Buffer kann erst dann befüllt werden, wenn CS 
seinen Pegel ändert und "fertig" ist?