ESP32 - SPI funktioniert nicht

[Marius S. (fhler)]

Hallo,

wie schon im Betreff erwähnt verwende ich einen ESP32 (DevKitC). Ich 
will per SPI Daten übertragen nur leider funktioniert es mit der 
SPI-Bibliothek nicht. Grund: unbekannt.

Noch nicht einmal das mitgelieferte SPI-Beispiel funktioniert. Das Board 
habe ich schon getauscht, das Netz durchwühlt aber keine der Lösungen 
funktioniert. Lediglich das BitBangedSPI im ArduinoISP-Beispiel 
funktioniert aber das ist "händisches SPI" und damit kann ich nur Daten 
rausschicken aber keine empfangen (was ich aber zwingend muss).

In der Arduino IDE hatte ich bisher das "DOIT ESP32 DEVKIT V1" 
ausgewählt kann es sein das ich ein anderes auswählen muss? Auf dem 
Board steht "ESP32-WROOM-32". Daher fällt für mich das "ESP32 DevModule" 
und das "ESP32 Wrover Module " weg / kommt eigentlich nicht in Frage.

Habt ihr evtl noch Lösungsvorschläge?

Gruß Marius

[John P. (brushlesspower)]

Welches Board du auswählst ist "eigentlich" egal.

Für jedes Board ist eine "pins_arduino.h" hinterlegt. In der steht z.B. 
welche Pins für SPI genutzt werden.

fürs DOIT ESP32 DEVKIT V1 sind das:

static const uint8_t SS    = 5;
static const uint8_t MOSI  = 23;
static const uint8_t MISO  = 19;
static const uint8_t SCK   = 18;

welche Pins du tatsächlich verwendest, musst du wissen.

[Marius S. (fhler)]

Hallo John,

Genau diese Pins verwende ich / will ich verwenden. Nur es tut sich 
absolut nichts.

[John P. (brushlesspower)]

Dann solltest du mal deinen Code posten.
Eventuell auch sagen was du mit der SPI machen willst?
Eventuell auch wie du was verbunden hast?

Hast du ein Oszi zur verfügung?


Ohne diese Angaben ist es Rätsel raten.

[Michael U. (amiga)]

Hallo,

mit welchem Sketch hast Du getestet? SPI am ESP32 macht eigenlich kein 
mir bekannten Probleme. Sonst würden auch meine SPI-Displays mit 
SPI-Touchcontroller und auch die SD-Karte nicht gehen.

Die Standard-Pins wurden oben schon genannt, Board ist völlig egal, 
"ESP32 Dev Module" kann man für alle nutzen solange man die GPIO-Nummern 
des ESP32 benutzt. Die boardspezifischen Einstellungen werden erst 
interessant, wenn man mit den bei einigen aufgedrucken Dx Bezeichungen 
arbeiten will oder fest verdrahtete Zusatzhardware (OLED usw.) direkt 
auf dem Board sind und man mit deren speziellen Beispielen arbeiten 
will.

Alles bezogen auf die IDE 1.8.8 und ESP32 Boardmanagerversion 1.0.1.

Was hast Du denn wie oder womit testen wollen?

Gruß aus Berlin
Michael

[Thomas F. (thomas_82)]

Evtl. die Pinzuordnung, der Aufdruck auf den ESP, NodeMCU und Co Boards 
ist teilweise verwirrend wenn es mir seltsam vorkommt teste ich 
mittlerweile mit einer Led und einem blink Sketch ob es der richtige 
ist.

[Marius S. (fhler)]

John P. schrieb:

> Dann solltest du mal deinen Code posten.

Selbst den Heartbeat macht er nicht mehr.

#include <SPI.h>

#include "Arduino.h"
#include "FS.h"
#include "SPIFFS.h"

#define PIN_SCK 18
#define PIN_MOSI  23
#define PIN_MISO  19
#define RESET 22


uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  SPI.transfer(a);
  SPI.transfer(b);
  SPI.transfer(c);
  return SPI.transfer(d);
}

