FreeRTOS - ESP8266 "vergisst" Bytes beim Senden über SPI

[Max M. (maxmicr)]

Der ESP8266 soll zwei einfache Nachrichten per SPI versenden (als 
Master) und anschließend 1 Byte empfangen, der gesamte Code sieht so 
aus:

bool isLEDon = false;

void send_spi(uint8_t *data, uint8_t length) {
  spi_trans_t trans;
  memset(&trans, 0, sizeof(trans));
  
  trans.bits.mosi = length * 8;
  trans.mosi = data;
  trans.addr = NULL;
  trans.cmd = NULL;

  spi_trans(HSPI_HOST, &trans);
}

uint8_t read_spi() {
  uint8_t resp[1];

  spi_trans_t trans;
  memset(&trans, 0, sizeof(trans));
  
  trans.bits.miso = 8;
  trans.miso = resp;
  trans.addr = NULL;
  trans.cmd = NULL;
  
  spi_trans(HSPI_HOST, &trans);
  
  return resp[0];
}

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  const uint32_t addr = 5829;
  const uint8_t addrMSB =  (addr >> 16);
  const uint8_t addrMLSB = (addr >> 8);
  const uint8_t addrLSB = (addr & 0xFF);
  
  uint8_t readMsg[] = {
    READ_CMD, addrMSB, addrMLSB, addrLSB
  };
  
  uint8_t writeMsg[] = {
    WRITE_CMD, addrMSB, addrMLSB, addrLSB, 133
  };

  while(true) {
    send_spi(writeMsg, sizeof(writeMsg));

    vTaskDelay(10 / portTICK_PERIOD_MS);

    send_spi(readMsg, sizeof(readMsg));
    
    vTaskDelay(25 / portTICK_PERIOD_MS);
    
    const uint8_t resp = read_spi();
    
    printf("RESPONSE: %d\n", resp);

    if(isLEDon) {
      gpio_set_level(GPIO_NUM_2, 1);
      isLEDon = false;
    } else {
      gpio_set_level(GPIO_NUM_2, 0);
      isLEDon = true;
    }

    vTaskDelay(100 / portTICK_PERIOD_MS);
  }
}

void ICACHE_FLASH_ATTR app_main() {
  gpio_config_t io_conf;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = LED_OUTPUT_PIN_SEL;
  io_conf.pull_down_en = 0;
  io_conf.pull_up_en = 0;
  gpio_config(&io_conf);
  
  spi_config_t spi_config;
  spi_config.interface.val = SPI_DEFAULT_INTERFACE;
  spi_config.mode = SPI_MASTER_MODE;
  spi_config.clk_div = SPI_2MHz_DIV;
  spi_config.event_cb = NULL;
  spi_init(HSPI_HOST, &spi_config);
      
  xTaskCreate(spi_master_write_slave_task, "spi_master_write_slave", 2048, NULL, 3, NULL);
}

Die 1. Nachricht ("Write") sieht perfekt aus, bei der 2. Nachricht 
vergisst der ESP8266 aber einfach die restlichen 3 Bytes und schickt nur 
das 1. Byte korrekt - warum?
Ich gönne ihm sogar extra 25ms Pause :(

P.S: Wenn ich die 1. Nachricht (also "Write") weglasse, dann wird die 
"Read"-Nachricht korrekt ausgegeben.

[minifloat (Gast)]

Erstens
Max M. schrieb:
> void send_spi(uint8_t *data, uint8_t length) {
>   spi_trans_t trans;

Damit legst du das Objekt bzw. die Struktur trans funktionslokal an. Es 
liegt auf dem Stack. Wer garantiert dir nach Ende der Funktion, dass es 
noch da ist?

Zweitens
Max M. schrieb:
> trans.mosi = data;
Der Datenzeiger muss für die gesamte Zeit, bis alle Daten raus gepustet 
wurden, valide sein. Ist er das auch?

Drittens

Max M. schrieb:
> Ich gönne ihm sogar extra 25ms Pause
Warten ist keine Synchronisationsmethode

mfg mf

[Max M. (maxmicr)]

minifloat schrieb:
> Wer garantiert dir nach Ende der Funktion, dass es
> noch da ist?

Wenn ich wüsste, wann das Übertragen abgeschlossen ist, könnte ich dir 
das sagen.

minifloat schrieb:
> Ist er das auch?

Gleiche Aussage wie oben. Ich hab keine Infos dazu gefunden, wann die 
SPI-Daten tatsächlich übertragen werden.


Danke für den Hinweis, ich werde die Variablen mal innerhalb der 
Task-Funktion global machen.

Edit: Leider nein, gleiches Verhalten (außer ich hab was übersehen):

void send_spi(spi_trans_t *trans, uint8_t *data, uint8_t length) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.mosi = 8 * length;
  trans->mosi = data;
  trans->addr = NULL;
  trans->cmd = NULL;

  spi_trans(HSPI_HOST, trans);
}

void read_spi(spi_trans_t *trans, uint8_t *dest) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.miso = 8;
  trans->miso = dest;
  trans->addr = NULL;
  trans->cmd = NULL;
  
  spi_trans(HSPI_HOST, trans);
}

typedef enum STATE {
  IDLE = 0,
  SENT_WRITE = 1,
  SENT_READ = 2
} STATE;

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  STATE state = IDLE;

  const uint32_t addr = 5829;
  const uint8_t addrMSB =  (addr >> 16);
  const uint8_t addrMLSB = (addr >> 8);
  const uint8_t addrLSB = (addr & 0xFF);
  
  uint8_t readMsg[] = {
    READ_CMD, addrMSB, addrMLSB, addrLSB
  };
  
  uint8_t writeMsg[] = {
    WRITE_CMD, addrMSB, addrMLSB, addrLSB, 133
  };
  
  uint8_t recvBuff[1];
  
  spi_trans_t trans;

  while(true) {

    switch(state) {
      case IDLE:
        send_spi(&trans, writeMsg, 5);
        state = SENT_WRITE;
      break;
      case SENT_WRITE:
        send_spi(&trans, readMsg, 4);
        state = SENT_READ;
      break;
      default:
        ;
        read_spi(&trans, recvBuff);
        printf("RESPONSE: %d\n", recvBuff[0]);
        state = IDLE;
      break;
    }

    if(isLEDon) {
      gpio_set_level(GPIO_NUM_2, 1);
    } else {
      gpio_set_level(GPIO_NUM_2, 0);
    }
    isLEDon = !isLEDon;

    vTaskDelay(10 / portTICK_PERIOD_MS);
  }
}

minifloat schrieb:
> Warten ist keine Synchronisationsmethode

Korrekt. Bei der wenigen Dokumentation, die es zum RTOS gibt, hab ich 
leider noch nicht rausgefunden, wie man einen SPI-Receive oder 
SPI-Transmit Interrupt implementiert.

[minifloat (Gast)]

Max M. schrieb:
> ich werde die Variablen mal innerhalb der Task-Funktion global machen

Mach' die mal in der C-Source überhaupt global. Oderststic. Weil wenn 
das Ding auf dem Stack liegt, die Übertragung aber vermutlich 
Interrupt-getrieben  und nicht synchron zum Tasksystem, muss das Ding 
dauerhaft existent sein.

Max M. schrieb:
> Wenn ich wüsste, wann das Übertragen abgeschlossen ist,

