esp32, CPU1 ganz für mich

[Martin B. (ratazong)]

Hallo zusammen,
der esp32 ist Dank seines RTOS nicht ganz echtzeitfähig. Man kann aber 
die CPU1 einfach ganz für sich bekommen.

Beispiel ist einfacher Rechteckgenerator:
Ich habe auf esp32-s3 getested mit der idf (bleeding edge), das sollte 
aber auch auf esp32 WROOM32 laufen:

/*
 * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */

#include <stdint.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "sdkconfig.h"

static const char *TAG = "example";

#define OUT_PORT 9

static volatile int cpu1Cnt=0;

/*------------------------------------------------------------------------*\
\*------------------------------------------------------------------------*/
void IRAM_ATTR task_cpu1(void *dummy)
{
  // first config the outputs
    gpio_config_t io_conf = {};
    //disable interrupt
    io_conf.intr_type = GPIO_INTR_DISABLE;
    //set as output mode
    io_conf.mode = GPIO_MODE_OUTPUT;
    //bit mask of the pins that you want to set,e.g.GPIO18/19
    io_conf.pin_bit_mask = (1<<OUT_PORT);
    //disable pull-down mode
    io_conf.pull_down_en = 0;
    //disable pull-up mode
    io_conf.pull_up_en = 0;
    //configure GPIO with the given settings
    gpio_config(&io_conf);
  
  // now disable interrupts for CPU1
  portDISABLE_INTERRUPTS();
  // never enable it again, so Taskscheduler will not steal cycles
  // DMA will steal them nevertheless
  // if you uncomment it, you will see interrutions of about 10 us every RTOS tick
  
#if 1  // slow version, generates about 1 MHz at fCPU = 160 MHz on ESP32-S3
  while(1)
  {
    gpio_set_level(OUT_PORT, 0);
    cpu1Cnt ++;
    gpio_set_level(OUT_PORT, 1);
  }
#else   // fast Version with direct access to the GPIO register
    // generates about 8 MHz square at fCPU = 160 MHz on esp32-s3
  // register addresses are valid only for esp32-s3
  volatile uint32_t * pGPIOw1tc = (uint32_t *)0x6000400c;
        volatile uint32_t * pGPIOw1ts = (uint32_t *)0x60004008;
        volatile uint32_t * pGPIOin = (uint32_t *)0x6000403c;
  while(1)
  {
    *pGPIOw1tc = (1 << OUT_PORT); // clear Port
    *pGPIOw1ts = (1 << OUT_PORT); // set Port
  }
#endif  
}

/*------------------------------------------------------------------------*\
\*------------------------------------------------------------------------*/
void tuwas(void)
{
    volatile int i,k,jj=0;
    for(k=0;k<10000;k++)
    {
        for(i=0;i<1000;i++) jj+= k+i;
    }
}

/*------------------------------------------------------------------------*\
\*------------------------------------------------------------------------*/
void app_main(void)
{
    ESP_LOGI(TAG, "Start CPU1");
    xTaskCreatePinnedToCore(task_cpu1, "tskCpu1", 2048, NULL, 10, NULL, 1);
    
  int Cnt=0;
  while (1)
  {
    ESP_LOGI(TAG,"Cnt = %d, cpu1Cnt = %d",Cnt,cpu1Cnt);
    Cnt++;
    tuwas();
  }
}

Damit das läuft, müssen Watchdogs disabled werden. Also idf Anleitung:

idf.py settarget esp32-s3
idf.py menuconfig
   bei menuconfig unter component config/esp system settings
   1) disable: Initialize task watchdog timer on startup
   2) disable: also watch cpu1 timer tick
idf.py - p yourComPort flash monitor

Wenn es mal einer mit dem normale esp probiert, mag der ja seine 
Ergenisse hier berichten. Ich habe gerade keinen zur Hand.

idf-projekt habe ich als zip angehängt. Vielleicht hilft es ja jemandem

-Martin

[Martin B. (ratazong)]

huch, Formatierung ist mist.
habe wohl tabs und leerzeichen gemischt

[Wolfgang (Gast)]

Martin B. schrieb:
> RTOS nicht ganz echtzeitfähig

Übersetze mal das "RT" von RTOS auf deutsch ;-)

"echtzeitfähig" ist eine ziemlich leere Buzz-Worthülse