void setup() {
  Serial.begin(115200);
    if(SPIFFS.begin())
  {
    Serial.println("SPIFFS Initialisierung....OK");
  }
  else
  {
    Serial.println("SPIFFS Initialisierung...Fehler!");
  }

  SPI.begin();
  
  pinMode(PIN_SCK, OUTPUT);
  pinMode(PIN_MOSI, OUTPUT);
  pinMode(PIN_MISO, INPUT);
  pinMode(RESET, OUTPUT);
 
   //Just for testing
  digitalWrite(RESET, HIGH);
  delay(1000);
  digitalWrite(RESET, LOW);

  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); //SPI-BUS einrichten: max 1 MHz, MSB zuerst, MODUS 0 
  SPI.transfer(0xFF);
  SPI.endTransaction();

     
}

void loop() {
  //"Heartbeat"
  delay(1000);
  digitalWrite(22, HIGH);
  delay(1000);
  digitalWrite(22, LOW);
  

  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); //SPI-BUS einrichten: max 1 MHz, MSB zuerst, MODUS 0 
  SPI.transfer(0xFF);
  SPI.transfer(0b10010101010101010110111111110000011110000);
  SPI.endTransaction();

  String debugLogData;
  
  if (SPIFFS.exists("/250.hex"))
  {
     Serial.println("File gefunden");
      File f = SPIFFS.open("/250.hex", "r");    
      
          while (f.available()){
            debugLogData += char(f.read());
          }
          f.close();
  }

  Serial.println(debugLogData);

    int maxIndex = debugLogData.length() - 1;
    int index=0;
    int next_index;
    String data_word;
    int anzahl_zeilen = 0;
    
    do{
        anzahl_zeilen++;
        next_index=debugLogData.indexOf('\r\n',index);
        data_word=debugLogData.substring(index, next_index);
        Serial.print("Output line: ");
        Serial.println(data_word);
        index=next_index+1;
     }while((next_index!=-1)&&(next_index<maxIndex));
     Serial.println(anzahl_zeilen);
     
     String Array[anzahl_zeilen];
     index=0;
     int i = 0;
     
     do{
        next_index=debugLogData.indexOf('\r\n',index);
        Array[i]=debugLogData.substring(index, next_index);
        Serial.print("Output Array line: ");
        Serial.println(Array[i]);
        i++;
        index=next_index+1;
     }while((next_index!=-1)&&(next_index<maxIndex));

      Serial.println("anzahl datenbytes (HEX)");
      char a = Array[0].charAt(1);
      char b = Array[0].charAt(2);
      String str = (String) a + (String) b;
      switch(str){}
      {
        case 00
        }

        Serial.println(str)

}

> Eventuell auch sagen was du mit der SPI machen willst?
  Mit den gesendeten Daten einen AtTiny programmieren
  Beitrag "ESP32 als ISP"

> Eventuell auch wie du was verbunden hast?
PIN ESP32    <->   PIN AtTiny45

22 -> 5 RESET
18 -> 2 CLK
23 -> 0 MOSI
19 -> 1 MISO

> Hast du ein Oszi zur verfügung?
  JA.

[Mike R. (thesealion)]

Ohne jetzt deinen kompletten Code zu lesen:

SPI.begin();
  
pinMode(PIN_SCK, OUTPUT);
pinMode(PIN_MOSI, OUTPUT);
pinMode(PIN_MISO, INPUT);
pinMode(RESET, OUTPUT);

Sieht meiner für die SPI Schnittstelle deutlich anders aus

SPI.begin(SPI_CLK, SPI_MISO, SPI_MOSI);

Wie soll die SPI Hardware denn etwas über die Pins ausgeben, wenn du sie 
gleich wieder als normale Outputs definierst?

[Marius S. (fhler)]

Mike R. schrieb:

> Sieht meiner für die SPI Schnittstelle deutlich anders aus
>

> SPI.begin(SPI_CLK, SPI_MISO, SPI_MOSI);
>

>
> Wie soll die SPI Hardware denn etwas über die Pins ausgeben, wenn du sie
> gleich wieder als normale Outputs definierst?

