开源工程中，接近与环境光传感器 LTR-553ALS-WA和全功能 NFC ST25R3916 的驱动没有开源吗

[apachexc]

[Harrison-Xu]

这个仓库只是出厂固件，没有用到全部硬件功能。

你想要的部分可以看这里：
https://github.com/m5stack/StackChan-BSP

[apachexc]

NFC https://github.com/m5stack/M5Unit-NFC ？

[Harrison-Xu]

可以的，也可以看这里
https://github.com/m5stack/StackChan-BSP/tree/main/examples/NFC
或者
https://docs.m5stack.com/zh_CN/arduino/stackchan/nfc

[apachexc]

M5unit-NFC 集成进去了，手机贴近stackchan ，stackchan能识别， 但是M5unit-NFC 好像不支持2台stackchan设备互相识别？ 另外，用NFC标签纸，stackchan M5unit-NFC 好像也不能识别？

[Harrison-Xu]

不能啊，会不会是识别区域的问题，多试试不同的位置？可以发代码、视频看下 👀

[apachexc]

//测试代码如下：

#include "stackchan_nfc.h"

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "driver/i2c_master.h"
#include "esp_heap_caps.h"
#include "esp_err.h"
#include "esp_http_client.h"
#include "cJSON.h"
#include "esp_netif.h"

#include "../../main/hal/board/hal_bridge.h"
#include "../../xiaozhi-esp32/main/boards/common/board.h"

#include "M5UnitUnified.h"
#include "M5UnitUnifiedNFC.h"
#include "M5Utility.h"

using namespace m5::nfc::a;

// 全局设备鉴权Token，业务层初始化赋值
char g_device_token[128] = {0};

// NFC 交友触发回调
static nfc_friend_trigger_cb_t s_friend_trigger_cb = NULL;

extern "C" void nfc_register_friend_trigger_callback(nfc_friend_trigger_cb_t cb)
{
s_friend_trigger_cb = cb;
}

static m5::unit::UnitUnified nfc_units;
static m5::unit::UnitNFC nfc_unit;
static m5::nfc::NFCLayerA nfc_a(nfc_unit);

static SemaphoreHandle_t i2c_mutex = NULL;
static SemaphoreHandle_t http_mutex = NULL;
static TaskHandle_t nfc_task_handle = NULL;

// 最大卡片数，用静态数组替代vector，彻底消除STL堆分配
#define MAX_CARD_NUM 8

// 异步请求参数，用固定长度数组，避免string拷贝触发堆分配
typedef struct {
char req_token[64];
char peer_code[64];
} nfc_friend_req_t;

// 生成32位随机requestToken，直接写入输出缓冲区
static void generate_nfc_request_token(char* out_buf, int buf_len)
{
const char table[] = "0123456789abcdef";
if (buf_len < 33) return;
for (int i = 0; i < 32; i++)
{
out_buf[i] = table[esp_random() % sizeof(table)];
}
out_buf[32] = '\0';
}

