### Getting Help (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Displays help information for Angular CLI commands and their usage, providing details on available options and arguments.

```Shell
ng help
```

--------------------------------

### Running Development Server (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Starts a local development server for the Angular application. It serves the application at http://localhost:4200/ and automatically reloads the browser when source files are changed.

```Shell
ng serve
```

--------------------------------

### Installing Bitaxetool with Pip - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This command installs or upgrades the Bitaxetool command-line utility using Python's package installer, pip. It requires Python 3.4 or later and pip installed on the system.

```Bash
pip install --upgrade bitaxetool
```

--------------------------------

### Define Component CMakeLists.txt (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Configure the build settings for a component using CMake. This file specifies the source files, include directories, and required dependencies for the component.

```CMake
idf_component_register(
SRCS
    "foo.c"

INCLUDE_DIRS
    "include"

REQUIRES
)
```

--------------------------------

### Running End-to-End Tests (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Executes the project's end-to-end tests via a platform of your choice. This command requires an end-to-end testing package to be installed and configured first.

```Shell
ng e2e
```

--------------------------------

### Build ESP-Miner Unit Tests (Shell)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Navigate to the test directory within the ESP-Miner root and use idf.py to build the unit test application. This command compiles the test code and linked components for the target ESP32-S3.

```Shell
cd test
idf.py build
```

--------------------------------

### Building Project for Production (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Compiles the Angular project into output files (artifacts) that are ready for deployment. The build artifacts are typically stored in the 'dist/' directory.

```Shell
ng build
```

--------------------------------

### Running Unit Tests (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Executes the project's unit tests using the configured test runner, which is typically Karma by default. It provides feedback on the test results.

```Shell
ng test
```

--------------------------------

### Implement Component Source File (C)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Provide the implementation details for functions declared in the component's header file. This C source file includes the necessary header and defines the function logic.

```C
#include "foo.h"

int foo(int i) {
    return i;
}
```

--------------------------------

### Flash ESP-Miner Unit Test Binary (Shell)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Use the esptool utility to flash the compiled unit test binary onto the ESP32-S3. This command specifies the serial port, chip type, baud rate, flash mode, size, frequency, and the addresses and paths of the bootloader, partition table, and test application binaries.

```Shell
python -m esptool -p /dev/ttyACM0 --chip esp32s3 -b 460800 --before default_reset --after hard_reset write_flash --flash_mode dio --flash_size 2MB --flash_freq 80m 0x0 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin 0x10000 build/unit_test_stratum.bin
```

--------------------------------

### Implement Unit Test Case (C)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Write a specific unit test case using the Unity test framework. This C file includes the Unity header and the component header, defining a test function with assertions to verify component behavior.

```C
#include "unity.h"
#include "foo.h"

TEST_CASE("Foo returns what is provided", "[foo]")
{
    TEST_ASSERT_EQUAL_INT(42, foo(42));
}

```

--------------------------------

### Configure Extra Component Directories (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/CMakeLists.txt

This commented-out section illustrates how to include additional component directories in the build, such as common examples or custom components. It shows a typical path relative to the IDF_PATH environment variable.

```CMake
# (Not part of the boilerplate)\n# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.\n# set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
```

--------------------------------

### Define Test Component CMakeLists.txt (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Configure the build settings specifically for the unit tests of a component. This CMake file specifies the source directories, include directories, and required dependencies like 'unity' and the component being tested.

```CMake
idf_component_register(SRC_DIRS "."
                    INCLUDE_DIRS "."
                    REQUIRES unity foo)

```

--------------------------------

### Monitor ESP32 Serial Output (Shell)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Connect to the ESP32's serial port to view output from the running unit tests. This command uses idf.py to open a serial monitor session.

```Shell
idf.py -p /dev/ttyACM0 monitor
```

--------------------------------

### Getting System Info via AxeOS API - cURL

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This cURL command sends a GET request to the Bitaxe's AxeOS API to retrieve system information. Replace YOUR-BITAXE-IP with the actual IP address of your Bitaxe device.

```cURL
curl http://YOUR-BITAXE-IP/api/system/info
```

--------------------------------

### Define Component Header File (C)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Define the public interface for a component in a C header file. This file includes function declarations and uses include guards to prevent multiple inclusions.

