添加智能灯固件代码

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/CMakeLists.txt

@@ -0,0 +1,6 @@
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(parttool)

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/Makefile

@@ -0,0 +1,9 @@
+#
+# This is a project Makefile. It is assumed the directory this Makefile resides in is a
+# project subdirectory.
+#
+
+PROJECT_NAME := parttool
+
+include $(IDF_PATH)/make/project.mk
+

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/README.md

@@ -0,0 +1,73 @@
+# Partitions Tool Example
+
+This example demonstrates common operations the partitions tool [parttool.py](../../../components/partition_table/parttool.py) allows the user to perform:
+
+- reading, writing and erasing partitions,
+- retrieving info on a certain partition,
+- dumping the entire partition table
+
+Users taking a look at this example should focus on the contents of the Python script [parttool_example.py](parttool_example.py) or shell script [parttool_example.sh](parttool_example.sh). The scripts contain
+programmatic invocation of the tool's functions via the Python API and command-line interface, respectively. Note
+that on Windows, the shell script example requires a POSIX-compatible environment via MSYS2/Git Bash/WSL etc.
+
+The example performs the operations mentioned above in a straightforward manner: it performs writes to partitions and then verifies correct content
+by reading it back. For partitions, contents are compared to the originally written file. For the partition table, contents are verified against the partition table CSV
+file. An erased partition's contents is compared to a generated blank file.
+
+## How to use example
+
+### Build and Flash
+
+Before running either of the example scripts, it is necessary to build and flash the firmware using the usual means:
+
+Make:
+```bash
+make build flash
+```
+
+CMake:
+```bash
+idf.py build flash
+```
+
+### Running [parttool_example.py](parttool_example.py)
+
+The example can be executed by running the script [parttool_example.py](parttool_example.py) or [parttool_example.sh](parttool_example.sh).
+
+Python script:
+```bash
+python parttool_example.py
+```
+
+Shell script:
+```
+./parttool_example.sh
+```
+
+The script searches for valid target devices connected to the host and performs the operations on the first one it finds. To perform the operations on a specific device, specify the port it is attached to during script invocation:
+
+Python script:
+```bash
+python parttool_example.py --port /dev/ttyUSB2
+```
+
+Shell script:
+```
+./parttool_example.sh /dev/ttyUSB2
+```
+
+## Example output
+
+Running the script produces the following output:
+
+```
+Checking if device app binary matches built binary
+Found data partition at offset 0x110000 with size 0x10000
+Writing to data partition
+Reading data partition
+Erasing data partition
+Reading data partition
+
+Partition tool operations performed successfully!
+```
+

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/example_test.py

@@ -0,0 +1,35 @@
+from __future__ import print_function
+import os
+import sys
+import subprocess
+
+import ttfw_idf
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_GENERIC')
+def test_examples_parttool(env, extra_data):
+    dut = env.get_dut('parttool', 'examples/storage/parttool', dut_class=ttfw_idf.ESP32DUT)
+    dut.start_app(False)
+
+    # Verify factory firmware
+    dut.expect("Partitions Tool Example")
+    dut.expect("Example end")
+
+    # Close connection to DUT
+    dut.receive_thread.exit()
+    dut.port_inst.close()
+
+    # Run the example python script
+    script_path = os.path.join(os.getenv("IDF_PATH"), "examples", "storage", "parttool", "parttool_example.py")
+
+    binary_path = ""
+    for flash_file in dut.app.flash_files:
+        if "parttool.bin" in flash_file[1]:
+            binary_path = flash_file[1]
+            break
+
+    subprocess.check_call([sys.executable, script_path, "--binary", binary_path])
+
+
+if __name__ == '__main__':
+    test_examples_parttool()

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "parttool_main.c"
+                    INCLUDE_DIRS ".")

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/main/parttool_main.c

