SPI-Bus verliert Werte

[Hugo Gruffy Duck (Gast)]

Hi,

ich habe einen Raspberry Pi und einen mbed Nucleo ST32F411RE miteinander 
verbunden. Mittels SPI-Bus möchte ich vom Raspberry Pi Daten an den mbed 
senden und empfangen.

Das ist das Pythonprogramm auf dem Raspberry Pi:

try:
    import tkinter as tk
except:
    import Tkinter as tk
    
import spidev
    
spi = spidev.SpiDev()
spi.open (0, 0)
import time
# spi.max_speed_hz = 1000000
    

button_width = 40

def bit_8_to_16(value=[]):    
    return ( (value[0]<<8)+value[1] )
    
def bit_16_to_8(value=0):
    return_value = []
    return_value.append(value>>8)
    return_value.append(value&0x00FF)
    return return_value

def main():
    root = tk.Tk()
    
    def do_exit():
        print ("PROGRAMM BEENDET")
        root.quit()
    
    def do_adc_task_isrunning():
        print ("ADC TASK RUNNING")
        spi.writebytes([0x00, 0xA0])
                
    def do_adc_task_start():
        print ("ADC TASK START")
        spi.writebytes([0x00, 0xA1])
                
    def do_adc_task_stopp():
        print ("ADC TASK STOPP")
        spi.writebytes([0x00, 0xA2])
                
    def do_adc_task_setfrequency():
        print ("ADC TASK SETFREQUENCY")
        spi.writebytes([0x00, 0xA3])
        time.sleep(0.1)  
        spi.writebytes([0x00, 100])      
        
    def do_fifo_anzahl_elements():
        print ("FIFO ANZAHL ELEMENTS")
        spi.writebytes([0x00, 0xB0])
        
        
    def do_fifo_get_one_element():
        print ("FIFO GET ONE ELEMENT")
        spi.writebytes([0x00, 0xB1])
        print (spi.readbytes(2))
        
    def do_fifo_get_elements():
        print ("FIFO GET ELEMENTS")        
        spi.writebytes([0x00, 0xB2])    
    
    #ADC_TASK_ISRUNNING      = 0x00A0,
    #ADC_TASK_START          = 0x00A1,
    #ADC_TASK_STOPP          = 0x00A2,
    #ADC_TASK_SETFREQUENCY   = 0x00A3,
    
    #FIFO_ANZAHL_ELEMENTS    = 0x00B0,
    #FIFO_GET_ONE_ELEMENT    = 0x00B1,
    #FIFO_GET_ELEMENTS       = 0x00B2
    
    button_1 = tk.Button(text="ADC_TASK_START", width=button_width, command=do_adc_task_start )
    button_1.pack()
    button_2 = tk.Button(text="ADC_TASK_STOPP", width=button_width, command=do_adc_task_stopp )
    button_2.pack()
    button_3 = tk.Button(text="ADC_TASK_SETFREQUENCY", width=button_width, command=do_adc_task_setfrequency )
    button_3.pack()
    button_4 = tk.Button(text="ADC_TASK_ISRUNNING", width=button_width, command=do_adc_task_isrunning )
    button_4.pack()
    button_5 = tk.Button(text="FIFO_ANZAHL_ELEMENTS", width=button_width, command=do_fifo_anzahl_elements )
    button_5.pack()
    button_6 = tk.Button(text="FIFO_GET_ONE_ELEMENT", width=button_width, command=do_fifo_get_one_element )
    button_6.pack()
    button_7 = tk.Button(text="FIFO_GET_ELEMENTS", width=button_width, command=do_fifo_get_elements )
    button_7.pack()    
    
    exit_button = tk.Button (text="Exit", command=do_exit, width=button_width)
    exit_button.pack()    
    
    root.mainloop()

if __name__ == "__main__":
    main()
    spi.close()

Das ist das C-Programm auf dem mbed:

#include "mbed.h"
#include "read_adc.h"
#include "ringbuffer.h"
#include "spi_commands.h"

#ifdef TARGET_NUCLEO_F411RE
    SPISlave spidevice(PA_7, PA_6, PA_5, PA_15);            // mosi, miso, sclk, ssel 