Du hast dort eine wunderschöne Statemachine. Gibt es für das spi_trans_t 
Objekt keine IsReady-Funktion?
Gibt es Doku zu dem SPI-Krempel?

mfg mf

[minifloat (Gast)]

minifloat schrieb:
> Oderststic

"Oder static"

[Max M. (maxmicr)]

minifloat schrieb:
> Mach' die mal in der C-Source überhaupt global.

So?

#include <stdio.h>
#include <string.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "esp_system.h"
#include "esp_spi_flash.h"
#include "esp_log.h"

#include "driver/gpio.h"
#include "driver/spi.h"

#define  LED_OUTPUT_PIN_SEL  ( (1 << GPIO_NUM_2) | (1 << GPIO_NUM_2) )

#define READ_CMD      0x13
#define WRITE_CMD      0x12

#define READ_ADDR      ( (uint32_t)5829 )

bool isLEDon = false;

static const uint8_t addrMSB =  (READ_ADDR >> 16);
static const uint8_t addrMLSB = (READ_ADDR >> 8);
static const uint8_t addrLSB = (READ_ADDR & 0xFF);

static uint8_t readMsg[4];
static uint8_t writeMsg[5];

static uint8_t recvBuff[1];

static spi_trans_t trans;

void send_spi(spi_trans_t *trans, uint8_t *data, uint8_t length) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.mosi = 8 * length;
  trans->mosi = data;
  trans->addr = NULL;
  trans->cmd = NULL;

  spi_trans(HSPI_HOST, trans);
}

void read_spi(spi_trans_t *trans, uint8_t *dest) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.miso = 8;
  trans->miso = dest;
  trans->addr = NULL;
  trans->cmd = NULL;
  
  spi_trans(HSPI_HOST, trans);
}

typedef enum STATE {
  IDLE = 0,
  SENT_WRITE = 1,
  SENT_READ = 2
} STATE;

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  STATE state = IDLE;

  while(true) {

    switch(state) {
      case IDLE:
        send_spi(&trans, writeMsg, 5);
        state = SENT_WRITE;
      break;
      case SENT_WRITE:
        send_spi(&trans, readMsg, 4);
        state = SENT_READ;
      break;
      default:
        ;
        read_spi(&trans, recvBuff);
        printf("RESPONSE: %d\n", recvBuff[0]);
        state = IDLE;
      break;
    }

    if(isLEDon) {
      gpio_set_level(GPIO_NUM_2, 1);
    } else {
      gpio_set_level(GPIO_NUM_2, 0);
    }
    isLEDon = !isLEDon;

    vTaskDelay(10 / portTICK_PERIOD_MS);
  }
}

void ICACHE_FLASH_ATTR app_main() {
  readMsg[0] = READ_CMD;
  readMsg[1] = addrMSB;
  readMsg[2] = addrMLSB;
  readMsg[3] = addrLSB;
  
  writeMsg[0] = WRITE_CMD;
  writeMsg[1] = addrMSB;
  writeMsg[2] = addrMLSB;
  writeMsg[3] = addrLSB;
  writeMsg[4] = 133;
  
  gpio_config_t io_conf;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = LED_OUTPUT_PIN_SEL;
  io_conf.pull_down_en = 0;
  io_conf.pull_up_en = 0;
  gpio_config(&io_conf);
  
  spi_config_t spi_config;
  spi_config.interface.val = SPI_DEFAULT_INTERFACE;
  spi_config.mode = SPI_MASTER_MODE;
  spi_config.clk_div = SPI_2MHz_DIV;
  spi_config.event_cb = NULL;
  spi_init(HSPI_HOST, &spi_config);
  

    /* Print chip information */
    esp_chip_info_t chip_info;
    esp_chip_info(&chip_info);
    printf("This is ESP8266 chip with %d CPU cores, WiFi, ",
            chip_info.cores);

    printf("silicon revision %d, ", chip_info.revision);

    printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024),
            (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external");
      
  xTaskCreate(spi_master_write_slave_task, "spi_master_write_slave", 2048, NULL, 3, NULL);
}

Nun sind beide Nachrichten falsch

minifloat schrieb:
> Gibt es Doku zu dem SPI-Krempel?

https://docs.espressif.com/projects/esp8266-rtos-sdk/en/latest/api-reference/peripherals/spi.html

[minifloat (Gast)]

Max M. schrieb:
> Nun sind beide Nachrichten falsch

Soll ich ehrlich sein, das hatte ich bereits erwartet...
spi_trans() scheint für den Usercode kein "blockierender"Syscall zu 
sein. D.h. der Task wird nicht suspended, wenn SPI noch am Werk ist.

Max M. schrieb:
> minifloat schrieb:
>> Gibt es Doku zu dem SPI-Krempel?
>
> 
https://docs.espressif.com/projects/esp8266-rtos-sdk/en/latest/api-reference/peripherals/spi.html

Schön. Hab' mal kurz durchgesehen. Es gibt offenbar keinen global 
abrufbaren Status der beiden SPIs. Spinlocks sind auch nicht das beste 
Mittel...
Aaaaaber. Du kannst einen Event-Callback anlegen. Das geht wohl im 
spi_config_t-Objekt:
>> spi_event_callback_t event_cb
>> SPI interrupt event callback

Und der Typ...
>> typedef void (*spi_event_callback_t)
>> (int event, void *arg)
...stellt in Aussicht, bei "int event" z.B. einen dieser hier zu 
bekommen...
>> SPI_TRANS_DONE_EVENT
>> SPI_TRANS_DONE

Also
a) Thread nach spi_trans() schlafen legen und mit dem Callback bei 
Erfolg wieder Aufwecken
b) Eigenen globalen Status mit dem Callback steuern.

mfg mf

[minifloat (Gast)]

PS
> So?
Bassd scho'

Zum verborgenen "Warum?" hier
> Nun sind beide Nachrichten falsch
Du manipulierst die Nachricht, die noch gesendet werden soll...

[Max M. (maxmicr)]

minifloat schrieb:
> Du kannst einen Event-Callback anlegen. Das geht wohl im
> spi_config_t-Objekt:

Danke für den Hinweis, ich habs nun mal versucht zu implementieren:

TaskHandle_t master_write_task;
/* ... */

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  const uint32_t addr = 5829;
  const uint8_t addrMSB =  (addr >> 16);
  const uint8_t addrMLSB = (addr >> 8);
  const uint8_t addrLSB = (addr & 0xFF);
  
  uint8_t readMsg[] = {
    READ_CMD, addrMSB, addrMLSB, addrLSB
  };
  
  uint8_t writeMsg[] = {
    WRITE_CMD, addrMSB, addrMLSB, addrLSB, 133
  };

  while(true) {
    send_spi(writeMsg, sizeof(writeMsg));

    vTaskSuspend(master_write_task);

    send_spi(readMsg, sizeof(readMsg));
    
    vTaskSuspend(master_write_task);
    
    const uint8_t resp = read_spi();
    /* ... */
  }
}

void spi_callback(int event, void *arg) {
  printf("SPI_INIT_EVENT: %d\n", SPI_INIT_EVENT);
  printf("SPI_TRANS_START_EVENT: %d\n", SPI_TRANS_START_EVENT);
  printf("SPI CALLBACK called with EVENT = %d, but SPI_TRANS_DONE=%d\n", event, SPI_TRANS_DONE_EVENT);
  if(event == SPI_TRANS_DONE_EVENT) {
    vTaskResume(master_write_task);
  }
}

