diff --git a/examples/UnitUnified/UnitFinger2/Automatic/AutoMatic.ino b/examples/UnitUnified/UnitFinger2/Automatic/Automatic.ino
similarity index 100%
rename from examples/UnitUnified/UnitFinger2/Automatic/AutoMatic.ino
rename to examples/UnitUnified/UnitFinger2/Automatic/Automatic.ino
diff --git a/src/unit/unit_Finger2.cpp b/src/unit/unit_Finger2.cpp
index c01fad5..59a1c1e 100644
--- a/src/unit/unit_Finger2.cpp
+++ b/src/unit/unit_Finger2.cpp
@@ -137,13 +137,13 @@ bool UnitFinger2::begin()
         M5_LIB_LOGE("Failed to ReadSysPara");
         return false;
     }
-    _pageCapacity = params.capacity;
+    _pageCapacity = params.database_capacity;
     M5_LIB_LOGD("Capacity:%u", _pageCapacity);
 
     M5_LIB_LOGD("---SystemBasicParams %zu---", sizeof(params));
     M5_LIB_LOGD("Status:  %04X", params.status);
-    M5_LIB_LOGD("TmpSize: %04X", params.template_size);
-    M5_LIB_LOGD("Capacity:%04X", params.capacity);
+    M5_LIB_LOGD("Type:    %04X", params.sensor_type);
+    M5_LIB_LOGD("DBCap:   %04X", params.database_capacity);
     M5_LIB_LOGD("ScoreLv: %04X", params.score_level);
     M5_LIB_LOGD("Address: %08X", params.address);
     M5_LIB_LOGD("PktSz:   %04X", params.packet_size);
