ESP32控制舵机：把脉宽、动力电源和真实角度分开

idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig build
idf.py -B build-local -D SDKCONFIG=build-local/sdkconfig -p REPLACE_PORT flash monitor

cc -std=c11 -Wall -Wextra -Werror -fsanitize=address,undefined -fno-omit-frame-pointer host_check.c -o /tmp/actuator-host
/tmp/actuator-host

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <stdio.h>
#include <inttypes.h>
#include "driver/gpio.h"
#include "driver/ledc.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "servo_policy.h"
static esp_err_t pulse_set(uint16_t pulse){
 /* One owner, no fade/other task uses this channel. The thread-safe combined
    API needs an installed fade service in IDF5.5.5; it is deliberately not used. */
 esp_err_t e=ledc_set_duty(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,servo_duty(pulse));
 return e==ESP_OK?ledc_update_duty(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0):e;
}
void app_main(void){
 gpio_config_t in={.pin_bit_mask=1ULL<<GPIO_NUM_5,.mode=GPIO_MODE_INPUT};ESP_ERROR_CHECK(gpio_config(&in));
 ledc_timer_config_t timer={.speed_mode=LEDC_LOW_SPEED_MODE,.duty_resolution=LEDC_TIMER_14_BIT,.timer_num=LEDC_TIMER_0,.freq_hz=50,.clk_cfg=LEDC_USE_APB_CLK};ESP_ERROR_CHECK(ledc_timer_config(&timer));
 ledc_channel_config_t channel={.gpio_num=GPIO_NUM_6,.speed_mode=LEDC_LOW_SPEED_MODE,.channel=LEDC_CHANNEL_0,.timer_sel=LEDC_TIMER_0,.duty=0,.hpoint=0};ESP_ERROR_CHECK(ledc_channel_config(&channel));ESP_ERROR_CHECK(ledc_stop(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,0));
 printf("V06 REQUEST50Hz/14bit; SDK frequency=%"PRIu32"Hz; no physical waveform/position feedback. Release first, then hold ARM1s. External servo5V only; no automatic startup position.\n",ledc_get_freq(LEDC_LOW_SPEED_MODE,LEDC_TIMER_0));
 Servo state={0};bool was=false,fault=false;uint16_t last=0;unsigned reason=0;
 for(;;){
  servo_tick(&state,gpio_get_level(GPIO_NUM_5)==0,(uint64_t)esp_timer_get_time());
  if(!fault&&(was!=state.active||(state.active&&last!=state.pulse))){
   esp_err_t e=state.active?pulse_set(state.pulse):ledc_stop(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,0);
   if(e!=ESP_OK){fault=true;(void)ledc_stop(LEDC_LOW_SPEED_MODE,LEDC_CHANNEL_0,0);printf("PWM_API_FAULT=%s; stop requested; reset only after diagnosis\n",esp_err_to_name(e));}
   else printf("SERVO_REQUEST active=%u pulse_us=%u duty=%"PRIu32"; signal/position unmeasured\n",state.active,state.pulse,state.active?servo_duty(state.pulse):0);
  }
  if(reason!=state.reason){reason=state.reason;printf("STOP_REASON=%u; PWM stop is not power removal or observed shaft stop\n",reason);}
  was=state.active;last=state.pulse;vTaskDelay(pdMS_TO_TICKS(20));
 }
}

// ---- main/servo_policy.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
#include <stdbool.h>
typedef struct {
 bool initialized,candidate,stable,released,holding,active;
 uint64_t changed,pressed,started,stepped,last;
 uint16_t pulse;int direction;unsigned reason;
} Servo;
/* reason:0 waiting/normal,1 released,2 ten-second limit,3 owner-clock gap.
   Time budgets are checked only when this owner runs, never a hardware stop guarantee. */