void ICACHE_FLASH_ATTR app_main() {
  gpio_config_t io_conf;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = LED_OUTPUT_PIN_SEL;
  io_conf.pull_down_en = 0;
  io_conf.pull_up_en = 0;
  gpio_config(&io_conf);
  
  spi_config_t spi_config;
  spi_config.interface.val = SPI_DEFAULT_INTERFACE;
  spi_config.mode = SPI_MASTER_MODE;
  spi_config.clk_div = SPI_2MHz_DIV;
  spi_config.event_cb = &spi_callback;
  spi_init(HSPI_HOST, &spi_config);
      
  xTaskCreate(spi_master_write_slave_task, "spi_master_write_slave", 2048, NULL, 3, &master_write_task);
}

Dann stürzt der ESP8266 aber dauernd ab:

[0;32mI (617) reset_reason: RTC reset 2 wakeup 0 store 4, reason is 2[0m
[0;32mI (623) gpio: GPIO[2]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:1074812240 [0m
[0;31mE (638) gpio: gpio_set_intr_type(138): GPIO interrupt type error[0m
SPI_INIT_EVENT: 0
SPI_TRANS_START_EVENT: 1
SPI CALLBACK called with EVENT = 0, but SPI_TRANS_DONE=2
SPI Write-Task started...
SPI_INIT_EVENT: 0
SPI_TRANS_START_EVENT: 1
SPI CALLBACK called with EVENT = 1, but SPI_TRANS_DONE=2
abort() was called at PC 0x402189fb on core 0

Guru Meditation Error: Core  0 panic'ed (StoreProhibited). Exception was unhandled.

Core 0 register dump:
PC      : 0x40218845  PS      : 0x00000033  A0      : 0x40218840  A1      : 0x3ffe8110  

A2      : 0x00000000  A3      : 0x00000000  A4      : 0x00000000  A5      : 0x00000001  

A6      : 0x00000001  A7      : 0x40229464  A8      : 0x00000040  A9      : 0x00000001  

A10     : 0x0000002d  A11     : 0x00000040  A12     : 0x3ffeb1f0  A13     : 0xffffffff  

A14     : 0x00000004  A15     : 0x401058b8  SAR     : 0x0000001e  EXCCAUSE: 0x0000001d

Vielleicht sollte Espressif lieber mehr Doku schreiben anstatt auf 
GitHub jeden Tag Commits rauszuhauen.

Edit: Sobald ich alle *printf()*-Ausgaben aus der spi_callback 
entferne, stürzt der ESP8266 nicht mehr ab (öhm alles klar!), allerdings 
wird der Task trotzdem nicht wieder aufgenommen (eventuell da das Event 
nie aufgerufen wird) - die 1. Nachricht läuft aber richtig über das SPI.

[minifloat (Gast)]

Was machst du denn da?
Max M. schrieb:
> const uint8_t resp = read_spi();

Weil das passt irgendwie nicht so recht zu deiner Deklaration...
Max M. schrieb:
> void read_spi(spi_trans_t *trans, uint8_t *dest)
...als void-Funktion und dann willst du einen const uint8_t beschreiben.

Würde irgendwie zu...
Max M. schrieb:
> Guru Meditation Error: Core  0 panic'ed (StoreProhibited).
...passen.
Ich geh pennen.
mfg mf

[minifloat (Gast)]

Max M. schrieb:
> Edit: Sobald ich alle *printf()*-Ausgaben aus der spi_callback entferne,
> stürzt der ESP8266 nicht mehr ab (öhm alles klar!),

Aha. Ist printf vielleicht ein blocking system call (Gift im IRQ) 
und/oder schreibt irgendwo wo er nicht soll?

Ich hab da eine Frage für Dumme.
Warum heißt es xTaskCreate
Aber vTaskSuspend und vTaskResume?

btw. Ich hab' keine Erfahrung mit FreeRTOS, alles nur höngengebliebenes 
Wissen aus dem Studium, was man eben über RTOS so vor 5-7 Jahren gelehrt 
hat.

Aus dem Callback heraus sollte es aber möglich sein, Tasks aufzuwecken. 
Wäre ja sonst sinnlos.

Letzte Idee des Abends
Dass es ein SPI-Init-Event gibt, sagt mir dass du vielleicht vor dem SPI 
losballern erst auf dieses SPI-Init-Event warten solltest. Damit würde 
ich dann den Task zum losballern starten.

n8 mfg mf

[Max M. (maxmicr)]

minifloat schrieb:
> Was machst du denn da?

Ups, da hab ich zwei Codestände durcheinander geschmissen.

minifloat schrieb:
> Dass es ein SPI-Init-Event gibt, sagt mir dass du vielleicht vor dem SPI
> losballern erst auf dieses SPI-Init-Event warten solltest. Damit würde
> ich dann den Task zum losballern starten.

Hab ich nun probiert:

#include <stdio.h>
#include <string.h>

#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"

#include "esp_system.h"
#include "esp_spi_flash.h"
#include "esp_log.h"

#include "driver/gpio.h"
#include "driver/spi.h"

#define  LED_OUTPUT_PIN_SEL  (1 << GPIO_NUM_2)

#define READ_CMD      0x13
#define WRITE_CMD      0x12

bool isLEDon = false;
SemaphoreHandle_t mutex;
TaskHandle_t spi_task_handle;

void send_spi(spi_trans_t *trans, uint8_t *data, uint8_t length) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.mosi = length * 8;
  trans->mosi = data;
  trans->addr = NULL;
  trans->cmd = NULL;

  spi_trans(HSPI_HOST, trans);
}

void read_spi(spi_trans_t *trans, uint8_t *buf) {
  memset(trans, 0, sizeof(*trans));
  
  trans->bits.miso = 8;
  trans->miso = buf;
  trans->addr = NULL;
  trans->cmd = NULL;
  
  spi_trans(HSPI_HOST, trans);
}

uint8_t readMsgBuf[4];
uint8_t writeMsgBuf[5];
uint8_t recvBuf[1];
spi_trans_t trans;

typedef enum STATE {
  IDLE = 0,
  SENT_WRITE = 1,
  SENT_READ = 2
} STATE;

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  STATE state = IDLE;

  const uint32_t addr = 5829;
  const uint8_t addrMSB =  (addr >> 16);
  const uint8_t addrMLSB = (addr >> 8);
  const uint8_t addrLSB = (addr & 0xFF);

  readMsgBuf[0] = READ_CMD;
  readMsgBuf[1] = addrMSB;
  readMsgBuf[2] = addrMLSB;
  readMsgBuf[3] = addrLSB;

  writeMsgBuf[0] = WRITE_CMD;
  writeMsgBuf[1] = addrMSB;
  writeMsgBuf[2] = addrMLSB;
  writeMsgBuf[3] = addrLSB;
  writeMsgBuf[4] = 133;

  while(true) {
    switch(state) {
      case IDLE: {
        send_spi(&trans, writeMsgBuf, sizeof(writeMsgBuf));

        xSemaphoreTake(mutex, portMAX_DELAY);
        //vTaskSuspend(spi_task_handle);

        state = SENT_WRITE;
      }
      break;

      case SENT_WRITE: {
        send_spi(&trans, readMsgBuf, sizeof(readMsgBuf));

        xSemaphoreTake(mutex, portMAX_DELAY);
        //vTaskSuspend(spi_task_handle);

        state = SENT_READ;
      }
      break;

      case SENT_READ: {
        read_spi(&trans, recvBuf);

        state = IDLE;
      }
      break;
  }

  if(isLEDon) {
    gpio_set_level(GPIO_NUM_2, 1);
    isLEDon = false;
  } else {
    gpio_set_level(GPIO_NUM_2, 0);
    isLEDon = true;
  }

  vTaskDelay(100 / portTICK_PERIOD_MS);
  }
}

void spi_callback(int event, void *arg) {
    switch (event) {
        case SPI_INIT_EVENT: {
      xTaskCreate(spi_master_write_slave_task, "spi_master_write_slave", 2048, NULL, 3, &spi_task_handle);
        }
        break;

        case SPI_TRANS_START_EVENT: {
        }
        break;

        case SPI_TRANS_DONE_EVENT: {
      xSemaphoreGive(mutex);
      //xTaskResumeFromISR(spi_task_handle);
        }
        break;

        case SPI_DEINIT_EVENT: {
        }
        break;
    }
}

void ICACHE_FLASH_ATTR app_main() {
  mutex = xSemaphoreCreateMutex();
  
  gpio_config_t io_conf;
  io_conf.intr_type = GPIO_INTR_DISABLE;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = LED_OUTPUT_PIN_SEL;
  io_conf.pull_down_en = 0;
  io_conf.pull_up_en = 0;
  gpio_config(&io_conf);
  
  spi_config_t spi_config;
  spi_config.interface.val = SPI_DEFAULT_INTERFACE;
  spi_config.intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE;
  spi_config.mode = SPI_MASTER_MODE;
  spi_config.clk_div = SPI_2MHz_DIV;
  spi_config.event_cb = &spi_callback;
  spi_init(HSPI_HOST, &spi_config);
}

Wenn ich anstatt des *Suspend()* und *Resume()* das Mutex verwende, 
funktioniert es (sobald ich xSemaphoreGive aus dem Callback entferne, 
bleibt der Controller stehen, daher gehe ich davon aus, dass die richtig 
funktionieren) im Sinne von "der Controller wartet, bis das SPI-Packet 
erfolgreich übertragen wurde". Bei Resume() und Suspend() bleibt der 
Controller nach dem 1. Suspend stehen.

Im Sinne des eigentlichen Zieles, dass 2 SPI-Pakete richtig übertragen 
werden, ist das Verhalten genauso wie im 1. Beitrag beschrieben.

minifloat schrieb:
> Wäre ja sonst sinnlos.

:(

[Einer K. (Gast)]

minifloat schrieb:
> Ich hab da eine Frage für Dumme.
> Warum heißt es xTaskCreate
> Aber vTaskSuspend und vTaskResume?
>
> btw. Ich hab' keine Erfahrung mit FreeRTOS, alles nur höngengebliebenes
> Wissen aus dem Studium, was man eben über RTOS so vor 5-7 Jahren gelehrt
> hat.

Dann solltest du die aktuelle Doku untersuchen!
Dann stellst du schnell fest, dass die vFunktionen als void definiert 
sind, und die xFunktionen Daten zurückgeben.
Gibt och mehr solcher Präfixe

[minifloat (Gast)]

Arduino Fanboy D. schrieb:
> Dann solltest du die aktuelle Doku untersuchen!

Ich bin nicht der TO. Werde mir daher nicht die Doku rein ziehen, erst 
wenn ich es benötige.
Warum leistest du angesichts deiner FreeRTOS-Allmacht keinen fachlich 
wertvollen Beitrag?

Arduino Fanboy D. schrieb:
> Gibt och mehr solcher Präfixe
Es gibt Leute die...
1 die Ungarische Notation verstehen und sinnvoll einsetzen
2 die Ungarische Notation für outdated halten, da Dank moderner IDEs 
obsolet
3 die Ungarische Notation mit Umgekehrter Polnischer Notation 
verwechseln und dich bei Diskussionen dann wie ein Auto anschauen
4 die Ungarische Notation nicht verstehen und sie falsch einsetzen
5 die Ungarische Notation durch etwas anderes ersetzen, was auch nicht 
sinnvoll ist

mfg mf

[Einer K. (Gast)]

minifloat schrieb:
> Ich bin nicht der TO. Werde mir daher nicht die Doku rein ziehen, erst
> wenn ich es benötige.
> Warum leistest du angesichts deiner FreeRTOS-Allmacht keinen fachlich
> wertvollen Beitrag?

Warum fragst du dann?
Nur um hinterher rum maulen zu können?

Ich wünsche dir:
Frohe Weihnachten.
Und ein schönes neues Jahr, gerne auch ohne solche Ausfälle.

[Max M. (maxmicr)]

Arduino Fanboy D. schrieb:
> Nur um hinterher rum maulen zu können?

Was ist mit dir falsch?



Ich sehe das aktuelle Problem nicht bei FreeRTOS sondern eher den 
System-Funktionen vom ESP8266 die schlecht / gar nicht dokumentiert 
sind.

[Fragender (Gast)]

Max M. schrieb:
> Nun sind beide Nachrichten falsch

Doofe Frage am Rande: Welchen Logicanalyzer und Software nutzt du? Ist 
ähnlich zu Saleae, aber anderes Design. (Wollte mich noch nachträglich 
beschenken.)

[minifloat (Gast)]

Arduino Fanboy D. schrieb:
> [...] gerne auch ohne solche Ausfälle.

Danke, die Ausfälle gebe ich gern zurück.
Wieder kein fachlich sinnvoller Beitrag von dir.

BTT.
Max, dein Mutex würde den Thread erst pausieren, wenn der Callback 
bereits ausgeführt ist. So rennt der Thread weiter und nimmt sich die 
Semaphore.
Ein hässliches Konstrukt mit...

> Thread
> ...
> SemaTake
> SemaTake*
> SemaGive
> ...

> Callback
> ...
> SemaGive
> ...

...kam mir gerade in den Sinn. Der Thread würde beim zweiten SemTake (*) 
stoppen, der Callback gibt wieder frei wenn er soweit ist, Thread nimmt 
erfolgreich und gibt wieder ab.

Hast du schon andere weitere Erkenntnisse, Max?

[Max M. (maxmicr)]

Ich glaub ich habs *Heulen vor Freude*:

#define  LED_OUTPUT_PIN_SEL  (1 << GPIO_NUM_2)

#define READ_CMD      0x13
#define WRITE_CMD      0x12

bool isLEDon = false;
SemaphoreHandle_t mutex;
TaskHandle_t spi_task_handle;

typedef enum STATE {
  IDLE = 0,
  SENT_WRITE = 1,
  SENT_READ = 2
} STATE;

void ICACHE_FLASH_ATTR spi_master_write_slave_task(void *arg) {
  printf("SPI Write-Task started...\n");
  
  uint8_t trans_data[5];
  uint8_t recv_data[1];

  STATE state = IDLE;
  spi_trans_t trans;
  
  memset(&trans, 0, sizeof(trans));
  trans.bits.miso = 0;
  trans.bits.mosi = 0;
  trans.mosi = trans_data;
  trans.miso = recv_data;
  trans.addr = NULL;
  trans.cmd = NULL;

  const uint32_t addr = 5829;
  const uint8_t addrMSB =  (addr >> 16);
  const uint8_t addrMLSB = (addr >> 8);
  const uint8_t addrLSB = (addr & 0xFF);

  while(true) {
    switch(state) {
      case IDLE: {
        xSemaphoreTake(mutex, portMAX_DELAY);
        trans.bits.miso = 0;
        trans.bits.mosi = 5 * 8;
        trans_data[0] = WRITE_CMD;
        trans_data[1] = addrMSB;
        trans_data[2] = addrMLSB;
        trans_data[3] = addrLSB;
        trans_data[4] = 133;
        spi_trans(HSPI_HOST, &trans);
        //vTaskSuspend(spi_task_handle);

        state = SENT_WRITE;
      }
      break;

      case SENT_WRITE: {
        xSemaphoreTake(mutex, portMAX_DELAY);
        trans.bits.miso = 0;
        trans.bits.mosi = 4 * 8;
        trans_data[0] = READ_CMD;
        trans_data[1] = addrMSB;
        trans_data[2] = addrMLSB;
        trans_data[3] = addrLSB;
        spi_trans(HSPI_HOST, &trans);
        //vTaskSuspend(spi_task_handle);

        state = SENT_READ;
      }
      break;

      case SENT_READ: {
        xSemaphoreTake(mutex, portMAX_DELAY);
        trans.bits.mosi = 0;
        trans.bits.miso = 8;
        spi_trans(HSPI_HOST, &trans);
        state = IDLE;
      }
      break;
  }

  if(isLEDon) {
    gpio_set_level(GPIO_NUM_2, 1);
    isLEDon = false;
  } else {
    gpio_set_level(GPIO_NUM_2, 0);
    isLEDon = true;
  }

  vTaskDelay(100 / portTICK_PERIOD_MS);
  }
}

void spi_callback(int event, void *arg) {
    switch (event) {
        case SPI_INIT_EVENT: {
      xTaskCreate(spi_master_write_slave_task, "spi_master_write_slave", 2048, NULL, 3, &spi_task_handle);
        }
        break;

        case SPI_TRANS_START_EVENT: {
        }
        break;

        case SPI_TRANS_DONE_EVENT: {
      xSemaphoreGive(mutex);
      //xTaskResumeFromISR(spi_task_handle);
        }
        break;

        case SPI_DEINIT_EVENT: {
        }
        break;
    }
}

void ICACHE_FLASH_ATTR app_main() {
  mutex = xSemaphoreCreateMutex();
  
  gpio_config_t io_conf;
  io_conf.intr_type = GPIO_INTR_DISABLE;
  io_conf.mode = GPIO_MODE_OUTPUT;
  io_conf.pin_bit_mask = LED_OUTPUT_PIN_SEL;
  io_conf.pull_down_en = 0;
  io_conf.pull_up_en = 0;
  gpio_config(&io_conf);
  
  spi_config_t spi_config;
  spi_config.interface.val = SPI_DEFAULT_INTERFACE;
  spi_config.intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE;
  spi_config.mode = SPI_MASTER_MODE;
  spi_config.clk_div = SPI_2MHz_DIV;
  spi_config.event_cb = &spi_callback;
  spi_init(HSPI_HOST, &spi_config);
}

minifloat schrieb:
> So rennt der Thread weiter und nimmt sich die
> Semaphore.

Stimmt, mein Fehler.

Meinst du, das macht so mehr Sinn?

Fragender schrieb:
> Welchen Logicanalyzer und Software nutzt du? Ist
> ähnlich zu Saleae, aber anderes Design. (Wollte mich noch nachträglich
> beschenken.)

Ist ein Saleae-Klon aus China mit offizieller Software.

[minifloat (Gast)]

Max M. schrieb:
> Meinst du, das macht so mehr Sinn?

Beim Zweiten Durchlauf des Tasks wird an der Semaphore gehalten. Das ist 
u.U. nicht sofort ersichtlich. Insgesamt aber logisch und sauberer als 
mein Vorschlag. Die Struktur "trans" und die Ressource 
"SPI-Schnittstelle" musste ja geschützt werden. Wenn die SPI noch busy 
ist, was du ja im Callback siehst, hat der Task nix dran rum zu fummeln.

mfg mf

[Max M. (maxmicr)]

Ich hab inzwischen ein wenig weiter entwickelt. Man soll nun per 
GET-Aufruf auf die Seite "/set?addr=5423&value=123" einen SPI-Transmit 
mit eben den verwendeten Werten absetzen können (ebenso mit 
"get?addr=5423").

Da ich nun noch das ganze HTTP-Handler Zeug in der main.c hab, dachte 
ich mir der Übersicht halber, das SPI-Handling in eine extra Struktur 
auszulagern:

#define TRANS_ARRAY_LEN    5
#define  RECV_ARRAY_LEN    1

#define WRITE_REQUEST_SIZE  5
#define READ_REQUEST_SIZE  4

typedef enum STATE {
  IDLE = 0,
  READY = 1,
  WROTE_WRITE_CMD = 2,
  WROTE_READ_CMD = 3,
  SENT_READ_CLK = 4
} STATE;

typedef struct SPI_HANDLER {
  
  spi_trans_t spi_t;
  STATE state;

  uint8_t trans_data[TRANS_ARRAY_LEN];
  uint8_t recv_data[RECV_ARRAY_LEN];
  
  void (*finishedWriteRequestCallback)(void);
  void (*finishedReadRequestCallback)(uint8_t data);
  
  void (*writeToRAM)(struct SPI_HANDLER*, uint32_t addr, uint8_t data);
  void (*readFromRAM)(struct SPI_HANDLER*, uint32_t addr);
  void (*notifyTransmitFinished)(struct SPI_HANDLER*);
  
} SPI_HANDLER;

extern void initSPIHandler(SPI_HANDLER *self);

In der Initialisierung wird dann alles vorkonfiguriert:

void ICACHE_FLASH_ATTR initSPIHandler(SPI_HANDLER *self) {
  self->writeToRAM = &writeToRAMRequest;
  self->readFromRAM = &readFromRAMRequest;
  self->notifyTransmitFinished = &notifyTransmitFinished;
  
  self->state = IDLE;
  
  memset(&self->spi_t, 0, sizeof(self->spi_t));
  self->spi_t.bits.miso = 0;
  self->spi_t.bits.mosi = 0;
  self->spi_t.mosi = self->trans_data;
  self->spi_t.miso = self->recv_data;
  self->spi_t.addr = NULL;
  self->spi_t.cmd = NULL;
  
  printf("Finished SPIHandler initialization\n");
}

Wenn jemand nun z.B. "/get?addr=5423" eingibt, wird dieser Handler 
aufgerufen:

esp_err_t ICACHE_FLASH_ATTR get_handler(httpd_req_t *req) {
  printf("/get handler called...\n");

    char*  buf;
    size_t buf_len;
    buf_len = httpd_req_get_url_query_len(req) + 1;
    if (buf_len > 1) {
        buf = malloc(buf_len);
        if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
            char addr_str[7];
            if (httpd_query_key_value(buf, "addr", addr_str, sizeof(addr_str)) == ESP_OK) {
                printf("Found parameter addr=%s\n", addr_str);
        const uint32_t addr = (uint32_t)atoi(addr_str);
        printf("atoi() delivered: %d\n", addr);
        spiHandler.readFromRAM(&spiHandler, addr);
            }
        }
        free(buf);
    }

  char resp[100];
  sprintf(resp, "Reading...");
  httpd_resp_send(req, resp, strlen(resp));

    return ESP_OK;
}

Die Funktion die hinter dem Funktionspointer *spiHandler.readFromRAM* 
steckt, sieht so aus:

void ICACHE_FLASH_ATTR readFromRAMRequest(SPI_HANDLER *self, uint32_t addr) {
  printf("Read from RAM request...\n");
  if(self->state == READY) {
    self->spi_t.bits.miso = 0;
    self->spi_t.bits.mosi = READ_REQUEST_SIZE * 8;

    self->trans_data[0] = READ_CMD;
    fillArrayWithAddr(&self->trans_data[1], addr);
    self->state = WROTE_READ_CMD;
    spi_trans(HSPI_HOST, &self->spi_t); /* ESP stürzt ab */
  } else {
    printf("SPIHandler not ready\n");
  }
}

Nun stürzt der ESP8266 in der markierten Zeile leider ab :(

abort() was called at PC 0x40231393 on core 0

Guru Meditation Error: Core  0 panic'ed (StoreProhibited). Exception was unhandled.

Core 0 register dump:
PC      : 0x402311dd  PS      : 0x00000033  A0      : 0x402311d8  A1      : 0x3ffe8410  

A2      : 0x00000000  A3      : 0x00000000  A4      : 0x00000000  A5      : 0x00000001  

A6      : 0x00000001  A7      : 0x402549ac  A8      : 0x00000040  A9      : 0x00000001  

A10     : 0x0000002d  A11     : 0x00000040  A12     : 0x3ffecc90  A13     : 0xffffffff  

A14     : 0x00000004  A15     : 0x40106c54  SAR     : 0x0000001e  EXCCAUSE: 0x0000001d

29  StoreProhibited:  CPU tried to store memory from a region which is protected against writes

https://github.com/SuperHouse/esp-open-rtos/wiki/Crash-Dumps

Aha...

Ich hab leider keine Ahnung warum, sobald ich den Funktionsaufruf 
spi_trans rausnehme, stürzt er nicht mehr ab (aber es passiert 
natürlich auch nichts).

Ich weiß nicht, ob das wieder so ein "printf"-Ding ist wie beim 
SPI-Callback oder ob die interne WLAN-Routine zu wenig Rechenzeit 
bekommt und deswegen der Watchdog den ESP killt (kann ich mir ja fast 
nicht vorstellen, so viel passiert nun auch nicht). Den RTOS-Task hab 
ich auch rausgeschmissen, so wirklich viel Sinn hatte der nicht wenn das 
eh alles asynchron läuft mit dem SPI-Event. War das ein Fehler? Muss so 
ein Task existieren damit das RTOS vernünftig läuft?

Allgemein bin ich nicht so zufrieden, selbst wenn die aktuelle Lösung 
funktionieren würde, da die Antwort asynchron zum HTTP-GET Aufruf 
passiert.

Aktuell liefere ich nach dem Aufruf "Reading..." als HTTP-Response-Body 
zurück. Meine Idee wäre dann, sobald das Byte per SPI gelesen ist (krieg 
ich ja mit über das spi-event:

void ICACHE_FLASH_ATTR spi_callback(int event, void *arg) {
    switch (event) {
        case SPI_INIT_EVENT: {
      spiHandler.state = READY;
        }
        break;

        case SPI_TRANS_START_EVENT: {
        }
        break;

        case SPI_TRANS_DONE_EVENT: {
      spiHandler.notifyTransmitFinished(&spiHandler);
        }
        break;

        case SPI_DEINIT_EVENT: {
        }
        break;
    }
}

)

eine weitere HTTP-Antwort zu schicken. Aber da hab ich dann gar keinen 
Aufruf also kein *httpd_req_t*-Pointer den die Funktion 
httpd_resp_send zur Antwort benötigt - wie mache ich das denn nun?

Unglücklicherweise ist der *http_req_t*-Pointer "verbraucht" sobald man 
eine Antwort gesendet hat (laut einem Kommentar im Espressif-GitHub-Repo 
Example). Alternativ könnte ich gar keine Antwort schicken und mir den 
Pointer merken bis die Antwort da ist...?

Edit: Ich hab probeweise das

spi_trans(HSPI_HOST, &self->spi_t); /* ESP stürzt ab */

mit

while(true);

ersetzt, und der ESP stürzt erst nach ein paar Sekunden mit diesmal 
einer anderen Fehlermeldung ab:

Task watchdog got triggered.



Guru Meditation Error: Core  0 panic'ed (unknown). Exception was unhandled.

Core 0 register dump:
PC      : 0x4022bbc8  PS      : 0x00000030  A0      : 0x4022bbc8  A1      : 0x3fff4310  

A2      : 0x0000000a  A3      : 0x00000000  A4      : 0x00000001  A5      : 0x00000000  

A6      : 0x40230ecc  A7      : 0x00000000  A8      : 0x00000000  A9      : 0x00000001  

A10     : 0x00000000  A11     : 0x0000000a  A12     : 0x3ffead34  A13     : 0x40107bec  

A14     : 0x0000053a  A15     : 0x401076b0  SAR     : 0x0000001c  EXCCAUSE: 0x0000053a

Am Watchdog kanns also nicht liegen.

[minifloat (Gast)]

Max M. schrieb:
> Den RTOS-Task hab ich auch rausgeschmissen, so wirklich viel Sinn hatte
> der nicht wenn das eh alles asynchron läuft mit dem SPI-Event.
Warum, das hat doch super funktioniert?

Kannst du einen Task erstellen, der zyklisch liest (nicht erst auf 
Anfrage) und einen, der sich um HTTP kümmert?
Datenübergabe dann über eine Struktur, die per Mutex geschützt wird.

Oder geht es dir darum, per HTTP-get und -post gezielt SPI-Transfers 
auszulösen?

Ich hab mit dem HTTP-gedöns auch schon ein wenig herumgespielt, 
allerdings ohne RTOS. Dabei ist es von Vorteil gewesen, Daten für HTTP 
(die "Internetseite") dauerhaft bereit zu halten. Datenaustausch erfolgt 
über hin-und-her gehende xml-Objekte. Auf der "Internetseite" läuft 
Javascript, um zyklisch oder auf Trigger hin Daten auszutauschen.

mfg mf

[minifloat (Gast)]

PS. Leider bin ich bis morgen Abend außer Haus,  sonst hätte ich dir 
entsprechende Codeschnipsel  Posten können...

[Max M. (maxmicr)]

minifloat schrieb:
> Warum, das hat doch super funktioniert?

Ich hatte alles in der main.c und das sah furchtbar aus. Deswegen hab 
ich versucht, den SPI-Teil in eben jene extra Struktur auszulagern.

minifloat schrieb:
> Oder geht es dir darum, per HTTP-get und -post gezielt SPI-Transfers
> auszulösen?

Ja genau, man soll mit dem Aufrufen von "/get?addr=xxxxxx" einen 
SPI-Transmit (READ_CMD) auslösen können. Diese Nachricht geht an einen 
ATmega, der dann entsprechend eine Antwort zurückliefert (natürlich 
leider asynchron, d.h. ich weiß (noch) nicht wie ich das mit der Antwort 
dann mache).
Genau das gleiche soll mit "/set?addr=xxxxxx&value=xxx" passieren, nur 
eben WRITE_CMD (und es gibt keine Antwort vom ATmega).

minifloat schrieb:
> Kannst du einen Task erstellen, der zyklisch liest (nicht erst auf
> Anfrage) und einen, der sich um HTTP kümmert?

Sowas fände ich sehr schön, ich hab aus 2017 ein Codebeispiel gefunden 
(das hat nicht funktioniert), die Beispiele vom Espressif-GitHub-Repo 
nutzen HTTP-Request-Handler.

Man legt so eine Struktur an:

httpd_uri_t set = {
    .uri       = "/set",
    .method    = HTTP_GET,
    .handler   = set_handler,
    .user_ctx  = NULL
};

registriert sie beim Webserver

httpd_handle_t ICACHE_FLASH_ATTR start_webserver(void)
{
    httpd_handle_t server = NULL;
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();

    printf("Starting server on port: '%d'\n", config.server_port);
    if (httpd_start(&server, &config) == ESP_OK) {
        printf("Registering URI handlers\n");
        httpd_register_uri_handler(server, &get);
    httpd_register_uri_handler(server, &set);

        return server;
    }

    printf("Error starting server!\n");
    return NULL;
}

und hat einen Handler wie im letzten Beitrag schon gezeigt. D.h. ich 
wüsste nicht, wie ich da einen Task drum rum basteln soll.

Sobald ich die mosi/miso-Arrays, das Anlagen der *spi_trans_t*-Struktur 
wieder nach *main.c*-Verschiebe und spi_trans auch nur dort aufrufe, 
stürzt der ESP nicht mehr ab. Ich weiß nicht, ob sowas möglich wäre, 
aber kann es sein, dass es der ESP einfach nicht mag wenn man in 
externen C-Files die Strukturen für Systemfunktionen anlegt

minifloat schrieb:
> Dabei ist es von Vorteil gewesen, Daten für HTTP
> (die "Internetseite") dauerhaft bereit zu halten.

Ist bestimmt eine gute Idee, aber ich kann nicht vorhersagen, was der 
Benutzer für eine Adresse und Wert eingibt.

minifloat schrieb:
> Leider bin ich bis morgen Abend außer Haus,  sonst hätte ich dir
> entsprechende Codeschnipsel  Posten können...

Mach dir kein Kopf, reicht schon wenn sich einer damit rumärgern müss :/

minifloat schrieb:
> Auf der "Internetseite" läuft
> Javascript, um zyklisch oder auf Trigger hin Daten auszutauschen.

So hatte ich mir das auch gedacht aber ich hab keine Ahnung wie die 
Kommunikation zwischen JavaScript und ESP abläuft.

[minifloat (Gast)]

Max M. schrieb:
> wie ich da einen Task drum rum basteln soll.

Ein Task, der zyklisch die Daten vom SPI in einen Puffer schaufelt. Die 
Get-Handler in der httpd_uri_t Struktur sind auch wieder so lustige 
Callbacks.

Max M. schrieb:
> minifloat schrieb:
>> Auf der "Internetseite" läuft
>> Javascript, um zyklisch oder auf Trigger hin Daten auszutauschen.
>
> So hatte ich mir das auch gedacht aber ich hab keine Ahnung wie die
> Kommunikation zwischen JavaScript und ESP abläuft.

Da kann ich dir morgen Abend paar Schnipsel Javascript dazu posten. Wie 
gesagt ein XML-Objekt je Kommunikationsrichtung.
mfg mf

[minifloat (Gast)]

PS. Ich denke, man kann den HTTP-Get-Callback sicher mit einem Mutex 
kurz pausieren. Da scheint die SPI-Mimik bereits nicht mehr kurz genug.

Was hältst du von folgendem:
1) HTTP-get eine Seite mit Bedienoberfläche und Javascript. Dieses 
Javascript macht dann:
2) HTTP-post ein XML mit den abzusetzenden SPI-Daten(Mosi).
3) HTTP-get ein XML mit
   a) BinNochNichtFertig
   b) BinFertig mit empfangenen SPI-Daten(Miso)