@@ -0,0 +1,22 @@
+/* Partitions Tool Example
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/unistd.h>
+#include <sys/stat.h>
+#include "esp_err.h"
+#include "esp_log.h"
+
+static const char *TAG = "example";
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "Partitions Tool Example");
+    ESP_LOGI(TAG, "Example end");
+}

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/partitions_example.csv

@@ -0,0 +1,6 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
+nvs,      data, nvs,     0x9000,  0x6000,
+phy_init, data, phy,     0xf000,  0x1000,
+factory,  app,  factory, 0x10000, 1M,
+storage,  data, spiffs,  ,        0x10000, 

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/parttool_example.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+#
+# Demonstrates the use of parttool.py, a tool for performing partition level
+# operations.
+#
+# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import sys
+import argparse
+
+PARTITION_TABLE_DIR = os.path.join("components", "partition_table", "")
+
+
+def assert_file_same(file1, file2, err):
+    with open(file1, "rb") as f1:
+        with open(file2, "rb") as f2:
+            f1 = f1.read()
+            f2 = f2.read()
+
+            if len(f1) < len(f2):
+                f2 = f2[:len(f1)]
+            else:
+                f1 = f1[:len(f2)]
+
+            if not f1 == f2:
+                raise Exception(err)
+
+
+def main():
+    COMPONENTS_PATH = os.path.expandvars(os.path.join("$IDF_PATH", "components"))
+    PARTTOOL_DIR = os.path.join(COMPONENTS_PATH, "partition_table")
+
+    sys.path.append(PARTTOOL_DIR)
+    from parttool import PartitionName, PartitionType, ParttoolTarget
+    from gen_empty_partition import generate_blanked_file
+
+    parser = argparse.ArgumentParser("ESP-IDF Partitions Tool Example")
+
+    parser.add_argument("--port", "-p", help="port where the device to perform operations on is connected")
+    parser.add_argument("--binary", "-b", help="path to built example binary", default=os.path.join("build", "parttool.bin"))
+
+    args = parser.parse_args()
+
+    target = ParttoolTarget(args.port)
+
+    # Read app partition and save the contents to a file. The app partition is identified
+    # using type-subtype combination
+    print("Checking if device app binary matches built binary")
+    factory = PartitionType("app", "factory")
+    target.read_partition(factory, "app.bin")
+    assert_file_same(args.binary, "app.bin", "Device app binary does not match built binary")
+
+    # Retrieve info on data storage partition, this time identifying it by name.
+    storage = PartitionName("storage")
+    storage_info = target.get_partition_info(storage)
+    print("Found data partition at offset 0x{:x} with size 0x{:x}".format(storage_info.offset, storage_info.size))
+
+    # Create a file whose contents will be written to the storage partition
+    with open("write.bin", "wb") as f:
+        # Create a file to write to the data partition with randomly generated content
+        f.write(os.urandom(storage_info.size))
+
+    # Write the contents of the created file to storage partition
+    print("Writing to data partition")
+    target.write_partition(storage, "write.bin")
+
+    # Read back the contents of the storage partition
+    print("Reading data partition")
+    target.read_partition(storage, "read.bin")
+
+    assert_file_same("write.bin", "read.bin", "Read contents of storage partition does not match source file contents")
+
+    # Erase contents of the storage partition
+    print("Erasing data partition")
+    target.erase_partition(storage)
+
+    # Read back the erased data partition
+    print("Reading data partition")
+    target.read_partition(storage, "read.bin")
+
+    # Generate a file of all 0xFF
+    generate_blanked_file(storage_info.size, "blank.bin")
+
+    assert_file_same("blank.bin", "read.bin", "Contents of storage partition not fully erased")
+
+    # Example end and cleanup
+    print("\nPartition tool operations performed successfully!")
+    clean_files = ["app.bin", "read.bin", "blank.bin", "write.bin"]
+    for clean_file in clean_files:
+        os.unlink(clean_file)
+
+
+if __name__ == '__main__':
+    main()

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/parttool_example.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+#
+# Demonstrates command-line interface of Partition Tool, parttool.py
+#
+#
+# $1 - serial port where target device to operate on is connnected to, by default the first found valid serial port
+# $2 - path to this example's built binary file (parttool.bin), by default $PWD/build/parttool.bin
+PORT=$1
+PARTTOOL_PY="python $IDF_PATH/components/partition_table/parttool.py -q"
+
+if [[ "$PORT" != "" ]]; then
+    PARTTOOL_PY="$PARTTOOL_PY --port $PORT"
+fi
+
+GEN_EMPTY_PARTITION_PY="python $IDF_PATH/components/partition_table/gen_empty_partition.py"
+
+BINARY=$2
+
+if [[ "$BINARY" == "" ]]; then
+    BINARY=build/parttool.bin
+fi
+
+function assert_file_same()
+{
+    sz_a=$(stat -c %s $1)
+    sz_b=$(stat -c %s $2)
+    sz=$((sz_a < sz_b ? sz_a : sz_b))
+    res=$(cmp -s -n $sz $1 $2) || 
+        (echo "!!!!!!!!!!!!!!!!!!!"
+        echo "FAILURE: $3"
+        echo "!!!!!!!!!!!!!!!!!!!")
+}
+
+# Read app partition and save the contents to a file. The app partition is identified
+# using type-subtype combination
+echo "Checking if device app binary matches built binary"
+$PARTTOOL_PY read_partition --partition-type=app --partition-subtype=factory --output=app.bin
+assert_file_same app.bin $BINARY "Device app binary does not match built binary"
+
+# Retrieve info on data storage partition, this time identifying it by name.
+offset=$($PARTTOOL_PY get_partition_info --partition-name=storage --info offset)
+size=$($PARTTOOL_PY get_partition_info --partition-name=storage  --info size)
+echo "Found data partition at offset $offset with size $size"
+
+# Create a file whose contents will be written to the storage partition
+head -c $(($size)) /dev/urandom > write.bin
+
+# Write the contents of the created file to storage partition
+echo "Writing to data partition"
+$PARTTOOL_PY write_partition --partition-name=storage --input write.bin
+
+# Read back the contents of the storage partition
+echo "Reading data partition"
+$PARTTOOL_PY read_partition --partition-name=storage --output read.bin
+
+assert_file_same write.bin read.bin "Read contents of storage partition does not match source file contents"
+
+# Erase contents of the storage partition
+echo "Erasing data partition"
+$PARTTOOL_PY erase_partition --partition-name=storage
+
+# Read back the erased data partition
+echo "Reading data partition"
+$PARTTOOL_PY read_partition --partition-name=storage --output read.bin
+
+# Generate a file of all 0xFF
+$GEN_EMPTY_PARTITION_PY $(($size)) blank.bin
+
+assert_file_same read.bin blank.bin "Contents of storage partition not fully erased"
+
+# Example end and cleanup
+printf "\nPartition tool operations performed successfully\n"
+rm -rf app.bin read.bin blank.bin write.bin

firmware/esp-idf/wumei-smart-firmware/examples/storage/parttool/sdkconfig.defaults

@@ -0,0 +1,3 @@
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_example.csv"
+CONFIG_PARTITION_TABLE_FILENAME="partitions_example.csv"