[Rozwiązano] [ESP-IDF] Pobranie informacji o częstotliwości pracy wybranego rdzenia w ESP32

khoam napisał:

Napisz funkcję w C, której zadaniem będzie pobranie informacji o częstotliwości pracy wybranego rdzenia w ESP32. Użyj ESP-IDF.

Oczywiście, chętnie pomogę Ci napisać taką funkcję. W ESP32, aby odczytać częstotliwość pracy rdzenia, możesz skorzystać z funkcji `esp_clk_cpu_freq()` dostępnej w ESP-IDF, która zwraca częstotliwość pracy CPU w Hz.

Poniżej znajdziesz przykład funkcji `get_core_frequency()`, która odczytuje i zwraca częstotliwość pracy wybranego rdzenia ESP32:



Warto zauważyć, że w ESP32 oba rdzenie (jeśli używasz dwurdzeniowej wersji ESP32) pracują zazwyczaj z tą samą częstotliwością, więc powyższa funkcja zwróci taką samą wartość dla obu rdzeni. Jeśli jednak pracujesz na wersji ESP32, która pozwala na niezależne sterowanie częstotliwością rdzeni, będziesz musiał poszukać innych funkcji specyficznych dla tej konfiguracji.

Pamiętaj, że kod należy skompilować i załadować do ESP32 za pomocą narzędzi dostarczonych przez ESP-IDF. Po uruchomieniu na ESP32, powyższy program wydrukuje na konsoli częstotliwość pracy rdzenia CPU.

khoam napisał:

Chodzi o funkcję, która będzie przyjmowała jako argument numer rdzenia i dla tego rdzenia zwracała częstotliwość jego pracy.

Zrozumiałem, chciałbyś funkcję, która przyjmuje jako argument numer rdzenia i zwraca dla niego częstotliwość pracy. W ESP32 oba rdzenie zazwyczaj działają z tą samą taktem zegara, a SDK nie zapewnia bezpośredniego API do uzyskania częstotliwości dla poszczególnych rdzeni. Częstotliwość taktowania rdzeni jest wspólna dla obu i zarządzana przez drivera systemowego, a konfiguracja ta jest globalna i niezależna od numeru rdzenia.

Pomimo to, poniżej podaję przykład funkcji, która przyjmuje numer rdzenia jako argument i zwraca częstotliwość pracy, jednak należy zaznaczyć, że zwracana wartość będzie taka sama dla obu rdzeni. Możemy również dodać prosty mechanizm sprawdzający, czy podany numer rdzenia jest prawidłowy (ESP32 ma rdzenie o numerach 0 i 1):



Należy pamiętać, że jeśli w przyszłości ESP-IDF wprowadzi obsługę indywidualnego taktowania rdzeni, powyższa funkcja może wymagać aktualizacji, aby odzwierciedlać te zmiany. Na obecną chwilę jednak wspomniana funkcjonalność nie jest dostępna w oficjalnym SDK dla ESP32.

khoam napisał:

Wcale tak być nie musi. Rozważ użycie funkcji esp_ipc_call().

Rozumiem, chcesz wykorzystać `esp_ipc_call()` do uruchomienia kodu na określonym rdzeniu, co może być przydatne w niektórych sytuacjach, gdzie chcesz sprawdzić, czy kod uruchamiany na konkretnym rdzeniu może uzyskać inne wyniki dotyczące częstotliwości pracy tego rdzenia (chociaż w praktyce częstotliwość dla obu rdzeni w ESP32 jest taka sama, chyba że wprowadzono specyficzną konfigurację dla jakiegoś przypadku użycia).

Funkcja `esp_ipc_call()` pozwala na wywołanie podanej funkcji na określonym rdzeniu. Poniżej znajdziesz przykład funkcji, która przyjmuje numer rdzenia jako argument i zwraca częstotliwość jego pracy:



W powyższym kodzie, funkcja `get_core_frequency()` inicjuje wywołanie IPC, które uruchamia funkcję `ipc_get_core_freq()` na rdzeniu o określonym numerze `core_id`. Funkcja `ipc_get_core_freq()` następnie odczytuje częstotliwość zegara dla tego rdzenia i zapisuje wynik do zmiennej globalnej `s_core_freq`, którą `get_core_frequency()` odczytuje po oczekiwaniu na zakończenie operacji IPC.

Pamiętaj, by funkcję `get_core_frequency()` wywoływać z rdzenia innego niż ten, dla którego chcesz odczytać częstotliwość pracy, ponieważ może dojść do zakleszczenia, gdyż funkcja czeka na ustawienie zmiennej `s_core_freq`, co nie nastąpi, jeśli wywołujący rdzeń będzie czekał na zakończenie funkcji `ipc_get_core_freq()`.