Danke. Mit der Änderung macht er wieder den Herzschlag. Aber trotzdem 
keine Änderung der Signale auf der Clock-/MOSI-/MISO-Leitung.

[Michael U. (amiga)]

Hallo,

SPI.begin(); setzt die Pins auf die oben schon erwähnten Pins und nutzt 
Hardware SPI. Die Pins muß man nur angeben, wenn man andere nutzt.

Die Pins da selber und dann auch falsch anzufassen ist nicht sinnvoll.

Interessant wäre wohl dann auch, was da auf dem Tiny45 läuft. Ich kenne 
es eigentlich so (aber nicht auf einem Tiny), daß mit SS/CS dem Slave 
mitgeteilt wird, daß der Master was von ihm will.

Gruß aus Berlin
Michael

[holger (Gast)]

>Interessant wäre wohl dann auch, was da auf dem Tiny45 läuft.

Das will er doch erst reinflashen.

>  SPI.transfer(0b10010101010101010110111111110000011110000);

Das sind 41Bits wenn ich mich nicht verzählt habe.
Sicher dass es eine SPI.transfer() gibt die dann vermutlich
64Bits überträgt?

[Michael U. (amiga)]

Hallo,

holger schrieb:
> Das sind 41Bits wenn ich mich nicht verzählt habe.
> Sicher dass es eine SPI.transfer() gibt die dann vermutlich
> 64Bits überträgt?

Nein, gibt es nicht. Aus SPI.h vom ESP32:

    void beginTransaction(SPISettings settings);
    void endTransaction(void);

    void transfer(uint8_t * data, uint32_t size);
    uint8_t transfer(uint8_t data);
    uint16_t transfer16(uint16_t data);
    uint32_t transfer32(uint32_t data);
  
    void transferBytes(uint8_t * data, uint8_t * out, uint32_t size);
    void transferBits(uint32_t data, uint32_t * out, uint8_t bits);

Gruß aus berlin
Michael

[fhler (Gast)]

holger schrieb:
>  SPI.transfer(0b10010101010101010110111111110000011110000);
>
> Das sind 41Bits wenn ich mich nicht verzählt habe.
> Sicher dass es eine SPI.transfer() gibt die dann vermutlich
> 64Bits überträgt?

Ich muss sagen da habe ich mir keine Gedanken drüber gemacht und einfach 
nur auf der Tastatur rumgetippt ohne zu zählen.

[Mike R. (thesealion)]

Dann mach dir jetzt mal Gedanken und erstelle einen Sketch der alle 
1000ms 8bit per SPI versendet.

Wenn du den fertig hast kannst du ihn hier Posten bzw. Gleichzeitig mit 
deinem Oszilloskop messen ob er denn funktioniert.

Oder dann sehen wir wie man dir helfen kann.

[Marius S. (fhler)]

Mike R. schrieb:
> Dann mach dir jetzt mal Gedanken und erstelle einen Sketch der alle
> 1000ms 8bit per SPI versendet.

#include <SPI.h>
#include "Arduino.h"

#define PIN_SCK 18
#define PIN_MOSI  23
#define PIN_MISO  19
#define RESET 22

void setup() {
  // put your setup code here, to run once:
  
  pinMode(PIN_SCK, OUTPUT);
  pinMode(PIN_MOSI, OUTPUT);
  pinMode(PIN_MISO, INPUT);
  pinMode(RESET, OUTPUT);
  
  SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI);
  //SPI.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  
  digitalWrite(22, HIGH);  
  delay(1000);
  digitalWrite(22, LOW);
  digitalWrite(5, LOW);
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); //SPI-BUS einrichten: max 1 MHz, MSB zuerst, MODUS 0 
  SPI.transfer(0x0F);
  SPI.endTransaction();
  digitalWrite(5, HIGH);
  delay(1000);

}

> Wenn du den fertig hast kannst du ihn hier Posten bzw. Gleichzeitig mit
> deinem Oszilloskop messen ob er denn funktioniert.

s. Anhang