```C
#ifndef FOO_H
#define FOO_H

int foo(int i);

#endif // FOO_H
```

--------------------------------

### Getting Swarm Info via AxeOS API - cURL

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

Use this cURL command to send a GET request to the AxeOS API to fetch information about the mining swarm. Replace YOUR-BITAXE-IP with the Bitaxe's IP address.

```cURL
curl http://YOUR-BITAXE-IP/api/swarm/info
```

--------------------------------

### Generating Code Scaffolding (Angular CLI)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/README.md

Generates new Angular components, directives, pipes, services, classes, guards, interfaces, enums, or modules using the Angular CLI's schematic capabilities.

```Shell
ng generate component component-name
```

```Shell
ng generate directive|pipe|service|class|guard|interface|enum|module
```

--------------------------------

### Add User to Dialout Group (Shell)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Grant the current user permissions to access serial devices, which is necessary for flashing and monitoring the ESP32. This command adds the user to the 'dialout' group.

```Shell
sudo usermod -aG dialout $USER
```

--------------------------------

### Modify Main Test CMakeLists.txt (Diff/CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/doc/unit_testing.md

Update the main unit test application's CMakeLists.txt file to include the new component's tests in the build. This diff shows adding the component name to the list of components to be tested.

```Diff
-set(TEST_COMPONENTS "bm1397 stratum" CACHE STRING "List of components to test")
+set(TEST_COMPONENTS "bm1397 stratum foo" CACHE STRING "List of components to test")
```

--------------------------------

### Building ESP-Miner Firmware - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This command sequence builds the ESP-Miner firmware using the ESP-IDF build system (idf.py build) and then merges the resulting binaries (bootloader, partition table, app) into a single file using a custom script (merge_bin.sh).

```Bash
idf.py build && ./merge_bin.sh ./esp-miner-merged.bin
```

--------------------------------

### Registering DNS Server Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/dns_server/CMakeLists.txt

Configures the build process for the 'dns_server' component in an ESP-IDF project. It lists the source file (`dns_server.c`), specifies the include directory (`include`), and declares a private dependency on the `esp_netif` component.

```CMake
idf_component_register(
SRCS
    "dns_server.c"

INCLUDE_DIRS
    "include"

PRIV_REQUIRES
    "esp_netif"
)
```

--------------------------------

### Flashing Factory Firmware with Bitaxetool - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

Use this command with Bitaxetool to flash a factory firmware image (.bin file) onto the Bitaxe hardware. Ensure the firmware file specified is compatible with your specific hardware version (e.g., 401).

```Bash
bitaxetool --firmware ./esp-miner-factory-401-v2.4.2.bin
```

--------------------------------

### Flashing Built Firmware with Bitaxetool - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

Use this Bitaxetool command to flash a locally built firmware image (esp-miner-merged.bin) along with a hardware-specific configuration file (config-xxx.cvs) onto the Bitaxe via USB. Replace xxx with your hardware version.

```Bash
bitaxetool --config ./config-xxx.cvs --firmware ./esp-miner-merged.bin
```

--------------------------------

### Registering ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/connect/CMakeLists.txt

This snippet uses the `idf_component_register` macro to define a component. It lists `connect.c` as a source file, specifies include directories relative to the component and project root, and declares dependencies on `nvs_flash`, `esp_wifi`, `esp_event`, and `stratum` components.

```ESP-IDF CMake
idf_component_register(
SRCS
    "connect.c"

INCLUDE_DIRS
    "include"
    "../../main"
    "../../main/tasks"
    "../asic/include"

REQUIRES
    "nvs_flash"
    "esp_wifi"
    "esp_event"
    "stratum"
)
```

--------------------------------

### Flashing Firmware and Config with Bitaxetool - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This command uses Bitaxetool to flash both a firmware image (.bin) and an NVS configuration file (.cvs) simultaneously. Note that settings in the config file will override any baked into the firmware image.

```Bash
bitaxetool --config ./config-401.cvs --firmware ./esp-miner-factory-401-v2.4.2.bin
```

--------------------------------

### Conditional Web UI Build and SPIFFS Image Creation (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/CMakeLists.txt

Includes logic to conditionally build the web UI using npm and create a SPIFFS partition image based on whether the build is running in a GitHub Actions environment or locally. It uses ExternalProject_Add for local builds to manage the npm process.