Es empfiehlt sich, die Mosi-Daten und die BinNochNichtFertig- bzw. 
BinFertig-XMLs mit einer ID zu versehen, sonst ist die Synchronisation 
der Benutzeroberfläche Gulasch.
Wenn nochmal Mosi-XML eintrudeln, ohne dass Miso-XML abgeholt wurde, 
wird Miso einfach gelöscht und ein neuer Transferzyklus kann beginnen.

mfg mf

[minifloat (Gast)]

PS. Statt XML-Objekten geht auch JSON.

[Max M. (maxmicr)]

Kann es sein, dass sich WiFi und SPI nicht vertragen?

So sehe ich den Access-Point des ESP:

WEBSERVER webserver;

void ICACHE_FLASH_ATTR spi_callback(int event, void *arg) {
    switch (event) {
        case SPI_INIT_EVENT: {

        }
        break;

        case SPI_TRANS_START_EVENT: {
        }
        break;

        case SPI_TRANS_DONE_EVENT: {

        }
        break;

        case SPI_DEINIT_EVENT: {
        }
        break;
    }
}

void ICACHE_FLASH_ATTR app_main() {
  gpio_config_t io_conf = {
    .intr_type = GPIO_INTR_DISABLE,
    .mode = GPIO_MODE_OUTPUT,
    .pin_bit_mask = LED_OUTPUT_PIN_SEL,
    .pull_down_en = 0,
    .pull_up_en = 0
  };
  gpio_config(&io_conf);
  gpio_set_level(GPIO_NUM_2, LED_OFF);
  
  spi_config_t spi_config = {
    .interface.val = SPI_DEFAULT_INTERFACE,
    .intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE,
    .mode = SPI_MASTER_MODE,
    .clk_div = SPI_2MHz_DIV,
    .event_cb = &spi_callback
  };
  spi_init(HSPI_HOST, &spi_config);
  
  initWebserver(&webserver, "Projekt", "");
}

