ESP32 LOLIN S3

[kapu48]

Írtam egy teszt programot:

Kód: Egész kijelölése

/*	
ESP32_S3_PSRAM_activation.ino 
forrás: https://forum.arduino.cc/t/esp32-how-to-use-psram-ps-malloc/1055481/2
Board
https://www.cnx-software.com/2022/08/28/7-lolin-s3-esp32-s3-board-ships-with-micropython-firmware/
LOLIN-S3-N16R8
Device Description
IDE Name
Arduino IDE 2.0.2
Operating System
Win10
Flash frequency
QIO 120Mhz      adat vonal:4bits
psRam frequency
OIO 120Mhz      adat vonal:8bits
Upload speed
921600
Description
IDE params are :

CPU Frequency 240Mhz,
Flash Size : 16mb
psRam Size :  8mb
Partition Scheme : Huge app
Core Debug Level : Nothing
Arduino run on Core 1
Events run on core 1

ESP32 S3 - A PSRAM aktiválása

Sketch
*/

//#include "main.h"

void   printPsramSize();

uint32_t i_u32 = 0;
uint16_t n_elements = 1024;
uint16_t *ps_data_all;       //  pointer a lefoglalt psRam területre

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  //Wire.begin();
  Serial.printf("\nStart Example.\n");
  ps_data_all = (uint16_t *) ps_malloc (n_elements * sizeof (uint16_t));
  if(ps_data_all == NULL){ 
    Serial.printf("Error: ps_data_all=ps_malloc!\n");
  } else{
 
    psramInit();
    printPsramSize();
  }
 
}

void loop() {
  // test ps_data_all
  for(uint16_t i = 0; i < n_elements; i++){
    ps_data_all[i] = i;                       //  irás
    Serial.printf("ps_data_all[%d] : %d \n", i, ps_data_all[i]);  //  olvasás
  }
  // a lefoglalt terület
  printPsramSize();
  // Free the memory
  free(ps_data_all);
  // teszt: 
  printPsramSize();

  while(1){
    
  }
}

void   printPsramSize(){
  uint32_t sizePSRAM = ESP.getPsramSize();
  Serial.printf("PSRAM init -> size PSRAM : %d Byte\n", sizePSRAM);
  uint32_t freePSRAM = ESP.getFreePsram();
  Serial.printf("Free PSRAM : %d Byte\n", freePSRAM);
  Serial.printf("Foglalt PSRAM : %d Byte\n", sizePSRAM-freePSRAM);
}

Az eredmény:
mem.Lefoglalás után:
PSRAM init -> size PSRAM : 8386147 Byte
Free PSRAM : 8383839 Byte
Foglalt PSRAM : 2308 Byte
mem.Felszabadítás után
PSRAM init -> size PSRAM : 8386163 Byte
Free PSRAM : 8385903 Byte
Foglalt PSRAM : 260 Byte
A kérdésem: Mért maradt a 260 Byte lefoglalva?

[kapu48]

Végül a fenti kérdés nem okoz problémát, valószínűleg a fájl rendszer létrehozása foglalta le.

Felmerült egy következő kérdés, az alábbi 2 alkalmazást lehet egyszerre használni?:

Kód: Egész kijelölése

#include "FFat.h"
#include <EEPROM.h>

Mivel mind a kettő a flasht használja de más módon.

(Sajnos elég kicsi a forgalom már itt! )

[kapu48]

Egyre jobban tetszik ez a board!

Board: ESP32 LOLIN S3 https://shop.tavir.hu/termek/shop/ardui ... -esp32-s3/
"PCF8574.h" // I2C bővítő: https://github.com/xreef/PCF8574_library Ez jó az ESP32S3-hoz!
<LiquidCrystal_I2C.h> // LCD 20*4: https://github.com/fdebrabander/Arduin ... 2C-library
A fenteb létrehozott rendszer könnyen használható:
psramInit();-> Beállítások: Menü: Tols/USB mode/USB OTG. kábel: USB_OTG<->PC USB. PC-n Irható/Olvasható a létrehozott fájl rendszer
Ez főleg a HTML.... alkalmazásoknál hasznos!
Amiket a rövid egy hét alatt sikerrel használtam:
Eszközök: Serial.begin(115200), SPI.begin(), Wire.begin(), lcd.begin(), FFat.begin()
FastLED.h: CRGB leds[NUM_LEDS]; // WS2812B_RGB_LED (pin 38)
"esp_dsp.h" https://github.com/espressif/esp-dsp
4*4 gomb mátrix illesztés: PCF8574 // I2C bővítő:

Ajánlom az olcsó árához képest nagyon jól felszerelt!
(Remélem a jövőben több hozzászólás lesz!)

[kapu48]

Itt az LCD rutin:

Kód: Egész kijelölése

// I2cLcd.ino // ESP32 lolin S3. kártyához
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>  //  https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

// Define I2C connections
#define I2C0_SDA     42
#define I2C0_SCL     41

uint32_t wire_frequency = 400000;

// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup()
{
  Serial.begin(115200);
  // uint32_t frequency=0 returns true, if successful init of i2c bus
  if(!Wire.begin(I2C0_SDA, I2C0_SCL, wire_frequency)){
    Serial.printf("\nERROR Wire!\n");
  } 
	// initialize the LCD
	lcd.begin();

	// Turn on the blacklight and print a message.
	lcd.backlight();
  lcd.clear();
	lcd.print("Hello, world!");
  lcd.setCursor(0,1);
  lcd.print("Hello, Jani!");
  lcd.setCursor(0,2);
  lcd.print("Hello, Kapu48!");
  lcd.setCursor(0,3);
  lcd.print("01234567890123456789");  
  delay(20000);
  lcd.clear();  
}

void loop()
{
	// Do nothing here...
}

[kapu48]

És a FFAT létrehozás:

Kód: Egész kijelölése

#include "FS.h"
#include "FFat.h"

// This file should be compiled with 'Partition Scheme' (in Tools menu)
// set to 'Default with ffat' if you have a 4MB ESP32 dev module or
// set to '16M Fat' if you have a 16MB ESP32 dev module.
//  HU.:
// Ezt a fájlt a 'Partíciós séma' segítségével kell lefordítani (az Eszközök menüben)
// állítsa 'Default with ffat' értékre, ha 4MB ESP32 fejlesztői modulja van, vagy
// állítsa '16M Fat' értékre, ha 16 MB-os ESP32 fejlesztői modulja van.

// You only need to format FFat the first time you run a test
// Csak a teszt első futtatásakor kell formázni az FFat fájlt
//#define FORMAT_FFAT true
#define FORMAT_FFAT false

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
    Serial.printf("Listing directory: %s\r\n", dirname);

    File root = fs.open(dirname);
    if(!root){
        Serial.println("- failed to open directory");
        return;
    }
    if(!root.isDirectory()){
        Serial.println(" - not a directory");
        return;
    }

    File file = root.openNextFile();
    while(file){
        if(file.isDirectory()){
            Serial.print("  DIR : ");
            Serial.println(file.name());
            if(levels){
                listDir(fs, file.path(), levels -1);
            }
        } else {
            Serial.print("  FILE: ");
            Serial.print(file.name());
            Serial.print("\tSIZE: ");
            Serial.println(file.size());
        }
        file = root.openNextFile();
    }
}

void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\r\n", path);

    File file = fs.open(path);
    if(!file || file.isDirectory()){
        Serial.println("- failed to open file for reading");
        return;
    }

    Serial.println("- read from file:");
    while(file.available()){
        Serial.write(file.read());
    }
    file.close();
}

void writeFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Writing file: %s\r\n", path);

    File file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("- failed to open file for writing");
        return;
    }
    if(file.print(message)){
        Serial.println("- file written");
    } else {
        Serial.println("- write failed");
    }
    file.close();
}

void appendFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Appending to file: %s\r\n", path);

    File file = fs.open(path, FILE_APPEND);
    if(!file){
        Serial.println("- failed to open file for appending");
        return;
    }
    if(file.print(message)){
        Serial.println("- message appended");
    } else {
        Serial.println("- append failed");
    }
    file.close();
}

void renameFile(fs::FS &fs, const char * path1, const char * path2){
    Serial.printf("Renaming file %s to %s\r\n", path1, path2);
    if (fs.rename(path1, path2)) {
        Serial.println("- file renamed");
    } else {
        Serial.println("- rename failed");
    }
}

void deleteFile(fs::FS &fs, const char * path){
    Serial.printf("Deleting file: %s\r\n", path);
    if(fs.remove(path)){
        Serial.println("- file deleted");
    } else {
        Serial.println("- delete failed");
    }
}