```CMake
if("$ENV{GITHUB_ACTIONS}" STREQUAL "true")
    message(STATUS "Running on GitHub Actions. Web ui will be prebuilt.")

    spiffs_create_partition_image(www ${WEB_SRC_DIR}/dist/axe-os FLASH_IN_PROJECT)
else()
    find_program(NPM_EXECUTABLE npm)
    if(NOT NPM_EXECUTABLE AND NOT EXISTS ${WEB_SRC_DIR}/dist)
        message(FATAL_ERROR "npm is not found! Please install it to proceed.")
    endif()

    ExternalProject_Add(
        web_ui_dist
        PREFIX ${CMAKE_BINARY_DIR}/web_ui_dist
        SOURCE_DIR ${WEB_SRC_DIR}
        DOWNLOAD_COMMAND ""
        CONFIGURE_COMMAND
            ${NPM_EXECUTABLE}  i
        USES_TERMINAL_BUILD true
        BUILD_COMMAND
            ${NPM_EXECUTABLE} run build
        INSTALL_COMMAND ""
        BUILD_ALWAYS OFF
        BUILD_IN_SOURCE TRUE
        BUILD_BYPRODUCTS
            "${WEB_SRC_DIR}/dist/axe-os/index.html"
    )

    add_dependencies(${COMPONENT_LIB} web_ui_dist)

    spiffs_create_partition_image(www ${WEB_SRC_DIR}/dist/axe-os FLASH_IN_PROJECT DEPENDS web_ui_dist)
endif()
```

--------------------------------

### Include ESP-IDF Project CMake File (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Includes the standard project configuration file provided by the ESP-IDF framework, which sets up the build environment and necessary functions.

```CMake
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
```

--------------------------------

### Include ESP-IDF Project Infrastructure and Name Project (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/CMakeLists.txt

Includes the core CMake files provided by the ESP-IDF framework, which set up the build system, and then defines the name of the project. These steps are fundamental for any ESP-IDF application.

```CMake
include($ENV{IDF_PATH}/tools/cmake/project.cmake)\n\nproject(esp-miner)
```

--------------------------------

### Include ESP-IDF Project CMake (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Includes the standard ESP-IDF project CMake file, which provides essential functions and configurations for building ESP-IDF applications and projects.

```CMake
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
```

--------------------------------

### Registering ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/CMakeLists.txt

Defines the 'esp-miner' component within the ESP-IDF build system, specifying its source files, include directories, private dependencies on other components, and files to be embedded.

```CMake
idf_component_register(
SRCS
    "adc.c"
    "i2c_bitaxe.c"
    "main.c"
    "nvs_config.c"
    "display.c"
    "screen.c"
    "input.c"
    "system.c"
    "work_queue.c"
    "nvs_device.c"
    "lv_font_portfolio-6x8.c"
    "logo.c"
    "./http_server/http_server.c"
    "./http_server/theme_api.c"
    "./http_server/axe-os/api/system/asic_settings.c"
    "./self_test/self_test.c"
    "./tasks/stratum_task.c"
    "./tasks/create_jobs_task.c"
    "./tasks/asic_task.c"
    "./tasks/asic_result_task.c"
    "./tasks/power_management_task.c"
    "./thermal/EMC2101.c"
    "./thermal/EMC2103.c"
    "./thermal/TMP1075.c"
    "./thermal/thermal.c"
    "./thermal/PID.c"
    "./power/TPS546.c"
    "./power/DS4432U.c"
    "./power/INA260.c"
    "./power/power.c"
    "./power/vcore.c"

INCLUDE_DIRS
    "."
    "tasks"
    "http_server"
    "http_server/axe-os/api/system"
    "self_test"
    "../components/asic/include"
    "../components/connect/include"
    "../components/dns_server/include"
    "../components/stratum/include"
    "thermal"
    "power"

PRIV_REQUIRES
    "app_update"
    "driver"
    "esp_adc"
    "esp_app_format"
    "esp_event"
    "esp_http_server"
    "esp_netif"
    "esp_psram"
    "esp_timer"
    "esp_wifi"
    "json"
    "nvs_flash"
    "spiffs"
    "vfs"
    "esp_driver_i2c"

EMBED_FILES "http_server/recovery_page.html"
)
```