und so nicht:

SPI_HANDLER spiHandler;
WEBSERVER webserver;

void ICACHE_FLASH_ATTR spi_callback(int event, void *arg) {
    switch (event) {
        case SPI_INIT_EVENT: {
      spiHandler.state = READY;
        }
        break;

        case SPI_TRANS_START_EVENT: {
        }
        break;

        case SPI_TRANS_DONE_EVENT: {
      
        }
        break;

        case SPI_DEINIT_EVENT: {
        }
        break;
    }
}

void ICACHE_FLASH_ATTR app_main() {
  gpio_config_t io_conf = {
    .intr_type = GPIO_INTR_DISABLE,
    .mode = GPIO_MODE_OUTPUT,
    .pin_bit_mask = LED_OUTPUT_PIN_SEL,
    .pull_down_en = 0,
    .pull_up_en = 0
  };
  gpio_config(&io_conf);
  gpio_set_level(GPIO_NUM_2, LED_OFF);
  
  spi_config_t spi_config = {
    .interface.val = SPI_DEFAULT_INTERFACE,
    .intr_enable.val = SPI_MASTER_DEFAULT_INTR_ENABLE,
    .mode = SPI_MASTER_MODE,
    .clk_div = SPI_2MHz_DIV,
    .event_cb = &spi_callback
  };
  spi_init(HSPI_HOST, &spi_config);
  
  initSPIHandler(&spiHandler);
  initWebserver(&webserver, "Projekt", "");
}