// HTTP POST 任务入口
static void http_post_nfc_friend_task(void* pvParameters) {
nfc_friend_req_t* req = (nfc_friend_req_t*)pvParameters;
std::string auth_token = Board::GetInstance().GetAuthToken();
if (auth_token.empty()) {
auth_token = "device_3fc01cfa-69cc-4ce7-8807-7161afbc14a9";
}
if (!auth_token.empty()) {
strncpy(g_device_token, auth_token.c_str(), sizeof(g_device_token) - 1);
g_device_token[sizeof(g_device_token) - 1] = '\0';
printf("[NFC] Device auth token loaded, length: %u\n", strlen(g_device_token));
} else {
printf("[NFC] WARNING: Auth token not ready, friend trigger will be skipped\n");

}

if (strlen(g_device_token) == 0)
{
    printf("[NFC Friend] Error: device token empty, skip request\n");
    free(req);
    vTaskDelete(NULL);
    return;
}

if (http_mutex == nullptr)
{
    http_mutex = xSemaphoreCreateMutex();
}
if (xSemaphoreTake(http_mutex, pdMS_TO_TICKS(2000)) != pdTRUE)
{
    printf("[NFC Friend] HTTP mutex lock fail\n");
    free(req);
    vTaskDelete(NULL);
    return;
}

esp_err_t ret = ESP_OK;
// 1. 组装请求JSON
cJSON *root = cJSON_CreateObject();
//cJSON_AddStringToObject(root, "deviceId", "2053025213814521857");
cJSON_AddStringToObject(root, "deviceId", "2053039445918412801");
cJSON_AddStringToObject(root, "requestToken", req->req_token);
if (strlen(req->peer_code) > 0)
{
    cJSON_AddStringToObject(root, "peerDeviceCode", req->peer_code);
}
printf("[NFC Friend] JSON root:%s \n", cJSON_Print(root));

// 释放参数结构体，尽早释放内存
free(req);
req = NULL;

// JSON序列化缓冲区分配到PSRAM，不占内部SRAM
char *post_data = (char*)heap_caps_malloc(512, MALLOC_CAP_SPIRAM);
if (!post_data)
{
    printf("[NFC Friend] JSON buffer alloc fail\n");
    cJSON_Delete(root);
    xSemaphoreGive(http_mutex);
    vTaskDelete(NULL);
    return;
}
// 用cJSON_PrintPreallocated避免内部二次分配
cJSON_PrintPreallocated(root, post_data, 512, 0);
cJSON_Delete(root);

// 2. HTTP配置
esp_http_client_config_t cfg = {
    .url = "http://192.168.31.79:9003/api/chat/nfc/friend/trigger",
    .method = HTTP_METHOD_POST,
    .timeout_ms = 5000,
    .buffer_size = 2048,
    .buffer_size_tx = 1024
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);

// 请求头
esp_http_client_set_header(client, "Content-Type", "application/json");
esp_http_client_set_header(client, "Token", g_device_token);
esp_http_client_set_post_field(client, post_data, strlen(post_data));

// 3. 发送请求
ret = esp_http_client_perform(client);
if (ret == ESP_OK)
{
    int status = esp_http_client_get_status_code(client);
    int content_len = esp_http_client_get_content_length(client);
    printf("[NFC Friend] HTTP status:%d len:%d\n", status, content_len);

   if (status == 200)
    {
        const int MAX_RESP_LEN = 4096;
        char *resp_buf = (char *)heap_caps_malloc(MAX_RESP_LEN, MALLOC_CAP_SPIRAM);
        if (resp_buf)
        {
            memset(resp_buf, 0, MAX_RESP_LEN);
            // 统一读取，无视content_len正负
            int read_len = esp_http_client_read_response(client, resp_buf, MAX_RESP_LEN - 1);
            printf("[NFC Friend] Raw Response: %s\n", resp_buf);

            cJSON *resp_root = cJSON_Parse(resp_buf);
            if (resp_root)
            {
                int code = cJSON_GetNumberValue(cJSON_GetObjectItem(resp_root, "code"));
                const char *msg = cJSON_GetStringValue(cJSON_GetObjectItem(resp_root, "msg"));
                cJSON *data = cJSON_GetObjectItem(resp_root, "data");
                printf("[NFC Friend] Resp code:%d msg:%s\n", code, msg ? msg : "null");
                if (code == 200 && data)
                {
                    const char *connect_order = cJSON_GetStringValue(cJSON_GetObjectItem(data, "connectOrder"));
                    int wait_sec = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(data, "waitSeconds"));
                    bool peer_ready = cJSON_IsTrue(cJSON_GetObjectItem(data, "peerReady"));

                    printf("==== NFC Friend Coordinate Result ====\n");
                    printf("msg: %s\n", msg ? msg : "null");
                    printf("connectOrder: %s\n", connect_order ? connect_order : "null");
                    printf("waitSeconds: %d\n", wait_sec);
                    printf("peerReady: %s\n", peer_ready ? "true" : "false");
                    printf("======================================\n");

                    if (s_friend_trigger_cb != NULL)
                        s_friend_trigger_cb(connect_order ? connect_order : "");
                }
                else
                {
                    printf("[NFC Friend] Server error code:%d msg:%s\n", code, msg ? msg : "");
                }
                cJSON_Delete(resp_root);
            }
            heap_caps_free(resp_buf);
        }
        else
        {
            printf("[NFC Friend] resp_buf malloc failed\n");
        }
    }
    else if (status != 200)
    {
        printf("[NFC Friend] HTTP response not 200, status:%d\n", status);
    }
}
else
{
    printf("[NFC Friend] HTTP request fail, err:%d\n", ret);
}

// 资源释放
esp_http_client_cleanup(client);
heap_caps_free(post_data);
xSemaphoreGive(http_mutex);
vTaskDelete(NULL);

}

// 触发异步交友请求
static void trigger_nfc_friend_async(const char* req_token, const char* peer_code)
{
nfc_friend_req_t* req = (nfc_friend_req_t*)malloc(sizeof(nfc_friend_req_t));
if (!req) return;
strncpy(req->req_token, req_token, sizeof(req->req_token)-1);
strncpy(req->peer_code, peer_code, sizeof(req->peer_code)-1);

// 低优先级独立任务，不阻塞NFC扫描
xTaskCreatePinnedToCore(
    http_post_nfc_friend_task,
    "nfc_http",
    6144,
    req,
    2,
    NULL,
    0
);

}