GELB: !RESET (PIN 22)
BLAU: SCK
ROSA: MOSI
GRÜN: MISO TEK07
GRÜN: CS/SS (PIN 5) TEK12

[Michael U. (amiga)]

Hallo,

ich kenne zwar den TEK nicht, aber was erwartest Du bei einer Auflösung 
von 1s pro raster von den 1000000 mal schnelleren SPI-Signalen noch zu 
sehen?
Deine SpI-Signale sind in rund 1/100000 s nach der steigendewn Flanke 
von RESET fertig. Auch der SS/CS Impuls ist da dann durch und macht fast 
2 Sekunden Pause bis zum nächsten...

Nachdenken, was Du da siehst, was Du zu sehen erwartest und welche 
Einstellungen sinnvoll sind.

Trigger auf die fallende Flanke von SS/CS und stell die Auflösung auf 
2µs pro Raster oder so.
Wenn der TEK genau Speicher hat kannst Du natürlich auch größere Werte 
nehmen und dann reinzoomen.

Gruß aus Berlin
Michael

[John P. (brushlesspower)]

Marius S. schrieb:
> #include "Arduino.h"

hat vielleicht nichts mit dem SPI Problem zu tun. (da stimme ich erstmal 
dem Micheal zu)

Aber warum includest du eine arduino.h aus dem sketch verzeichnis?
die ist doch bereits in den ESP32 Hardware sourcen enthalten.

[Michael U. (amiga)]

Hallo,

so, ich wollte es sowieo mal machen, also war jetzt eine Gelegenheit 
dazu. ;)
Ich habe den uralten VB6-Kram installiert und meinen 
Eigenbau-Logicanalyzer ausgekramt...

Im Bild das, was Deine Software macht. Genau, das, was sie soll...

Weiß ich jetzt wenigstens, das mein 10 Jahre alter Kram immernoch geht 
und die Software auch unter Win7-64.

Gruß aus Berlin
Michael

[Marius S. (fhler)]

Vielen Dank für eure Hilfe, der SPI-Bus funktioniert jetzt.

[Michael U. (amiga)]

Hallo,

Danke für die Rückmeldung.
Ich bin auch froh, daß ich meinen alten LA wieder in Gang gebracht habe.
http://www.avr.roehres-home.de/logikanalyzer/index.html

Gruß aus Berlin
Michael

[Sinan (Gast)]

Hallo Marius,

kannst du deinen fertigen Sketch posten?

Ich bin momentan auch damit beschäftigt eine Kommunikation mit dem SPI 
aufzubauen.

Gruß

Sinan

[Sinan (Gast)]

Marius S. schrieb:
> Vielen Dank für eure Hilfe, der SPI-Bus funktioniert jetzt.

Hallo Marius,

kannst du deinen fertigen Sketch posten?
Ich bin momentan auch damit beschäftigt eine Kommunikation mit dem SPI 
aufzubauen.
Gruß
Sinan

[Hansjörg (Gast)]

Das läuft:

#include<SPI.h>       //Library for SPI

#define SPI_SCK 18 //Serial Clock(Master Output)
#define SPI_MOSI 23 //Master Output,Slave Input
#define SPI_MISO 19 //
#define SPI_CS 5 //Chip Select,Slave Transmit Enable(active low,Master 
Output)
#define SS 5

char retchr;

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   pinMode(SPI_CS, OUTPUT);
   pinMode(LED, OUTPUT);
   pinMode(SPI_SCK, OUTPUT);
   pinMode(SPI_MOSI, OUTPUT);
   pinMode(SPI_MISO, INPUT);

   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin (SPI_SCK,SPI_MISO,SPI_MOSI);
   SPI.setBitOrder(MSBFIRST);
   SPI.setDataMode(SPI_MODE0);
   SPI.setClockDivider(SPI_CLOCK_DIV8); //divide the clock by 8=2 MHz 
@ESP32
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char *p = "Hello, world! We are online over SPI\n\r" ; c = 
*p; p++)
   {
      retchr=SPI.transfer (c);
      Serial.print(c);
      Serial.print(retchr); // MOSI MISO Link gebt echo retour
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(500);
}