void testFileIO(fs::FS &fs, const char * path){
    Serial.printf("Testing file I/O with %s\r\n", path);

    static uint8_t buf[512];
    size_t len = 0;
    File file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("- failed to open file for writing");
        return;
    }

    size_t i;
    Serial.print("- writing" );
    uint32_t start = millis();
    for(i=0; i<2048; i++){
        if ((i & 0x001F) == 0x001F){
          Serial.print(".");
        }
        file.write(buf, 512);
    }
    Serial.println("");
    uint32_t end = millis() - start;
    Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
    file.close();

    file = fs.open(path);
    start = millis();
    end = start;
    i = 0;
    if(file && !file.isDirectory()){
        len = file.size();
        size_t flen = len;
        start = millis();
        Serial.print("- reading" );
        while(len){
            size_t toRead = len;
            if(toRead > 512){
                toRead = 512;
            }
            file.read(buf, toRead);
            if ((i++ & 0x001F) == 0x001F){
              Serial.print(".");
            }
            len -= toRead;
        }
        Serial.println("");
        end = millis() - start;
        Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
        file.close();
    } else {
        Serial.println("- failed to open file for reading");
    }
}

void setup(){
    Serial.begin(115200);
   // Serial.setDebugOutput(true);
    if (FORMAT_FFAT) FFat.format();
    if(!FFat.begin()){
        Serial.println("FFat Mount Failed");
        return;
    }

    Serial.printf("Total space: %10u\n", FFat.totalBytes());
    Serial.printf("Free space: %10u\n", FFat.freeBytes());
    listDir(FFat, "/", 0);
    writeFile(FFat, "/hello.txt", "Hello ");
    appendFile(FFat, "/hello.txt", "World!\r\n");
    readFile(FFat, "/hello.txt");
    renameFile(FFat, "/hello.txt", "/foo.txt");
    readFile(FFat, "/foo.txt");
    deleteFile(FFat, "/foo.txt");
    testFileIO(FFat, "/test.txt");
    Serial.printf("Free space: %10u\n", FFat.freeBytes());
    deleteFile(FFat, "/test.txt");
    Serial.println( "Test complete" );
}

void loop(){

}

[Robert]

EEPROM és FAT együtt: lehet. Fontos azonban, hogy először az EEPROM initje legyen meg + foglalás.
Utána a Filerendszeré. Így alakul ki a foglalási kiosztás, ami a köv indításkor is azonos lesz.

[kapu48]

Köszi! Akkor ezt igy csinálom majd.
Robi már kinőtem az eredeti elnevezést! Át tudnád nevezni a témát?
Mondjuk: ESP32 LOLIN S3 fejlesztések-re?

Még az RGB_LED WS2812 ami különleges ezen a boardon, legyen itt hozzá egy kipróbáld program:
RGB LED Show:

Kód: Egész kijelölése

// LCD_RGBled.ino
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arduino.h>
//#include <SPI.h>
#include "pins_arduino.h"
#include "FastLED.h"      // https://github.com/FastLED/FastLED 
#include "Wire.h"  // https://www.mischianti.org/2019/01/02/pcf8574-i2c-digital-i-o-expander-fast-easy-usage/ 
#include <LiquidCrystal_I2C.h>  //  https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

// Define I2C connections pins:
#define I2C0_SDA     42
#define I2C0_SCL     41
#define I2C0_INT     45
// RGB_LED WS2812
#define LED_PIN      38
#define NUM_LEDS      1
#define BRIGHTNESS   30
#define LED_TYPE     WS2812
#define COLOR_ORDER  GRB
#define UPDATES_PER_SECOND 1000
// LCD 20*4 karakter
#define LCD_COLS  20
#define LCD_ROWS   4
#define I2C_PCF8574_ADDR7 0x27    //  I2C LCD 20*4 karakter
#define I2C_PCF8574_ADDR1 0x21    // I2C INPUT 8 * button
#define I2C_PCF8574_ADDR2 0x22    //  I2C 4 OUTPUT, 4 INPUT gomb mátrix
#define I2C_PCF8574_ADDR3 0x23
#define I2C_PCF8574_ADDR4 0x24

void loop();

uint32_t wire_frequency = 400000;
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(I2C_PCF8574_ADDR7, LCD_COLS, LCD_ROWS);

// Az esp32 esetében közvetlenül átadhatja a TwoWire-t, így kiválaszthatja a másodlagos i2c csatornát:
// Instantiate Wire for generic use at 400kHz
TwoWire I2Cone = TwoWire(0);
// Instantiate Wire for generic use at 100kHz
TwoWire I2Ctwo = TwoWire(1);

// Representation of an RGB pixel (Red, Green, Blue)
CRGB leds[NUM_LEDS];