--------------------------------

### Setting ESP-IDF Compile Options (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/CMakeLists.txt

Appends specific preprocessor definitions related to the LVGL library configuration to the component's compile options.

```CMake
idf_build_set_property(COMPILE_OPTIONS "-DLV_CONF_INCLUDE_SIMPLE=1" APPEND)
idf_build_set_property(COMPILE_OPTIONS "-DLV_CONF_PATH= ${CMAKE_SOURCE_DIR}/main/lv_conf.h" APPEND)
```

--------------------------------

### Generating Angular Service for Mining Pool (Bash)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/http_server/axe-os/add-pool.md

This command uses the Angular CLI to generate a new service file named `<poolname>` within the project's structure. This is the first step in adding a new mining pool implementation.

```bash
ng generate service <poolname>
```

--------------------------------

### Registering ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/asic/CMakeLists.txt

Registers the current directory as an ESP-IDF component. It lists the source files (`.c`), specifies the local include directory (`include`), and declares dependencies on other components like FreeRTOS, driver, and stratum.

```CMake
idf_component_register(
SRCS 
    "bm1370.c"
    "bm1368.c"
    "bm1366.c"
    "bm1397.c"
    "serial.c"
    "crc.c"
    "common.c"
    "asic.c"
    "frequency_transition_bmXX.c"

INCLUDE_DIRS 
    "include"

REQUIRES 
    "freertos"
    "driver"
    "stratum"
)
```

--------------------------------

### Flashing NVS Configuration with Bitaxetool - Bash

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This command flashes only the Non-Volatile Storage (NVS) configuration file (.cvs) to the Bitaxe using Bitaxetool. This is useful for updating settings without changing the main firmware.

```Bash
bitaxetool --config ./config-401.cvs
```

--------------------------------

### Append Compile Definitions (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Appends a preprocessor definition (-DCONFIG_ASIC_FREQUENCY=100) to the compile flags for the project, likely configuring a hardware-specific setting.

```CMake
idf_build_set_property(COMPILE_DEFINITIONS "-DCONFIG_ASIC_FREQUENCY=100" APPEND)
```

--------------------------------

### Triggering System Restart via AxeOS API - cURL

Source: https://github.com/bitaxeorg/esp-miner/blob/master/readme.md

This cURL command sends a POST request to the AxeOS API to initiate a system restart on the Bitaxe device. Replace YOUR-BITAXE-IP with the Bitaxe's IP address.

```cURL
curl -X POST http://YOUR-BITAXE-IP/api/system/restart
```

--------------------------------

### Registering Component Sources and Includes (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/main/CMakeLists.txt

Uses the `idf_component_register` macro to define an ESP-IDF component. The `SRCS` parameter specifies the source files to include, and `INCLUDE_DIRS` lists directories to add to the include path for compilation.

```CMake
idf_component_register(SRCS "unit_test_all.c"
                    INCLUDE_DIRS ".")
```

--------------------------------

### Defining Web UI Source Directory (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/main/CMakeLists.txt

Sets a CMake variable to the path of the web user interface source directory within the project.

```CMake
set(WEB_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/http_server/axe-os")
```

--------------------------------

### Include Main Project Components (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Adds the 'components' directory from the parent project to the list of directories where CMake searches for components. This allows the test project to access components defined in the main application.

```CMake
set(EXTRA_COMPONENT_DIRS "../components")
```

--------------------------------

### Registering ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/asic/test/CMakeLists.txt

Registers the current directory as an ESP-IDF component. It includes the current directory for source files and headers and declares dependencies on the 'cmock', 'stratum', and 'bm1397' components.

```CMake
idf_component_register(SRC_DIRS "."
                       INCLUDE_DIRS "."
                       REQUIRES cmock stratum bm1397)
```

--------------------------------

### Register Component Sources and Includes (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/main/CMakeLists.txt

Registers the current directory as an ESP-IDF component using the `idf_component_register` macro. It specifies `unit_test_all.c` as the source file (`SRCS`) and includes the current directory (`.`) in the include paths (`INCLUDE_DIRS`). This is typically used in a `CMakeLists.txt` file within a component directory.

```CMake
idf_component_register(SRCS "unit_test_all.c"
                    INCLUDE_DIRS ".")
```