static inline void servo_tick(Servo *s,bool pressed,uint64_t now){
 if(!s->initialized){*s=(Servo){.initialized=true,.candidate=pressed,.stable=true,.changed=now,.last=now,.pulse=1500,.direction=1};}
 bool gap=now<s->last||now-s->last>250000;s->last=now;
 if(gap){s->active=false;s->released=false;s->holding=false;s->candidate=pressed;s->stable=true;s->changed=now;s->reason=3;}
 if(pressed!=s->candidate){s->candidate=pressed;s->changed=now;}
 if(now>=s->changed&&now-s->changed>=50000&&s->stable!=s->candidate){
  s->stable=s->candidate;
  if(!s->stable){s->released=true;s->holding=false;}
  else if(s->released){s->pressed=now;s->holding=true;}
 }
 if(!pressed){if(s->active)s->reason=1;s->active=false;}
 if(s->active&&now-s->started>=10000000){s->active=false;s->released=false;s->holding=false;s->reason=2;}
 if(!s->active&&pressed&&s->stable&&s->holding&&s->released&&now-s->pressed>=1000000){
  s->active=true;s->released=false;s->holding=false;s->started=now;s->stepped=now;s->pulse=1500;s->direction=1;s->reason=0;
 }
 if(s->active&&now-s->started>=1000000&&now-s->stepped>=100000){
  s->stepped=now;s->pulse=(uint16_t)(s->pulse+5*s->direction);
  if(s->pulse>=1600){s->pulse=1600;s->direction=-1;}else if(s->pulse<=1400){s->pulse=1400;s->direction=1;}
 }
}
static inline uint32_t servo_duty(uint16_t pulse){return pulse<1400||pulse>1600?0:(uint32_t)(((uint64_t)pulse*16384+10000)/20000);}

# ---- sdkconfig.defaults ----
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
# CONFIG_SPIRAM is not set
# CONFIG_PM_ENABLE is not set
CONFIG_ESP_CONSOLE_UART_DEFAULT=y
CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
CONFIG_FREERTOS_HZ=1000

// ---- host_check.c ----
/* SPDX-License-Identifier: MIT */
#include <assert.h>
#include <stdio.h>
#include "main/servo_policy.h"
static uint64_t time_us;
static void steps(Servo *s,bool p,unsigned count){for(unsigned i=0;i<count;i++){servo_tick(s,p,time_us);time_us+=20000;}}
int main(void){
 Servo s={0};steps(&s,true,100);assert(!s.active);puts("PASS startup held never starts");
 steps(&s,false,5);steps(&s,true,50);assert(!s.active);steps(&s,true,5);assert(s.active&&s.pulse==1500);puts("PASS stable release then1s hold arms neutral");
 uint64_t start=s.started;while(time_us-start<1000000)steps(&s,true,1);assert(s.pulse==1500);steps(&s,true,1);assert(s.pulse==1505);puts("PASS neutral1s then5us scheduled increments");
 bool high=false,low=false;while(time_us-start<9990000){steps(&s,true,1);assert(s.pulse>=1400&&s.pulse<=1600);high|=s.pulse==1600;low|=s.pulse==1400;}assert(high&&low);steps(&s,true,2);assert(!s.active&&s.reason==2);steps(&s,true,100);assert(!s.active);puts("PASS bounded1400..1600 pulses and10s hold limit requires release");
 steps(&s,false,5);steps(&s,true,60);assert(s.active);steps(&s,false,1);assert(!s.active&&s.reason==1);puts("PASS raw release immediately requests signal stop at owner tick");
 steps(&s,false,5);steps(&s,true,60);assert(s.active);time_us+=250001;steps(&s,true,1);assert(!s.active&&s.reason==3);steps(&s,true,80);assert(!s.active);puts("PASS owner gap closes output and held input cannot rearm");
 assert(servo_duty(1399)==0&&servo_duty(1601)==0&&servo_duty(1400)==1147&&servo_duty(1500)==1229&&servo_duty(1600)==1311);puts("PASS explicit14bit pulse calculation and range rejection; not waveform measurement");
 time_us=UINT64_C(5)*UINT64_C(4294967296)*1000;s=(Servo){0};steps(&s,false,5);steps(&s,true,60);assert(s.active);puts("PASS full64bit microsecond time after five32bit millisecond cycles");
 puts("8 same-source synthetic groups passed; no servo, GPIO, waveform, angle or power measurement");
}