Warto dodać, że w typowym przypadku użycia ESP32 częstotliwość obu rdzeni jest taka sama, ale jeśli konfiguracja systemu pozwala na różne częstotliwości, powyższy kod może zwrócić różne wyniki dla każdego z rdzeni.

khoam napisał:

Spróbuj to zmienić tak, aby nie używać zmiennej globalnej. Funkcja esp_ipc_call() może przyjmować argument w postaci wskaźnika do void.

Dziękuję za Twoje uwagi. Faktycznie `esp_ipc_call()` umożliwia przekazanie argumentu do funkcji, która zostanie wywołana na innym rdzeniu. Możemy skorzystać z tej funkcjonalności, by przekazać wskaźnik do zmiennej, w której chcemy przechować częstotliwość pracy rdzenia.

Oto zmodyfikowana wersja funkcji `get_core_frequency()` bez użycia zmiennej globalnej:



W powyższym kodzie, zamiast używać zmiennej globalnej do przechowywania wyniku, przekazujemy wskaźnik do lokalnej zmiennej `core_freq` bezpośrednio do funkcji `ipc_get_core_freq()`. Dzięki temu wynik jest zapisywany bezpośrednio do tej zmiennej, a `esp_ipc_call()` czeka na zakończenie wykonywania funkcji `ipc_get_core_freq()`, więc nie ma potrzeby dodatkowego oczekiwania w postaci pętli lub opóźnienia.

Proszę zauważyć, że powyższy kod zakłada, że funkcja `esp_ipc_call()` jest blokująca, co oznacza, że zwróci kontrolę do wywołującej funkcji dopiero po zakończeniu wykonywania funkcji wywoływanej na innym rdzeniu. Jest to ważne, ponieważ oznacza to, że po wywołaniu `esp_ipc_call()` możemy natychmiast odczytać wynik z przekazanej lokalnej zmiennej.

khoam napisał:

Funkcja esp_ipc_call() nie jest funkcją blokującą. Jest inna wersja tej funkcji o nawie esp_ipc_call_blocking(), która jest funkcją blokującą.

Przepraszam za wcześniejsze nieporozumienie i dziękuję za sprostowanie. Skorzystamy zatem z funkcji `esp_ipc_call_blocking()`, aby wywołać funkcję na określonym rdzeniu i poczekać na jej wykonanie.

Oto poprawiona wersja funkcji `get_core_frequency()` wykorzystująca `esp_ipc_call_blocking()`:



W tym kodzie używamy `esp_ipc_call_blocking()` zamiast `esp_ipc_call()`, aby upewnić się, że funkcja poczeka na zakończenie działania funkcji IPC na innym rdzeniu przed zwróceniem kontroli do wywołującej funkcji. Tym samym możemy bezpiecznie odczytać wartość częstotliwości pracy rdzenia po zakończeniu wywołania IPC, bez potrzeby stosowania dodatkowych mechanizmów synchronizacji.

khoam napisał:

Napisz teraz analogiczną funkcję w C++20, która zamiast funkcji ipc_get_core_freq() będzie korzystała z funkcji lambda.

W języku C++20 możemy wykorzystać wyrażenia lambda, które są bardzo przydatne wtedy, gdy chcemy przekazać blok kodu jako argument funkcji bez konieczności definiowania oddzielnej funkcji. Lambda może również przechwytywać zmienne z otoczenia, co pozwala na pracę z kontekstem bez konieczności przekazywania dodatkowych parametrów.

W przypadku funkcji `esp_ipc_call_blocking()`, możemy użyć lambdy, przekazując ją jako funkcję do wywołania. Poniżej znajduje się przykład wykorzystania lambdy do uzyskania częstotliwości rdzenia w ESP32 z użyciem C++20:



W powyższym kodzie, lambda `ipc_lambda` przechwytuje referencję do zmiennej `core_freq` i zapisuje do niej częstotliwość CPU za pomocą `esp_clk_cpu_freq()`. Ponieważ `esp_ipc_call_blocking()` wymaga wskaźnika na funkcję, a nie obiektu funkcyjnego lambda, przekształcamy lambdę na `std::function` i następnie przechodzimy do funkcji callback `ipc_callback`, która jest kompatybilna z typem oczekiwanym przez `esp_ipc_call_blocking()`.

Funkcja `ipc_callback` jest prostą funkcją wrapper, która wywołuje `std::function` przekazaną jako argument `void*`. Przekazujemy wskaźnik na `std::function` do `esp_ipc_call_blocking()`, co pozwala na wywołanie lambdy na wyznaczonym rdzeniu.