#endif

#ifdef TARGET_LPC1768
    SPISlave spidevice(p11, p12, p13, p14);            // mosi, miso, sclk, ssel 
#endif

// Ringbuffer initialisieren:
    RingBuffer ADC_Fifo;
    RingBuffer Error_Fifo;
    
// ADC_Interrupt initialisieren
    ReadADCValues read_ADC_values;

Serial pc(USBTX, USBRX);

uint32_t help, get_element=0;


void spi_evaluation(uint16_t command) {
    bool abort = false;
    switch (command) {
        case ADC_TASK_ISRUNNING: 
            pc.printf ("\n\r ADC_TASK_ISRUNNING (%d)", read_ADC_values.is_active);
            break;

        case ADC_TASK_START:
            pc.printf ("\n\r ADC_TASK_START");
            read_ADC_values.start();
            break;

        case ADC_TASK_STOPP:
            pc.printf ("\n\r ADC_TASK_STOPP");
            read_ADC_values.stopp();
            break;

        case ADC_TASK_SETFREQUENCY:
            pc.printf ("\n\r ADC_TASK_FREQUENCY");
            abort=true;
            while (abort) {
                if (spidevice.receive()) {
                    abort = false;
                    help=spidevice.read();
//                    read_ADC_values.set_sampling_rate( spidevice.read() );                    
                }
            }  // Ende while
            
            pc.printf ("\n\r NEW_FREQUENCY (%d)", help);
            
            break;            

        case FIFO_ANZAHL_ELEMENTS:
            pc.printf ("\n\r FIFO ANZAHL ELEMENTS");
            break;            
        
        case FIFO_GET_ONE_ELEMENT:
            // pc.printf ("\n\r FIFO GET ONE ELEMENT");
            spidevice.reply(get_element);
            get_element++;
            break;            
        
        case FIFO_GET_ELEMENTS:
            pc.printf ("\n\r FIFO GET ELEMENTS");
            break; 
    } // Switch Ende           
}

int main () {
    // uart konfigurieren
    pc.baud (921600);
    pc.printf ("\n\r Programm wurde gestartet");
    
    // spi konfigurieren
    spidevice.format (16, 0);
    // spidevice.frequency(1000000);
    
    // ADC-Interrupt konfigurieren
    read_ADC_values.init();
 
    while (1) {
        if (spidevice.receive()) {
             spi_evaluation (spidevice.read());
        }  // Ende if

     } // Hauptschleife Programm
}

Hier ist noch die Datei SPI_COMMANDS.h

/*
In dieser Datei werden die Hexwerte für die SPI-Befehle, die vom 
SPI-Master kommen, mit lesbaren Worten codiert. 
*/

#ifndef SPI_COMMANDS_H
#define SPI_COMMANDS_H

enum SPICommands {
    ADC_TASK_ISRUNNING      = 0x00A0,
    ADC_TASK_START          = 0x00A1,
    ADC_TASK_STOPP          = 0x00A2,
    ADC_TASK_SETFREQUENCY   = 0x00A3,
    
    FIFO_ANZAHL_ELEMENTS    = 0x00B0,
    FIFO_GET_ONE_ELEMENT    = 0x00B1,
    FIFO_GET_ELEMENTS       = 0x00B2
};
#endif

Die anderen Headerdateien wie der Fifo werden in dem aktuellen Programm 
noch nicht benutzt. Die mbed.h wird vom Internetcompiler bereitgestellt.

Mein Problem ist folgendes:

Drücke ich mehrmals hintereinander schnell auf dem Raspberry den Button 
"FIFO GET ONE ELEMENT", dan bekomme ich einen Wert zurück, der bei jedem 
Aufruf um einen Wert nach oben addiert wird. Manchmal bekomme ich ein 
paar mal hintereinander den gleichen Wert - woran liegt das?