@@ -194,10 +194,10 @@ bool UnitFinger2::readSystemParams(finger2::SystemBasicParams& params)
 
     Packet pkt{};
     if (transceive_command(pkt, CMD_READ_SYSTEM_PARAMETER, _address) && pkt.size() == 28) {
-        params.status        = ((uint16_t)pkt[10] << 8) | pkt[11];
-        params.template_size = ((uint16_t)pkt[12] << 8) | pkt[13];
-        params.capacity      = ((uint16_t)pkt[14] << 8) | pkt[15];
-        params.score_level   = ((uint16_t)pkt[16] << 8) | pkt[17];
+        params.status            = ((uint16_t)pkt[10] << 8) | pkt[11];
+        params.sensor_type       = ((uint16_t)pkt[12] << 8) | pkt[13];
+        params.database_capacity = ((uint16_t)pkt[14] << 8) | pkt[15];
+        params.score_level       = ((uint16_t)pkt[16] << 8) | pkt[17];
         params.address     = ((uint16_t)pkt[18] << 24) | ((uint16_t)pkt[19] << 16) | ((uint16_t)pkt[20] << 8) | pkt[21];
         params.packet_size = ((uint16_t)pkt[22] << 8) | pkt[23];
         params.baud_rate   = ((uint16_t)pkt[24] << 8) | pkt[25];
@@ -563,13 +563,7 @@ bool UnitFinger2::clear()
 
 bool UnitFinger2::writeSystemRegister(const finger2::RegisterID reg_id, const uint8_t value)
 {
-    auto reg = m5::stl::to_underlying(reg_id);
-    if (reg == 4 /* internal baud rate */ || reg > 11) {
-        M5_LIB_LOGE("Invalid reg_id %u", reg_id);
-        return false;
-    }
-
-    // parameter check
+    // Check args
     switch (reg_id) {
         case RegisterID::ScoreLevel:
             if (value < 1 || value > 5) {
@@ -583,20 +577,19 @@ bool UnitFinger2::writeSystemRegister(const finger2::RegisterID reg_id, const ui
                 return false;
             }
             break;
-        case RegisterID::SecurityLevel:
-            if (value > 3) {
-                M5_LIB_LOGE("SecurityLevel must be 0 - 3 (%u)", value);
-                return false;
-            }
         default:
-            break;
+            M5_LIB_LOGE("Invalid reg_id %u", reg_id);
+            return false;
     }
 
+#if 0
     if (reg >= 10) {
         reg = 0x10 + (reg - 10);  // DEC 10,11... => HEX 0x10, 0x11,...
     }
+#endif
+
     Packet pkt{};
-    uint8_t params[2]{reg, value};
+    uint8_t params[2]{m5::stl::to_underlying(reg_id), value};
     return transceive_command(pkt, CMD_WRITE_REGISTER, _address, params, sizeof(params));
 }
 
diff --git a/src/unit/unit_Finger2.hpp b/src/unit/unit_Finger2.hpp
index 56b1323..b66f75c 100644
--- a/src/unit/unit_Finger2.hpp
+++ b/src/unit/unit_Finger2.hpp
@@ -64,36 +64,11 @@ enum class LEDColor : uint8_t {
 
 /*!
   @enum RegisterID
-  @brief writeReg() target
+  @brief PS_WriteReg target register
  */
 enum class RegisterID : uint8_t {
-    DelayTime,           //!< 0x00:The time delay for sending data packets
-    EnrollTimes,         //!< 0x01:Enroll times
-    ImageFormat,         //!< 0x02:Image format (only 0)
-    EnrollLogic,         /*!< 0x03:The logic for capturing fingerprints during registration (0 as default)
-                           |Logic|Description|
-                           |---|---|
-                           | 0 | No logical relationship |
-                           | 1 | Requires no relationship between enrolled fingers|
-                           | 2 | Requires a relationship between enrolled fingers|
-                         */
-    ScoreLevel = 5,      //!< 0x05:Match threshold (Lenient:1 - Strict:5) (3 as default)
-    PacketSize,          //!< 0x06:Data packet size (0:32,1:64,2:128,3:256) (2 as default)
-    SecurityLevel,       /*!< 0x07:Encryption level (0 as default)
-                           <ul>
-                           <li>0: Supports all instructions except the security instruction set</li>
-                           <li>1: No security algorithms <br>
-                           Does not support the security instruction set, template upload, template download, or image
-                           download </li>
-                           <li>2: Reserved</li>
-                           <li>3: Supports AES (128-bit, ECB) <br>
-                           Does not support template upload, template download, image download, exact match, or
-                           search</li>
-                           </ol>
-                           @warning Once set, changes are not permitted
-                         */
-    ProductSerial = 10,  //!< 0x0A:Product model number
-    LEDControl,          //!< 0x0B:Turn on or off the auto-light feature
+    ScoreLevel = 5,  //!< 0x05:Match threshold (Lenient:1 - Strict:5) (3 as default)
+    PacketSize,      //!< 0x06:Data packet size (0:32,1:64,2:128,3:256) (1 as default)
 };
 
 /*!
@@ -101,14 +76,14 @@ enum class RegisterID : uint8_t {
  @brief The module’s basic parametrs
 */
 struct SystemBasicParams {
-    uint16_t status{};         //!< System operational status
-    uint16_t template_size{};  //!< Fingerprint template capacity (Not the actual template size)
-    uint16_t capacity{};       //!< Fingerprint library capacity
-    uint16_t score_level{};    //!< Match threshold (See also RegisterID::ScoreLevel)
-    uint32_t address{};        //!< Device address
-    uint16_t packet_size{};    //!< Packet size (See also RegisterID::PacketSize)
-    uint16_t baud_rate{};      //!< Baud rate between STM32 and device
-                               //!< (The value multiplied by 9600 is the actual)
+    uint16_t status{};             //!< System operational status
+    uint16_t sensor_type{};        //!< Sensor type
+    uint16_t database_capacity{};  //!< Fingerprint database capacity
+    uint16_t score_level{};        //!< Match threshold (See also RegisterID::ScoreLevel)
+    uint32_t address{};            //!< Device address
+    uint16_t packet_size{};        //!< Packet size (See also RegisterID::PacketSize)
+    uint16_t baud_rate{};          //!< Baud rate between STM32 and device
+                                   //!< (The value multiplied by 9600 is the actual)
 } __attribute__((packed));
 
 using auto_enroll_flag_t   = uint16_t;  //!< Flags for autoEnroll
@@ -273,7 +248,7 @@ class UnitFinger2 : public Component {
     M5_UNIT_COMPONENT_HPP_BUILDER(UnitFinger2, 0x00);
 
 public:
-    static constexpr uint32_t DEFAULT_MODULE_ADDRESS{0xFFFFFFFF};  //!< DEFAULT_ADDRESS
+    static constexpr uint32_t DEFAULT_MODULE_ADDRESS{0xFFFFFFFF};  //!< Default device address
     using Packet = std::vector<uint8_t>;
 
     static constexpr uint16_t IMAGE_WIDTH{80};      //!< Capture image width
diff --git a/test/embedded/test_finger2/finger2_test.cpp b/test/embedded/test_finger2/finger2_test.cpp
index fab4bb7..5ecf535 100644
--- a/test/embedded/test_finger2/finger2_test.cpp
+++ b/test/embedded/test_finger2/finger2_test.cpp
@@ -70,6 +70,24 @@ protected:
         s.begin(115200, SERIAL_8N1, pin_num_in, pin_num_out);
         return &s;
     }
+
+    void reset_serial(const uint32_t baud = 19200)
+    {
+        auto pin_num_in  = M5.getPin(m5::pin_name_t::port_c_rxd);
+        auto pin_num_out = M5.getPin(m5::pin_name_t::port_c_txd);
+        if (pin_num_in < 0 || pin_num_out < 0) {
+            // M5_LOGW("PortC is not available");
+            Wire.end();
+            pin_num_in  = M5.getPin(m5::pin_name_t::port_a_pin1);
+            pin_num_out = M5.getPin(m5::pin_name_t::port_a_pin2);
+        }
+        // M5_LOGI("%u getPin: %d,%d", baud, pin_num_in, pin_num_out);
+        serial->end();
+        serial->begin(baud, SERIAL_8N1, pin_num_in, pin_num_out);
+        while (serial->available()) {
+            serial->read();
+        }
+    }
 };
 
 // INSTANTIATE_TEST_SUITE_P(ParamValues, TestFinger2, ::testing::Values(false, true));
@@ -85,7 +103,34 @@ constexpr WorkMode workmode_table[] = {
 
 constexpr LEDMode led_table[] = {
     LEDMode::Bleath, LEDMode::Blink, LEDMode::On, LEDMode::Off, LEDMode::Fadein, LEDMode::Fadeout,
+};
+constexpr auto_enroll_flag_t enroll_flags_table[] = {
+    0,
+    auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS,
+    auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+    auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS | auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+    auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE,
+    auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE | auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS,
+    auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE | auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE,
+    auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE | auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS |
+        auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS |
+        auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE |
+        auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE |
+        auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE,
+    auto_enroll_flag::NO_NEED_RELAESE_FINGER | auto_enroll_flag::PROHIBIT_DUPLICATE_TEMPLATE |
+        auto_enroll_flag::DONT_RETURN_INTERMEDIATE_RESULTS | auto_enroll_flag::ALLOW_OVERWRITE_PAGE,
+};
 
+constexpr auto_identify_flag_t identify_flags_table[] = {
+    0,
+    auto_identify_flag::DONT_RETURN_INTERMEDIATE_RESULTS,
 };
 
 auto rng = std::default_random_engine{};
@@ -111,7 +156,7 @@ TEST_P(TestFinger2, Basic)
     SCOPED_TRACE(ustr);
 
     /////
-    // return;
+    return;
 
     auto cfg = unit->config();
 
@@ -166,8 +211,9 @@ TEST_P(TestFinger2, Basic)
         SystemBasicParams params{};
         EXPECT_TRUE(unit->readSystemParams(params));
         EXPECT_NE(params.status, 0U);
-        EXPECT_EQ(params.template_size, 0x2EC8u);
-        EXPECT_EQ(params.capacity, 100u);
+        // EXPECT_EQ(params.template_size, 0x2EC8u);
+        // EXPECT_EQ(params.sensor_type,0x????);
+        EXPECT_EQ(params.database_capacity, 100u);
         EXPECT_EQ(params.score_level, cfg.score_level);
         EXPECT_EQ(params.address, 0xFFFFFFFFu);
         EXPECT_GE(params.packet_size, 0u);
@@ -196,9 +242,9 @@ TEST_P(TestFinger2, Basic)
         EXPECT_FALSE(unit->writeSystemRegister(RegisterID::PacketSize, 4));
         EXPECT_FALSE(unit->writeSystemRegister(RegisterID::PacketSize, 255));
 
-        EXPECT_TRUE(unit->writeSystemRegister(RegisterID::PacketSize, 2));
+        EXPECT_TRUE(unit->writeSystemRegister(RegisterID::PacketSize, 1));
         EXPECT_TRUE(unit->readSystemParams(params));
-        EXPECT_EQ(params.packet_size, 2);
+        EXPECT_EQ(params.packet_size, 1);
 
         uint8_t info[512]{};
         uint8_t info_empty[512]{};
@@ -236,7 +282,7 @@ TEST_P(TestFinger2, LED)
     SCOPED_TRACE(ustr);
 
     /////
-    // return;
+    return;
 
     EXPECT_TRUE(unit->writeSleepTime(10));
 
@@ -292,7 +338,7 @@ TEST_P(TestFinger2, Notepad)
     SCOPED_TRACE(ustr);
 
     /////
-    // return;
+    return;
 
     uint8_t buf[32]{};
     constexpr uint8_t empty[32]{};
@@ -371,7 +417,7 @@ TEST_P(TestFinger2, Template)
     SCOPED_TRACE(ustr);
 
     /////
-    // return;
+    return;
 
     std::vector<uint8_t> tbuf{};
     tbuf.resize(UnitFinger2::TEMPLATE_SIZE);
@@ -546,6 +592,9 @@ TEST_P(TestFinger2, Finger)
 {
     SCOPED_TRACE(ustr);
 
+    /////
+    return;
+
     for (auto&& wm : workmode_table) {
         auto s = m5::utility::formatString("WorkMode:%u", wm);
         SCOPED_TRACE(s.c_str());
@@ -655,6 +704,55 @@ TEST_P(TestFinger2, Finger)
     }
 }
 
+TEST_P(TestFinger2, Automatic)
+{
+    SCOPED_TRACE(ustr);
+    for (auto&& wm : workmode_table) {
+        auto s = m5::utility::formatString("WorkMode:%u", wm);
+        SCOPED_TRACE(s.c_str());
+        EXPECT_TRUE(unit->writeWorkMode(wm));
+
+        // In sleep
+        if (wm == WorkMode::ScheduledSleep) {
+            wait_sleep(unit.get());
+
+            ConfirmCode confirm{};
+            EXPECT_FALSE(unit->autoEnroll(confirm, 0));
+
+            bool matched{};
+            uint16_t page{}, score{};
+            EXPECT_FALSE(unit->autoIdentify(matched, page, score));
+            continue;
+        }
+
+        ConfirmCode confirm{};
+        EXPECT_FALSE(unit->autoEnroll(confirm, 0));
+        bool matched{};
+        uint16_t page{}, score{};
+        EXPECT_FALSE(unit->autoIdentify(matched, page, score));
+
+        EXPECT_FALSE(unit->autoEnroll(confirm, 100));
+        EXPECT_FALSE(unit->autoEnroll(confirm, 65535));
+
+        EXPECT_FALSE(unit->autoEnroll(confirm, 0, 0));
+        EXPECT_FALSE(unit->autoEnroll(confirm, 0, 6));
+        EXPECT_FALSE(unit->autoEnroll(confirm, 0, 255));
+
+        for (auto&& eflags : enroll_flags_table) {
+            EXPECT_FALSE(unit->autoEnroll(confirm, 0, 5, eflags));
+        }
+
+        EXPECT_FALSE(unit->autoIdentify(matched, page, score, 100));
+        EXPECT_FALSE(unit->autoIdentify(matched, page, score, 0xFFFE));
+        EXPECT_FALSE(unit->autoIdentify(matched, page, score, 0xFFFF, 2));
+        EXPECT_FALSE(unit->autoIdentify(matched, page, score, 0xFFFF, 255));
+
+        for (auto&& iflags : identify_flags_table) {
+            EXPECT_FALSE(unit->autoIdentify(matched, page, score, 0xFFFF, 0, iflags));
+        }
+    }
+}
+
 #if 0
 // page:0
 0x3ffb202c| 00 03 06 09 0C 0F 12 15 18 1B 1E 21 24 27 2A 2D |