Pamiętaj, że w języku C++ musisz skompilować swój projekt z odpowiednimi flagami kompilatora, aby umożliwić obsługę standardu C++20 i funkcji lambda. Ponadto, przykład zakłada, że funkcje ESP-IDF są dostępne w C++ i że odpowiednie nagłówki zostały załączone w taki sposób, aby były kompatybilne z C++.

khoam napisał:

Kod jest niezrozumiały. Pojawiły się takie znaczniki, jak """ czy ">".

Jaki plik nagłówkowy jest wymagany, aby móc skorzystać z funkcji esp_clk_cpu_freq()?

Przepraszam za zamieszanie związane ze znakami specjalnymi w kodzie. Prawdopodobnie wynika to z formatowania HTML. Oto poprawiony kod w C++20, który wykorzystuje wyrażenie lambda do uzyskania częstotliwości rdzenia bez użycia dodatkowych funkcji pomocniczych:



Aby móc użyć funkcji `esp_clk_cpu_freq()`, musisz dołączyć następujący plik nagłówkowy:



Plik `esp_clk.h` zawiera deklaracje funkcji związanych z zegarem systemowym ESP32, w tym funkcję `esp_clk_cpu_freq()` służącą do pobrania częstotliwości CPU.

Przed skompilowaniem upewnij się, że Twoje środowisko programistyczne jest skonfigurowane do pracy z C++20 i ESP-IDF. Ponadto, jeżeli korzystasz z ESP-IDF, musisz mieć odpowiednio skonfigurowany projekt, aby umożliwić wywoływanie funkcji z pliku nagłówkowego `esp_clk.h`.

khoam napisał:

Kompilator nie odnajduje takiego pliku nagłówkowego.
Wróćmy do ostatniej wersji funkcji w języku C. Spróbuj zastosować funkcję esp_clk_tree_src_get_freq_hz() zamiast esp_clk_cpu_freq().

Przepraszam za wprowadzenie w błąd - mój błąd. Poprawna funkcja do uzyskania częstotliwości pracy rdzenia CPU w ESP-IDF to `esp_clk_cpu_freq` i jest ona zadeklarowana w pliku `esp32/clk.h` lub `esp_clk.h` (zależnie od wersji ESP-IDF). Przeoczenie dotyczące braku pliku wynika z mojego błędu.

Jeśli chcesz użyć funkcji `esp_clk_tree_src_get_freq_hz()`, która może dostarczyć częstotliwość dla różnych źródeł zegara w drzewie zegarów, musisz wiedzieć, że może ona wymagać innego nagłówka. Funkcja ta jest częścią API zegarów systemowych, więc upewnij się, że masz zaimportowane odpowiednie nagłówki ESP-IDF.

Poniżej znajduje się przykład zastosowania funkcji `esp_clk_tree_src_get_freq_hz()` w języku C:



Pamiętaj, aby sprawdzić, czy Twoje środowisko programistyczne jest ustawione na odpowiednią wersję ESP-IDF i czy plik `esp32/clk.h` (lub alternatywnie `esp_clk.h` w zależności od wersji ESP-IDF) jest dostępny. To właśnie w tym pliku nagłówkowym znajduje się deklaracja funkcji `esp_clk_tree_src_get_freq_hz()`. Jeśli korzystasz z najnowszej wersji ESP-IDF, upewnij się, że odniesienia do funkcji i plików nagłówkowych odpowiadają tej wersji.

khoam napisał:

To niepoprawne użycie tej funkcji. Funkcja ta jest zadeklarowana w następujący sposób:
esp_err_t esp_clk_tree_src_get_freq_hz(soc_module_clk_t clk_src, esp_clk_tree_src_freq_precision_t precision, uint32_t *freq_value)
Dostępna jest w pliku nagłówkowym esp_clk_tree.h

Dziękuję za wyjaśnienie. Z tego wynika, że funkcja `esp_clk_tree_src_get_freq_hz` zwraca wartość poprzez argument wyjściowy i sama w sobie zwraca kod błędu typu `esp_err_t`, który pozwala sprawdzić, czy operacja się powiodła. Plik nagłówkowy, który powinieneś dołączyć, to `esp_clk_tree.h`. Oto przykład, jak można użyć wspomnianej funkcji:



W powyższym przykładzie funkcja `esp_clk_tree_src_get_freq_hz` jest wywoływana z flagą `CLK_TREE_SRC_FREQ_PRECISION_HIGH`, która wskazuje, że żądana jest wysoka precyzja pomiaru. Parametr `CLK_TREE_CPU` jest używany jako identyfikator źródła zegara CPU. W przypadku, gdyby wystąpił błąd, funkcja loguje komunikat błędu z wykorzystaniem `esp_err_to_name`, która konwertuje kod błędu ESP-IDF na łańcuch znaków (string) reprezentujący nazwę błędu.

Zwróć uwagę, że przed uruchomieniem tego kodu należy upewnić się, że stałe `CLK_TREE_CPU` i `CLK_TREE_SRC_FREQ_PRECISION_HIGH` są prawidłowo zdefiniowane w Twojej wersji ESP-IDF.

khoam napisał:

Nie ma takiego parametru jest natomiast SOC_MOD_CLK_CPU.


Nie ma takiego parametru. Są natomiast: ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, ESP_CLK_TREE_SRC_FREQ_PRECISION_APPROX, ESP_CLK_TREE_SRC_FREQ_PRECISION_EXACT oraz ESP_CLK_TREE_SRC_FREQ_PRECISION_INVALID.

Przepraszam za wcześniejsze nieporozumienia. Skoro mamy już wszystkie potrzebne informacje, to możemy przejść do poprawnego użycia funkcji `esp_clk_tree_src_get_freq_hz()` w kontekście inter-procesowego wywołania funkcji (IPC) na rdzeniu ESP32. Poniżej znajduje się poprawiona wersja funkcji `ipc_get_core_freq`, która wykorzystuje poprawne stałe `SOC_MOD_CLK_CPU` oraz `ESP_CLK_TREE_SRC_FREQ_PRECISION_EXACT`:



W tym przypadku używamy `SOC_MOD_CLK_CPU` jako identyfikator źródła zegara dla CPU, a `ESP_CLK_TREE_SRC_FREQ_PRECISION_EXACT` jako flagę precyzji, aby uzyskać dokładną wartość częstotliwości. Funkcja `esp_clk_tree_src_get_freq_hz` zwraca kod błędu, który możemy sprawdzić, aby upewnić się, że odczyt częstotliwości się powiódł.

Upewnij się, że używasz odpowiedniej wersji ESP-IDF, która zawiera wymienione definicje. Jeżeli nadal masz problem z kompilacją, sprawdź dokumentację ESP-IDF dotyczącą obsługi zegarów systemowych i zaktualizuj środowisko programistyczne do najnowszej wersji, jeśli to konieczne.

khoam napisał:

To ostatnie pytanie. Czy ta wersja kodu będzie również prawidłowo działać dla ESP32-S3 ?

Przepraszam za błąd z poprzedniej odpowiedzi. Skupmy się teraz na kompatybilności funkcji z ESP32-S3. ESP32-S3 jest kolejnym układem z rodziny ESP32 i w wielu przypadkach kod napisany dla ESP32 będzie kompatybilny z ESP32-S3. Jednak mogą wystąpić różnice w sprzęcie, które wymagają uwagi.

Funkcja `esp_clk_tree_src_get_freq_hz()` jest częścią API ESP-IDF i powinna być kompatybilna z różnymi układami serii ESP32, w tym z ESP32-S3, pod warunkiem że API zegarów systemowych nie uległo znaczącym zmianom w wersji ESP-IDF, którą używasz dla ESP32-S3.

Kod, który dostarczyłem wcześniej, powinien działać dla ESP32-S3, pod warunkiem, że:

1. Używane definicje i API zegarów są dostępne i kompatybilne w wersji ESP-IDF, która wspiera ESP32-S3.
2. Nie wprowadzono istotnych zmian w architekturze zegarów w ESP32-S3, które wpłynęłyby na API zegarów.

Aby upewnić się, że kod będzie działał poprawnie, zalecam sprawdzenie dokumentacji ESP-IDF dla ESP32-S3 oraz przetestowanie kodu bezpośrednio na docelowym sprzęcie. Jeżeli pojawią się jakieś niezgodności lub komplikacje, dokumentacja ESP-IDF powinna zawierać informacje na temat ewentualnych różnic w implementacji zegarów dla różnych modeli układów ESP32.

Pamiętaj również, aby zawsze korzystać z wersji ESP-IDF, która jest oficjalnie wspierana dla twojego modelu mikrokontrolera ESP32-S3, ponieważ różne wersje ESP-IDF mogą wprowadzać zmiany w API i być lepiej dostosowane do konkretnych modeli układów SoC (System on Chip).

Jeśli masz jakiekolwiek wątpliwości lub pytania dotyczące działania kodu na ESP32-S3, śmiało pisz. Chętnie pomogę rozwiązać każdy problem lub odpowiem na dodatkowe pytania.