Das kann doch nicht sein? ???

[minifloat (Gast)]

minifloat schrieb:
> Da kann ich dir morgen Abend paar Schnipsel Javascript dazu posten.

Habe herade gesehen, dass ich das Ding "mit Arduino" erstellt habe.
Leider nur eine unfertige Version. Das Konzept sollte aber klar sein.
Dann muss ich mich bei dir entschuldigen, das hier...

minifloat schrieb:
> Wie gesagt ein XML-Objekt je Kommunikationsrichtung.

...stimmt bei meiner Umsetzung nicht.

Ich lade die HTML-Seite, diese lädt sich ein XML. Im XML befinden sich 
die Daten, die von den Bedienelementen dargestellt werden 
sollen(ESP8266->Webseite). Kommandos (Webseite->ESP8266) werden über den 
requeststring des XMLs ausgetauscht.

mfg mf

[Max M. (maxmicr)]

Vielen Dank für deine Hilfe. Das sieht gut aus, dann weiß ich ungefähr 
wie ich das machen muss.

Max M. schrieb:
> Das kann doch nicht sein? ???

Hab das Problem inzwischen tatsächlich mit zwei Queues gelöst bekommen, 
die sich mit dem FreeRTOS sehr komfortabel erstellen lassen.
Ich hatte da ein paar Pointer / Struktur-Fehler die beim ESP für sehr 
seltsames Verhalten gesorgt haben (aber keine Absturzmeldung) weswegen 
ich darauf erstmal nicht aufmerksam geworden bin.