static void nfc_scan_task(void* pvParameters) {
printf("[NFC] NFC scan task created, wait for system init...\n");
vTaskDelay(pdMS_TO_TICKS(3000));
printf("[NFC] NFC scan task started\n");

if (i2c_mutex == NULL) {
    i2c_mutex = xSemaphoreCreateMutex();
    if (i2c_mutex == NULL) {
        printf("[NFC] ERROR: Failed to create I2C mutex\n");
        vTaskDelete(NULL);
        return;
    }
}

i2c_master_bus_handle_t i2c_bus = hal_bridge::board_get_i2c_bus();
if (i2c_bus == nullptr) {
    printf("[NFC] ERROR: Get main I2C bus failed\n");
    vTaskDelete(NULL);
    return;
}

// 挂载NFC设备
if (xSemaphoreTake(i2c_mutex, portMAX_DELAY) == pdTRUE) {
    bool add_ok = nfc_units.add(nfc_unit, i2c_bus);
    xSemaphoreGive(i2c_mutex);
    if (!add_ok) {
        printf("[NFC] ERROR: attach NFC device failed\n");
        vTaskDelete(NULL);
        return;
    }
}

// 初始化NFC单元
if (xSemaphoreTake(i2c_mutex, portMAX_DELAY) == pdTRUE) {
    bool begin_ok = nfc_units.begin();
    xSemaphoreGive(i2c_mutex);
    if (!begin_ok) {
        printf("[NFC] ERROR: M5UnitUnified init failed\n");
        vTaskDelete(NULL);
        return;
    }
}

printf("[NFC] M5Unit-NFC scan started\n");

uint32_t heap_check_tick = 0;
uint32_t corruption_count = 0;
char current_req_token[64] = {0};

while (true) {
    // 内部SRAM水位保护
    size_t free_internal = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
    if (free_internal < 6144) {
        vTaskDelay(pdMS_TO_TICKS(500));
        continue;
    }

    // 堆完整性检测：每2秒1次，只异常时打印
    heap_check_tick++;
    if (heap_check_tick >= 20) {
        heap_check_tick = 0;
        if (!heap_caps_check_integrity_all(false)) {
            corruption_count++;
            printf("[NFC] WARNING: Heap corruption detected! count:%lu\n", corruption_count);
            // 连续5次损坏，主动重启设备，避免积累到致命崩溃
            if (corruption_count >= 15) {
                printf("[NFC] FATAL: Heap too corrupted, reboot system\n");
                esp_restart();
            }
        } else {
            corruption_count = 0;
        }
    }

    bool has_card = false;
    bool trigger_friend = false;

    if (xSemaphoreTake(i2c_mutex, pdMS_TO_TICKS(500)) == pdTRUE) {
        nfc_units.update();

        // 用静态数组接收卡片，替代vector，消除STL堆分配
        // 注意：库内部仍会分配，但外层不再额外增加堆操作
        std::vector<PICC> picc_vec;
        picc_vec.reserve(MAX_CARD_NUM);

        // 检测超时150ms，兼容手机NFC
        if (nfc_a.detect(picc_vec, 150)) {
            has_card = true;
            size_t card_num = picc_vec.size();
            if (card_num > MAX_CARD_NUM) card_num = MAX_CARD_NUM;

            for (size_t i = 0; i < card_num; i++) {
                auto& card = picc_vec[i];
                if (nfc_a.identify(card)) {
                    printf("[NFC] Detected Card | UID: %s | Type: %s\n",
                           card.uidAsString().c_str(),
                           card.typeAsString().c_str());
                    trigger_friend = true;
                }
            }
            nfc_a.deactivate();

            // 防抖轮询，减少detect调用次数
            uint32_t hold_cnt = 0;
            while (hold_cnt < 2) {
                std::vector<PICC> tmp_vec;
                tmp_vec.reserve(4);
                if (!nfc_a.detect(tmp_vec, 20)) {
                    break;
                }
                hold_cnt++;
                vTaskDelay(pdMS_TO_TICKS(150));
            }
        }

        xSemaphoreGive(i2c_mutex);
    }

    // 刷卡成功，异步触发交友接口
    if (trigger_friend)
    {
        generate_nfc_request_token(current_req_token, sizeof(current_req_token));
        printf("[NFC Friend] Start trigger, requestToken=%s\n", current_req_token);
        trigger_nfc_friend_async(current_req_token, "");
    }

    // 扫描间隔拉长到200ms，降低库调用频率，减少堆损坏概率
    if (has_card) {
        vTaskDelay(pdMS_TO_TICKS(500));
    } else {
        vTaskDelay(pdMS_TO_TICKS(200));
    }
}

}

extern "C" void nfc_detect_start(void) {
// 防止重复创建任务
if (nfc_task_handle != NULL) {
return;
}
// 栈深度16KB，绑定Core0
xTaskCreatePinnedToCore(
nfc_scan_task,
"nfc_scan",
16384,
NULL,
5,
&nfc_task_handle,
0
);
}

[apachexc]

手机能识别，如上图的日志显示， 但标签纸不行。

[apachexc]

理论上，ST25R3916 完整硬件能力，四大完整模式全都原生支持吧：

1. Reader/Writer 读卡（当前在用）
2. Card Emulation 卡模拟（把设备变成 NFC 卡片，两台 StackChan 互碰识别核心功能）
3. P2P 点对点通信
4. 主动 / 被动 NFC 交互

有没有两台 StackChan 互碰识别的例子？
github上只有读卡的例程。

[Forairaaaaa]

你好，M5Unit-NFC 已有卡模拟例程，可以先让两台 StackChan 分别运行：

• 一台运行 NFC-A Emulation，模拟 NFC 标签。
• 另一台运行 NFC-A Detect，读取前一台的 UID。

StackChan NFC 文档中也有卡模拟示例，如果需要两台使用相同程序、互碰后双方交换设备身份，还需要在此基础上增加角色切换和数据交换逻辑；上述例程可以先验证一读一卡的识别流程。