--------------------------------

### Registering IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/stratum/test/CMakeLists.txt

Registers the current directory as an Espressif IDF component using the idf_component_register CMake function. It specifies the source directories, include directories, and lists required components like 'cmock' and 'stratum'.

```CMake
idf_component_register(SRC_DIRS "."
                    INCLUDE_DIRS "."
                    REQUIRES cmock stratum)
```

--------------------------------

### Include Extra Component Directories (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Sets the CMake variable EXTRA_COMPONENT_DIRS to point to the components directory of the main application, allowing the test project to access shared components.

```CMake
set(EXTRA_COMPONENT_DIRS "../components")
```

--------------------------------

### Define Project Name (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Sets the name of the CMake project, which is used for build targets and other project-specific configurations.

```CMake
project(unit_test_stratum)
```

--------------------------------

### Adding Include Directories to ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/asic/CMakeLists.txt

Adds external directories containing header files to the component's include path. The `PRIVATE` keyword ensures these paths are only used during the compilation of this component. Paths are specified relative to the current source directory.

```CMake
# Include the header files from "main" directory
target_include_directories(${COMPONENT_LIB} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../main")

# Include the header files from "main/tasks" directory
target_include_directories(${COMPONENT_LIB} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../main/tasks")
```

--------------------------------

### Append Compile Definition (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Appends a preprocessor definition to the compile flags for the project. This specific definition sets the ASIC frequency configuration, which might be relevant for hardware-related tests.

```CMake
idf_build_set_property(COMPILE_DEFINITIONS "-DCONFIG_ASIC_FREQUENCY=100" APPEND)
```

--------------------------------

### Set Minimum CMake Version (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Specifies the minimum required version of CMake to successfully process this build script.

```CMake
cmake_minimum_required(VERSION 3.16)
```

--------------------------------

### Set ESP-IDF Target Chip (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Specifies the target microcontroller chip for which the project is being built, in this case, the ESP32-S3.

```CMake
set(IDF_TARGET "esp32s3")
```

--------------------------------

### Registering ESP-IDF Component (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/components/stratum/CMakeLists.txt

Registers an ESP-IDF component using the `idf_component_register` CMake function. It lists the source files (`SRCS`), include directories (`INCLUDE_DIRS`), and required components (`REQUIRES`) that this component depends on for compilation and linking within the ESP-IDF build system.

```CMake
idf_component_register(
SRCS
    "utils.c"
    "mining.c"
    "stratum_api.c"
                    
INCLUDE_DIRS
    "include"

REQUIRES
    "json"
    "mbedtls"
    "app_update"
)
```

--------------------------------

### Set Minimum CMake Version (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Specifies the minimum required version of CMake to build the project. This ensures compatibility with the build system features used.

```CMake
cmake_minimum_required(VERSION 3.16)
```

--------------------------------

### Define Components for Testing (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Sets the list of components for which unit tests should be included. This variable can be overridden from the CMake cache, allowing selection of specific components for testing via command-line arguments.

```CMake
set(TEST_COMPONENTS "bm1397 stratum" CACHE STRING "List of components to test")
```

--------------------------------

### Set Target ESP-IDF Chip (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Specifies the target ESP32 chip for the build. This setting determines the specific hardware architecture and associated configurations used by the ESP-IDF build system.

```CMake
set(IDF_TARGET "esp32s3")
```

--------------------------------

### Define Project Name (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test/CMakeLists.txt

Sets the name of the CMake project. This name is used by CMake for various internal purposes and can appear in build output.

```CMake
project(unit_test_stratum)
```

--------------------------------

### Set Minimum CMake Version (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/CMakeLists.txt

Specifies the minimum required version of CMake to build the project. This ensures compatibility with the project's build scripts and the ESP-IDF framework.

```CMake
cmake_minimum_required(VERSION 3.5)
```

--------------------------------

### Define Test Components (CMake)

Source: https://github.com/bitaxeorg/esp-miner/blob/master/test-ci/CMakeLists.txt

Sets the TEST_COMPONENTS variable, specifying which components (initially 'bm1397 stratum') are included for testing. This variable can be overridden via CMake cache.

```CMake
set(TEST_COMPONENTS "bm1397 stratum" CACHE STRING "List of components to test")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.