Falls es jemanden nützt, so sieht nun der Event-Handler des Webservers 
aus:

esp_err_t ICACHE_FLASH_ATTR get_handler(httpd_req_t *req) {
  printf("/get handler called...\n");

    char*  buf;
    size_t buf_len;
  char resp_msg[100];
    buf_len = httpd_req_get_url_query_len(req) + 1;
    if (buf_len > 1) {
        buf = malloc(buf_len);
        if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
            char addr_str[7];
            if (httpd_query_key_value(buf, "addr", addr_str, sizeof(addr_str)) == ESP_OK) {
                printf("Found parameter addr=%s\n", addr_str);
    const uint32_t addr = (uint32_t)atoi(addr_str);
    printf("atoi() delivered: %d\n", addr);
    
    SPI_RESPONSE spi_resp;
    SPI_REQUEST spi_req = {
      .type = READ_CMD,
      .addr = addr,
      .data = 0
    };

    uint8_t ret = xQueueSend(webserver.toSPIQueue, &spi_req, 0);
    if(ret == pdTRUE) {
      ret = xQueueReceive(webserver.toWebserverQueue, &spi_resp, 5000 / portTICK_RATE_MS);
      
      if(ret == pdTRUE) {
        sprintf(resp_msg, "Value=%d", spi_resp.data);
      } else {
        sprintf(resp_msg, "Didn't receive answer within 5s");
      }
    } else {
      sprintf(resp_msg, "Request-Queue of SPIHandler is full");
    }
    
    httpd_resp_send(req, resp_msg, strlen(resp_msg));
            }
        }
        free(buf);
    }

    return ESP_OK;
}