void setup() {
  Serial.begin(115200);
 // uint32_t frequency=0 returns true, if successful init of i2c bus
  if(!Wire.begin(I2C0_SDA, I2C0_SCL, wire_frequency)){
    Serial.printf("\nERROR Wire!\n");
  } 
	// initialize the LCD
	lcd.begin();
 	// Turn on the blacklight and print a message.
  lcd.clear();
	lcd.backlight();
	lcd.print("Hello, World!"); 
  lcd.setCursor(0,1);
  lcd.print("WS2812 RGB LED SHOW!");
  FastLED.addLeds<LED_TYPE, LED_PIN, GRB>(leds, NUM_LEDS);

}

void loop() {
  rgbShow();

}

void rgbShow(){
  leds[0] = CRGB(255-BRIGHTNESS, 0, 0);
  FastLED.show();
  delay(UPDATES_PER_SECOND);  
  leds[0] = CRGB(0, 255-BRIGHTNESS, 0);
  FastLED.show();
  delay(UPDATES_PER_SECOND);
  leds[0] = CRGB(0, 0, 255-BRIGHTNESS);
  FastLED.show();
  delay(UPDATES_PER_SECOND);
  leds[0] = CRGB(255-BRIGHTNESS, 255-BRIGHTNESS, 255-BRIGHTNESS);
  FastLED.show();

  delay(UPDATES_PER_SECOND);
  leds[0] = CRGB(255-BRIGHTNESS, 0, 255-BRIGHTNESS);
  FastLED.show();
  delay(UPDATES_PER_SECOND);
  leds[0] = CRGB(255-BRIGHTNESS, 255-BRIGHTNESS, 0);
  FastLED.show();
  delay(UPDATES_PER_SECOND);
  leds[0] = CRGB(0, 255-BRIGHTNESS, 255-BRIGHTNESS);
  FastLED.show();
  delay(UPDATES_PER_SECOND);
}

Ehhez több féle alkalmazást találtam, ez volt az első amit sikeresen futtatam.
A pin kivezetések eltérnek a szokványostól, ezért nagyon oda kel figyelni mit hova lehet bekötni.

[Robert]

Az EGB ledsorra van egy komplett alkalmazáscsomag (persze okosotthon irányból).
WLED a csomag neve, és mindenféle vicik-vacak van benne...

[μProfessor]

WS2812B-t és társait (aka NeoPixel) elég sok módon meg lehet hajtani az ESP32-S3 magokkal.

• Az infra távirányítás meghajtására tervezett RMT https://docs.espressif.com/projects/esp ... s/rmt.html tágabb alkalmazása a kedvencem. Jól használja a hardvert, precíz a kimenő jel.

• Furmányosabb az IIC busz megtrükközése, ez is hardverre bízza az időzítést, kicsit instabilabb a végeredmény.

• És lehet teljesen szoftveres magközelítéseket is találni, azokba más (főleg megszakításos) folyamatok bekavarhatnak.

Itt egy rövid elemzés más tollából: https://blog.ja-ke.tech/2019/06/02/neop ... mance.html

[tokyo]

WS2812B-t és társait (aka NeoPixel) elég sok módon meg lehet hajtani az ESP32-S3 magokkal.

• Az infra távirányítás meghajtására tervezett RMT https://docs.espressif.com/projects/esp ... s/rmt.html tágabb alkalmazása a kedvencem. Jól használja a hardvert, precíz a kimenő jel.

• Furmányosabb az IIC busz megtrükközése, ez is hardverre bízza az időzítést, kicsit instabilabb a végeredmény.

• És lehet teljesen szoftveres magközelítéseket is találni, azokba más (főleg megszakításos) folyamatok bekavarhatnak.

Itt egy rövid elemzés más tollából: https://blog.ja-ke.tech/2019/06/02/neop ... mance.html

Nagyszerű, hogy megosztottad az ESP32-S3 magokkal történő WS2812B (NeoPixel) vezérlésének különböző módjait! Az RMT (Remote Control) használata valóban hatékony és precíz módszer, különösen az infravörös távirányításnál, és jó látni, hogy a hardveres megközelítést a LED vezérléséhez is sikeresen alkalmazzák.

Az I2C busz használata is érdekes lehet, de mint mondtad, az időzítésnek fontos szerepe van, és ez okozhat instabilitást. Fontos megjegyezni, hogy a hardveres megközelítések általában megbízhatóbbak és pontosabbak.

Az szoftveres megközelítés is hasznos lehet bizonyos alkalmazásokban, de valóban kényes lehet a megszakítások és más folyamatok beavatkozása miatt.

Az elemzési link is informatív, és hozzájárul az ESP32-S3 és WS2812B vezérlési módszereinek jobb megértéséhez. Köszönjük, hogy megosztottad ezt az értékes információt!