ESP RainMaker 做远程小灯：先分清设备、账号和云服务

// ---- main/light_model.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdbool.h>
#include <stdint.h>
typedef enum {N10_NONE,N10_SHORT,N10_WIFI_RESET} N10Action;
typedef struct {bool raw,stable,ready,pressed;uint64_t changed,down;} N10Button;
/* Initialize raw/stable to the actual level at boot. A stable release must be
   observed before accepting any press; actions occur only on debounced release. */
static inline N10Button n10_button_init(bool down,uint64_t now){return(N10Button){.raw=down,.stable=down,.changed=now};}
static inline N10Action n10_button_tick(N10Button*b,bool down,uint64_t now){
 if(down!=b->raw){b->raw=down;b->changed=now;}
 if(now<b->changed||now-b->changed<30)return N10_NONE;
 if(!down&&!b->ready){b->ready=true;b->stable=false;b->pressed=false;return N10_NONE;}
 if(!b->ready||b->stable==down)return N10_NONE;
 b->stable=down;
 if(down){b->pressed=true;b->down=now;return N10_NONE;}
 if(!b->pressed)return N10_NONE;
 b->pressed=false;return now>=b->down&&now-b->down>=5000?N10_WIFI_RESET:N10_SHORT;
}

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdatomic.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/gpio.h"
#include "esp_timer.h"
#include "esp_log.h"
#include "esp_event.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "esp_rmaker_core.h"
#include "esp_rmaker_standard_params.h"
#include "esp_rmaker_standard_devices.h"
#include "esp_rmaker_standard_types.h"
#include "esp_rmaker_standard_services.h"
#include "esp_rmaker_utils.h"
#include "app_network.h"
#include "sdkconfig.h"
#include "light_model.h"
#define LED GPIO_NUM_4
#define BUTTON GPIO_NUM_5
static const char*TAG="N10";
static QueueHandle_t writes;
static _Atomic(esp_rmaker_param_t*) power_param;
static atomic_bool cloud_ready,reset_pending;
static uint64_t ms(void){return (uint64_t)esp_timer_get_time()/1000;}
#if CONFIG_N10_CLASSIC_CLOUD
static esp_err_t write_cb(const esp_rmaker_device_t*d,const esp_rmaker_param_t*p,const esp_rmaker_param_val_t v,void*priv,esp_rmaker_write_ctx_t*ctx){
 (void)d;(void)priv;(void)ctx;
 if(atomic_load(&reset_pending))return ESP_ERR_INVALID_STATE;
 if(p!=atomic_load(&power_param)||v.type!=RMAKER_VAL_TYPE_BOOLEAN)return ESP_ERR_INVALID_ARG;
 const bool requested=v.val.b;
 /* Callback accepts a bounded request; only owner changes GPIO and reports. */
 return xQueueSend(writes,&requested,0)==pdTRUE?ESP_OK:ESP_ERR_NO_MEM;
}
static void status_event(void*unused,esp_event_base_t base,int32_t id,void*data){
 (void)unused;(void)data;
 if(base==IP_EVENT&&id==IP_EVENT_STA_GOT_IP)ESP_LOGI(TAG,"GOT_IP: not cloud/account association proof");
 if(base==WIFI_EVENT&&id==WIFI_EVENT_STA_DISCONNECTED)ESP_LOGW(TAG,"AP_DISCONNECTED: local button remains active; helper handles reconnect");
}
#endif
static void owner(void*unused){
 (void)unused;bool state=false,dirty=true,reset_requested=false;uint64_t report_at=0;
 N10Button button=n10_button_init(gpio_get_level(BUTTON)==0,ms());
 for(;;){
  bool requested;while(xQueueReceive(writes,&requested,0)==pdTRUE){if(!reset_requested){state=requested;dirty=true;}}
  const uint64_t now=ms();N10Action a=n10_button_tick(&button,gpio_get_level(BUTTON)==0,now);
  if(a==N10_SHORT&&!reset_requested){state=!state;dirty=true;}
  if(a==N10_WIFI_RESET&&!reset_requested){
   if(atomic_load(&cloud_ready)){
    reset_requested=true;atomic_store(&reset_pending,true);state=false;dirty=true;
    /* Fixed upstream API returns acceptance, not verified erase/reboot. */
    esp_err_t rc=esp_rmaker_wifi_reset(2,2);ESP_LOGW(TAG,"WIFI_RESET_REQUEST=%s; verify reboot and BLE provisioning physically",esp_err_to_name(rc));
   }else ESP_LOGW(TAG,"LOCAL_ONLY_OR_START_FAILED: no Wi-Fi credentials reset requested");
  }
  if(dirty){
   esp_err_t rc=gpio_set_level(LED,state?1:0);
   if(rc!=ESP_OK){state=false;(void)gpio_set_level(LED,0);ESP_LOGE(TAG,"GPIO_ERROR=%s, OFF requested",esp_err_to_name(rc));}
   ESP_LOGI(TAG,"OUTPUT_LATCH=%s; not optical feedback or phone confirmation",state?"ON":"OFF");
   dirty=false;report_at=0;
  }
  esp_rmaker_param_t*p=atomic_load(&power_param);
  if(p&&atomic_load(&cloud_ready)&&now>=report_at){
   esp_err_t rc=esp_rmaker_param_update_and_report(p,esp_rmaker_bool(state));
   ESP_LOGI(TAG,"REPORT_REQUEST=%s; remote display/delivery must be observed separately",esp_err_to_name(rc));report_at=now+5000;
  }
  vTaskDelay(pdMS_TO_TICKS(10));
 }
}
void app_main(void){
 gpio_config_t out={.pin_bit_mask=UINT64_C(1)<<LED,.mode=GPIO_MODE_OUTPUT,.pull_up_en=GPIO_PULLUP_DISABLE,.pull_down_en=GPIO_PULLDOWN_DISABLE,.intr_type=GPIO_INTR_DISABLE};
 ESP_ERROR_CHECK(gpio_config(&out));ESP_ERROR_CHECK(gpio_set_level(LED,0));
 gpio_config_t in={.pin_bit_mask=UINT64_C(1)<<BUTTON,.mode=GPIO_MODE_INPUT,.pull_up_en=GPIO_PULLUP_DISABLE,.pull_down_en=GPIO_PULLDOWN_DISABLE,.intr_type=GPIO_INTR_DISABLE};ESP_ERROR_CHECK(gpio_config(&in));
 writes=xQueueCreate(8,sizeof(bool));if(!writes)return;
 if(xTaskCreate(owner,"light_owner",4096,NULL,5,NULL)!=pdPASS)return;
#if !CONFIG_N10_CLASSIC_CLOUD
 ESP_LOGW(TAG,"LOCAL_ONLY: Classic cloud disabled; no Wi-Fi/BLE/account operation. Button works, power resets OFF.");return;
#else
 esp_err_t rc=nvs_flash_init();if(rc!=ESP_OK){ESP_LOGE(TAG,"NVS=%s: stop cloud, preserve contents; no automatic erase",esp_err_to_name(rc));return;}
 app_network_init(); /* Fixed helper is void and uses ESP_ERROR_CHECK internally. */
 ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,ESP_EVENT_ANY_ID,status_event,NULL));
 ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT,ESP_EVENT_ANY_ID,status_event,NULL));
 esp_rmaker_config_t config={.enable_time_sync=true};
 esp_rmaker_node_t*node=esp_rmaker_node_init(&config,"N10 Owned LED","Light");if(!node){ESP_LOGE(TAG,"node_init failed; local button only");return;}
 esp_rmaker_device_t*device=esp_rmaker_lightbulb_device_create("LED",NULL,false);if(!device)return;
 esp_rmaker_param_t*p=esp_rmaker_device_get_param_by_type(device,ESP_RMAKER_PARAM_POWER);if(!p)return;
 atomic_store(&power_param,p);ESP_ERROR_CHECK(esp_rmaker_device_add_cb(device,write_cb,NULL));ESP_ERROR_CHECK(esp_rmaker_node_add_device(node,device));
 esp_rmaker_system_serv_config_t system={.flags=SYSTEM_SERV_FLAG_REBOOT|SYSTEM_SERV_FLAG_FACTORY_RESET|SYSTEM_SERV_FLAG_WIFI_RESET,.reboot_seconds=2,.reset_seconds=2,.reset_reboot_seconds=2};
 ESP_ERROR_CHECK(esp_rmaker_system_service_enable(&system));
 rc=esp_rmaker_start();if(rc!=ESP_OK){ESP_LOGE(TAG,"agent_start=%s",esp_err_to_name(rc));return;}
 atomic_store(&cloud_ready,true);
 rc=app_network_start(POP_TYPE_RANDOM);if(rc!=ESP_OK){atomic_store(&cloud_ready,false);ESP_LOGE(TAG,"provision_start=%s; local button only, inspect factory/claim configuration",esp_err_to_name(rc));return;}
 ESP_LOGW(TAG,"CLASSIC network/claim agent started: no claim, account mapping, phone control or removal result asserted");
#endif
}