Und so der SPIHandler-Task (der Webserver selbst hat keinen Task):

void ICACHE_FLASH_ATTR spi_handler_task(void *arg) {
  
  SPI_REQUEST req;
  SPI_RESPONSE resp;

  while(true) {
    if(spiHandler.state == READY) {
      const uint8_t queue_resp = xQueueReceive(spiHandler.toSPIQueue, &req, 0);
      if(queue_resp && xSemaphoreTake(spiHandler.mutex, portMAX_DELAY )) {
        printf("SPIHandler: Got SPI_REQUEST...");
        if(req.type == READ_CMD) {
          printf("of type READ with %d\n", req.addr);
          uint8_t trans_data[READ_REQUEST_SIZE];
          fillReadRequest(trans_data, req.addr);

          spiHandler.spi_t.bits.mosi = READ_REQUEST_SIZE * 8;
          spiHandler.spi_t.bits.miso = 0;
          spiHandler.spi_t.mosi = trans_data;
          printf("Set up SPI buffer, transmitting...");
          spi_trans(HSPI_HOST, &spiHandler.spi_t);
          printf("done\n");
          spiHandler.state = WROTE_READ_CMD;
        } else if(req.type == WRITE_CMD) {
          printf("of type WRITE with %d|%d\n", req.addr, req.data);
          uint8_t trans_data[WRITE_REQUEST_SIZE];
          fillWriteRequest(trans_data, req.addr, req.data);
          spiHandler.spi_t.bits.mosi = WRITE_REQUEST_SIZE * 8;
          spiHandler.spi_t.bits.miso = 0;
          spiHandler.spi_t.mosi = trans_data;
          printf("Set up SPI buffer, transmitting...");
          spi_trans(HSPI_HOST, &spiHandler.spi_t);
          printf("done\n");
          spiHandler.state = WROTE_WRITE_CMD;
        }
      }
    } else {
      if(xSemaphoreTake(spiHandler.mutex, portMAX_DELAY)) {
        switch(spiHandler.state) {
          case WROTE_READ_CMD: {
            printf("Substate 'WROTE_READ_CMD' for READ-REQUEST, setting up SPI buffer...");
            spiHandler.spi_t.bits.mosi = 0;
            spiHandler.spi_t.bits.miso = 8;
            spiHandler.spi_t.miso = recv_data;
            printf("done. Transmitting...");
            spi_trans(HSPI_HOST, &spiHandler.spi_t);
            printf("done\n");
            spiHandler.state = SENT_READ_CLK;
          } break;
          case SENT_READ_CLK: {
            printf("Substate 'SENT_READ_CLK' for READ-Request, received response\n");
            resp.addr = req.addr;
            resp.data = recv_data[0];
            spiHandler.state = READY;
            printf("Push result into queue...");
            xQueueSend(spiHandler.toWebserverQueue, &resp, 0);
            printf("done\n");
            xSemaphoreGive(spiHandler.mutex);
          } break;
          case WROTE_WRITE_CMD: {
            xQueueSend(spiHandler.toWebserverQueue, &resp, 0);
            spiHandler.state = READY;
            xSemaphoreGive(spiHandler.mutex);
          } break;
          default: break;
        }
      }
    }
    
    vTaskDelay(10 / portTICK_RATE_MS);
  }
}

Ursprünglich wollte ich zwei Arrays, die ich in der Struktur 
SPI_HANDLER angelegt habe, für MISO/MOSI verwenden. Aber da wurden 
dann wieder mehrere Nullen übertragen (wie im ursprünglichen Beitrag).

Mit lokalen Arrays so wie oben dargestellt, die eigentlich außerhalb des 
Scopes liegen, funktioniert es dann seltsamerweise.
So ganz verstanden hab ich es noch nicht.

[minifloat (Gast)]

Max M. schrieb:
> Vielen Dank für deine Hilfe.

Bitte gerne. Note to self: Lichtsteuerung zuende coden und die seit 3 
Jahren laufene noch üblere Bastelversion damit ersetzen...

Schön, dass es jetzt ein bisschen mehr funzt :)

mfg mf