Mit dem Button "ADC TASK FREQUENCY" möchte ich später die Zeit eines 
Timers einstellen. Dazu möchte ich einen Wert an den mbed senden. Nicht 
immer wird der Wert empfangen und dann wartet das Programm in der 
Schleife:

        case ADC_TASK_SETFREQUENCY:
            ...
            while (abort) {
                if (spidevice.receive()) {
             ...

obwohl vom Raspberry Pi gleich danach noch ein Wert gesendet wird:

    def do_adc_task_setfrequency():
        print ("ADC TASK SETFREQUENCY")
        spi.writebytes([0x00, 0xA3])
        time.sleep(0.1)  
        spi.writebytes([0x00, 100])

Es ist sogar extra noch ein sleep-Befehl dadrin, weil ich dachte, dass 
der mbed vielleicht nicht schnell genug ist und etwas Zeit braucht, bis 
die while-Schleife etc. verarbeitet ist.

Die Kommunikation funktioniert also nicht fehlerfrei zwischen dem 
Raspberry Pi und dem mbed und ich habe keine Idee, wie ich das Problem 
in den Griff kriegen kann.

Ich möchte später z.B. in einem Rutsch hintereinander 100 Messwerte vom 
mbed an den Raspberry Pi senden - aber wenn es schon bei einem Wert 
nicht richtig funktioniert und manche Werte doppelt empfangen werden, 
dann ist das problematisch. Woran könnte das liegen?

[(prx) A. K. (prx)]

Kann es sein, dass sich SPI und UART beim Zeitverhalten in die Quere 
kommen? Eine nicht tief gepufferte UART Ausgabe blockiert den µC.

[Hugo Gruffy Duck (Gast)]

A. K. schrieb:
> Kann es sein, dass sich SPI und UART beim Zeitverhalten in die Quere
> kommen? Eine nicht tief gepufferte UART Ausgabe blockiert den µC.

        case FIFO_GET_ONE_ELEMENT:
            // pc.printf ("\n\r FIFO GET ONE ELEMENT");
            spidevice.reply(get_element);
            get_element++;
            break;

Ich hab die printf-Anweisung schon herausgenommen. Oder meinst Du, die 
Printf-Anweisung auf Seiten des Raspberry Pis kann auch problematisch 
sein?

[Hugo Gruffy Duck (Gast)]

Ich hab das Programm jetzt etwas abgeändert. Auf dem mbed:

        case FIFO_GET_ONE_ELEMENT:
            // pc.printf ("\n\r FIFO GET ONE ELEMENT");
            spidevice.reply(get_element);
            get_element++;
            break;

Auf dem Raspberry Pi:

    def do_fifo_get_one_element():
        print ("FIFO GET ONE ELEMENT")
        elements=[]
        for lalala in range (0, 10):
            spi.writebytes([0x00, 0xB1])
            time.sleep(0.00001)
            elements.append(spi.readbytes(2)[1])
            # print (spi.readbytes(2))
            time.sleep(0.00001)
        print (elements)

Während der SPI-Kommunikation sind nun keine print-Anweisungen mehr 
vorhanden. Dennoch kommt es zum Datenverlust - nicht immer werden die 
10ner-Blöcke sauber übertragen.

[dunno.. (Gast)]

Hugo Gruffy Duck schrieb:
> time.sleep(0.00001)

Ich bezweifle dass du es schaffst in ner scriptsprache auf nem raspi 
10µS zu warten. Und selbst wenn, ist denn der MBED in der lage in den 
10µS:
-das SPI Kommando in die Main-Loop zu bekommen
-auszuwerten
-und das ergebnis wieder in den spi-buffer zu schreiben?

spendiere zum test mal deutlich mehr zeit. wenns dann noch nicht 
funktioniert, ist der fehler woanders.

[Hugo Gruffy Duck (Gast)]

dunno.. schrieb:
> Ich bezweifle dass du es schaffst in ner scriptsprache auf nem raspi
> 10µS zu warten.

Warum bezweifelst Du das? Meinst Du, der Raspi ist schneller oder eher 
langsamer?

Ich hatte auch schon vorher längere Intervalle angegeben, sogar mal eine 
ganze Sekunde, was ja eigentlich ne Ewigkeit für den mbed und den 
Raspberry sein müsste.