应广科技Padauk单片机MCU低成本开发指南：七段屏/温控/医疗设备合规单片机方案,OTP存储器 | 12位ADC采集 | 状态机协议 | 睡眠功耗0.1μA

#include
#include

// 硬件定义
#define RX_PIN        PA0      // 数据接收引脚
#define TX_PIN        PA6      // 数据转发引脚
#define EOT          0x00      // 结束符
#define MAX_DISPLAYS  32       // 最大支持显示器数量

// 状态机定义
typedef enum {
  RECV,       // 接收模式
  FORWARD,    // 转发模式
  UPDATE      // 更新显示
} State_t;

// 全局变量
volatile uint8_t segment_data = 0;
volatile State_t STATE = RECV;
volatile uint8_t display_index = 0;

// 七段数码管0-9编码表（共阴极）
const uint8_t seg_table[10] = {
  0x3F, // 0
  0x06, // 1
  0x5B, // 2
  0x4F, // 3
  0x66, // 4
  0x6D, // 5
  0x7D, // 6
  0x07, // 7
  0x7F, // 8
  0x6F  // 9
};

// 初始化函数
void init_uart() {
  // 设置PA0为输入（接收引脚）
  PADIER |= (1 << RX_PIN);
  
  // 设置PA6为输出（转发引脚）
  PAC |= (1 << TX_PIN);
  
  // 设置PB端口为输出（段码驱动）
  PBC = 0xFF;
  
  // 启用引脚变化中断
  INTEN |= INT_PA0;
  INTEGS |= EDGE_FALLING; // 下降沿触发
}

// 中断服务程序
void interrupt(void) __interrupt(0) {
  if (INTF & INT_PA0) {   // PA0引脚变化中断
    INTF &= ~INT_PA0;     // 清除中断标志
    UART_Handler();       // 调用UART处理函数
  }
}

// UART处理函数
void UART_Handler() {
  static uint8_t bit_count = 0;
  static uint8_t rx_byte = 0;
  
  // 接收起始位检测
  if (bit_count == 0) {
    if (!PA & (1 << RX_PIN)) {
      bit_count = 1;
      rx_byte = 0;
    }
    return;
  }
  
  // 接收8位数据（含起始位）
  if (bit_count < 9) {
    // 在数据位中间采样
    _delay_us(52);  // 在16MHz下约52us (1/19200)
    
    uint8_t bit_val = (PA & (1 << RX_PIN)) ? 1 : 0;
    
    if (bit_count >= 1 && bit_count <= 8) {
      rx_byte |= (bit_val << (bit_count - 1));
    }
    
    bit_count++;
    return;
  }
  
  // 接收结束位
  bit_count = 0;
  
  // 状态机处理
  if (STATE == RECV) {
    if (rx_byte != EOT) {
      // 只取低5位用于显示
      segment_data = rx_byte & 0x1F;
    } else {
      STATE = FORWARD;
    }
  } 
  
  if (STATE == FORWARD) {
    // 转发数据
    if (rx_byte == EOT) {
      STATE = UPDATE;
    } else {
      // 模拟UART发送
      PA &= ~(1 << TX_PIN); // 起始位
      _delay_us(104);
      
      for (uint8_t i = 0; i < 8; i++) {
        if (rx_byte & (1 << i)) {
          PA |= (1 << TX_PIN);
        } else {
          PA &= ~(1 << TX_PIN);
        }
        _delay_us(104);
      }
      
      PA |= (1 << TX_PIN); // 停止位
      _delay_us(104);
    }
  }
  
  if (STATE == UPDATE) {
    update_display(segment_data);
    STATE = RECV;
  }
}

// 显示驱动函数（带PWM调光）
void update_display(uint8_t num) {
  uint8_t seg_code = seg_table[num % 10];
  
  // 软件PWM调光（占空比25%）
  for (uint8_t cycle = 0; cycle < 4; cycle++) {
    if (cycle == 0) {
      PB = seg_code; // 开启显示
    } else {
      PB = 0x00;     // 关闭显示
    }
    _delay_ms(1);    // PWM周期约4ms
  }
}

// 主函数
void main() {
  // 初始化
  MISC = 0b00000010; // 启用IHRC 16MHz
  CLKMD = 0b00100000; 
  while (!(CLKMD & 0b00000001)); // 等待时钟稳定
  
  init_uart();
  EI(); // 全局中断使能
  
  // 主循环
  while (1) {
    // 睡眠模式降低功耗
    SLEEP();
  }
}

#include
#include

// PID参数
#define KP          2.5f
#define KI          0.1f
#define KD          0.5f
#define SAMPLE_TIME 100   // ms

// 温度范围
#define MIN_TEMP    50
#define MAX_TEMP    250
#define SAFE_TEMP   280   // 过热保护阈值

// 温度校准点结构体
typedef struct {
  uint16_t adc_value;
  uint8_t temp_celsius;
} TempPoint;

// 温度校准表
const TempPoint temp_table[] = {
  {800, 25},   // 25°C
  {700, 50},   // 50°C
  {600, 75},   // 75°C
  {500, 100},  // 100°C
  {400, 125},  // 125°C
  {300, 150},  // 150°C
  {200, 175},  // 175°C
  {100, 200},  // 200°C
  {50,  225},  // 225°C
  {25,  250}   // 250°C
};

// PID控制器
typedef struct {
  float setpoint;
  float integral;
  float prev_error;
} PIDController;

// 全局变量
volatile PIDController pid = {100.0f, 0.0f, 0.0f}; // 默认100°C
volatile uint8_t current_pwm = 0;

// 初始化ADC
void init_adc() {
  ADCR = 0b10001000; // 选择ADC8通道，启用ADC
  ADCCR = 0b00000000; // 参考电压VDD
}

// 读取ADC值
uint16_t read_adc() {
  ADCR |= 0b00000001; // 启动转换
  while (ADCR & 0b00000001); // 等待转换完成
  return (ADCD << 8) | ADCDL; // 12位ADC值
}

// ADC值转换为温度
uint8_t adc_to_temp(uint16_t adc_val) {
  // 查找表转换
  for (uint8_t i = 1; i < sizeof(temp_table)/sizeof(TempPoint); i++) {
    if (adc_val >= temp_table[i].adc_value) {
      // 线性插值
      uint16_t adc_diff = temp_table[i-1].adc_value - temp_table[i].adc_value;
      uint8_t temp_diff = temp_table[i-1].temp_celsius - temp_table[i].temp_celsius;
      
      return temp_table[i].temp_celsius + 
             (uint8_t)((temp_diff * (adc_val - temp_table[i].adc_value)) / adc_diff);
    }
  }
  return MAX_TEMP; // 超出范围
}

// PID计算
uint8_t pid_control(uint8_t current_temp) {
  float error = pid.setpoint - current_temp;
  
  // 积分项（带抗饱和）
  pid.integral += KI * error;
  if (pid.integral > 255) pid.integral = 255;
  if (pid.integral < 0) pid.integral = 0;
  
  // 微分项
  float derivative = KD * (error - pid.prev_error);
  pid.prev_error = error;
  
  // PID输出
  float output = KP * error + pid.integral + derivative;
  
  // 限制输出范围
  if (output > 255) output = 255;
  if (output < 0) output = 0;
  
  return (uint8_t)output;
}

// PWM初始化
void init_pwm() {
  // 使用Timer0 PWM模式
  TM0C = 0b00100000; // PWM模式，时钟源IHRC/4
  TM0S = 0b00000100; // 分频器4分频 (16MHz/4=4MHz)
  TM0B = 0;          // 占空比初始0
  TM0CT = 0;         // 计数器清零
  TM0C |= 0b10000000; // 启用Timer0
}

// 设置PWM占空比
void set_pwm(uint8_t duty) {
  TM0B = duty;
}

// 温度保护
void temp_protection(uint8_t current_temp) {
  if (current_temp > SAFE_TEMP) {
    // 过热保护
    set_pwm(0); // 关闭加热
    while (1) { // 进入保护状态
      // 闪烁报警LED
      PA ^= (1 << PA3);
      _delay_ms(500);
    }
  }
}

// 主函数
void main() {
  // 时钟初始化
  MISC = 0b00000010; // IHRC 16MHz
  CLKMD = 0b00100000;
  while (!(CLKMD & 0b00000001));
  
  // 外设初始化
  init_adc();
  init_pwm();
  
  // 主循环
  while (1) {
    // 读取温度
    uint16_t adc_val = read_adc();
    uint8_t current_temp = adc_to_temp(adc_val);
    
    // 温度保护
    temp_protection(current_temp);
    
    // PID控制
    current_pwm = pid_control(current_temp);
    set_pwm(current_pwm);
    
    // 采样间隔
    _delay_ms(SAMPLE_TIME);
  }
}

uint32_t read_count() {
    uint32_t count = 0;
    i2c_start();
    i2c_write(0xA0); // EEPROM地址
    i2c_write(0x00); // 数据地址高字节
    i2c_write(0x00); // 低字节
    count = (i2c_read() << 16); // 读取24位数据
    count |= (i2c_read() << 8);
    count |= i2c_read();
    return count;
}

#include
#include

// 参数存储地址
#define ZERO_ADDR   0x10
#define SCALE_ADDR  0x14

// 全局变量
float zero_val = 0.0f;
float scale_factor = 1.0f;

// ADC初始化
void init_adc() {
  ADCR = 0b10000000; // 选择ADC0通道
  ADCCR = 0b00000000; // VDD参考
}

// 读取ADC值
uint16_t read_adc() {
  ADCR |= 0b00000001; // 启动转换
  while (ADCR & 0b00000001); // 等待完成
  return (ADCD << 8) | ADCDL;
}

// 读取校准参数
void read_calibration() {
  // 从SRAM读取零点值
  uint8_t *zero_ptr = (uint8_t*)ZERO_ADDR;
  zero_val = *(float*)zero_ptr;
  
  // 从SRAM读取比例因子
  uint8_t *scale_ptr = (uint8_t*)SCALE_ADDR;
  scale_factor = *(float*)scale_ptr;
}

// 保存校准参数
void save_calibration() {
  // 保存零点值到SRAM
  uint8_t *zero_ptr = (uint8_t*)ZERO_ADDR;
  *(float*)zero_ptr = zero_val;
  
  // 保存比例因子到SRAM
  uint8_t *scale_ptr = (uint8_t*)SCALE_ADDR;
  *(float*)scale_ptr = scale_factor;
}

// 零点校准
void calibrate_zero() {
  // 10次采样平均
  float sum = 0;
  for (uint8_t i = 0; i < 10; i++) {
    sum += (float)read_adc();
    _delay_ms(10);
  }
  zero_val = sum / 10.0f;
  
  save_calibration();
}

// 重量校准
void calibrate_weight(float known_weight) {
  // 10次采样平均
  float sum = 0;
  for (uint8_t i = 0; i < 10; i++) {
    sum += (float)read_adc();
    _delay_ms(10);
  }
  float ref_val = sum / 10.0f;
  
  scale_factor = (ref_val - zero_val) / known_weight;
  save_calibration();
}

// 获取重量（带滤波）
float get_weight() {
  // 移动平均滤波
  static float filter_buffer[5] = {0};
  static uint8_t index = 0;
  
  float raw_val = (float)read_adc() - zero_val;
  
  filter_buffer[index] = raw_val;
  index = (index + 1) % 5;
  
  float sum = 0;
  for (uint8_t i = 0; i < 5; i++) {
    sum += filter_buffer[i];
  }
  
  return (sum / 5.0f) / scale_factor;
}

// 主函数
void main() {
  // 初始化
  MISC = 0b00000010; // IHRC 16MHz
  CLKMD = 0b00100000;
  while (!(CLKMD & 0b00000001));
  
  init_adc();
  read_calibration();
  
  // 主循环
  while (1) {
    float weight = get_weight();
    
    // 显示重量逻辑
    // ...
    
    _delay_ms(100);
  }
}

// 直接驱动电机振动
void motor_control(uint8_t power) {
    set_pwm(PB7, power); // PB7输出PWM（0-100%）
}

void adjust_brightness() {
    uint16_t light = read_adc(LIGHT_SENSOR);
    uint8_t pwm = (light < LIGHT_THRESH) ? MAX_BRIGHT : (light / SCALE_FACTOR);
    set_pwm(LED_PIN, pwm);
}

#include
#include

// SPI定义
#define SPI_CLK  PA0
#define SPI_MOSI PA1
#define SPI_MISO PA2
#define SPI_CS   PA3

// 传感器命令
#define CMD_START_MEASURE 0x01
#define CMD_READ_DATA     0x02

// SPI初始化
void spi_init() {
  // 设置引脚方向
  PAC |= (1 << SPI_CLK) | (1 << SPI_MOSI) | (1 << SPI_CS); // 输出
  PAC &= ~(1 << SPI_MISO); // 输入
  
  // 初始状态
  PA |= (1 << SPI_CS);   // CS高电平（不选中）
  PA &= ~(1 << SPI_CLK); // 时钟低电平
}

// SPI发送接收字节
uint8_t spi_transfer(uint8_t data) {
  uint8_t received = 0;
  
  // 片选使能
  PA &= ~(1 << SPI_CS);
  _delay_us(1);
  
  for (uint8_t i = 0; i < 8; i++) {
    // 设置MOSI
    if (data & 0x80) {
      PA |= (1 << SPI_MOSI);
    } else {
      PA &= ~(1 << SPI_MOSI);
    }
    data <<= 1;
    
    // 时钟上升沿
    PA |= (1 << SPI_CLK);
    _delay_us(1);
    
    // 读取MISO
    received <<= 1;
    if (PA & (1 << SPI_MISO)) {
      received |= 0x01;
    }
    
    // 时钟下降沿
    PA &= ~(1 << SPI_CLK);
    _delay_us(1);
  }
  
  // 片选禁用
  PA |= (1 << SPI_CS);
  
  return received;
}

// 启动测量
void start_measurement() {
  spi_transfer(CMD_START_MEASURE);
  _delay_ms(10); // 等待传感器准备
}

// 读取血氧数据
void read_oxygen_data(uint16_t *heart_rate, uint16_t *spo2) {
  spi_transfer(CMD_READ_DATA);
  
  uint8_t data[4] = {0};
  for (uint8_t i = 0; i < 4; i++) {
    data[i] = spi_transfer(0x00);
  }
  
  *heart_rate = (data[0] << 8) | data[1];
  *spo2 = (data[2] << 8) | data[3];
}

// 计算血氧饱和度
uint8_t calculate_spo2(uint16_t spo2_value) {
  // 传感器特定校准公式
  return (spo2_value * 0.8) + 20; // 示例公式
}

// 主函数
void main() {
  // 初始化
  MISC = 0b00000010; // IHRC 16MHz
  CLKMD = 0b00100000;
  while (!(CLKMD & 0b00000001));
  
  spi_init();
  
  // 启动测量
  start_measurement();
  
  // 主循环
  while (1) {
    uint16_t heart_rate, spo2_value;
    read_oxygen_data(&heart_rate, &spo2_value);
    
    uint8_t spo2 = calculate_spo2(spo2_value);
    
    // 数据处理和传输
    // ...
    
    _delay_ms(500); // 每500ms读取一次
  }
}

easypdkprog -n PFS154 write blink.ihx # 烧录LED闪烁固件

#include
#include

// 硬件定义
#define LED_PIN      PA4
#define BUTTON_PIN   PA3

// 精确延时函数（ms）
void delay_ms(uint16_t ms) {
  // 使用Timer0实现精确延时
  TM0C = 0b00000000; // 系统时钟，无分频
  TM0S = 0b00000000; // 分频器1:1
  TM0B = 0;          // 比较值
  
  for (uint16_t i = 0; i < ms; i++) {
    TM0CT = 0; // 计数器清零
    TM0C |= 0b01000000; // 启用Timer0
    
    // 等待1ms (16MHz时钟)
    while (TM0CT < 16000); // 16000 cycles = 1ms
    
    TM0C &= ~0b01000000; // 禁用Timer0
  }
}

// 按钮检测（带防抖）
uint8_t is_button_pressed() {
  static uint8_t last_state = 1;
  static uint16_t debounce_timer = 0;
  
  uint8_t current_state = PA & (1 << BUTTON_PIN) ? 1 : 0;
  
  if (current_state != last_state) {
    debounce_timer = 500; // 50ms防抖时间
  }
  
  if (debounce_timer > 0) {
    debounce_timer--;
    if (debounce_timer == 0) {
      last_state = current_state;
      return (current_state == 0); // 按钮按下返回1
    }
  }
  
  return 0;
}

// 主函数
void main() {
  // 时钟初始化
  MISC = 0b00000010; // IHRC 16MHz
  CLKMD = 0b00100000;
  while (!(CLKMD & 0b00000001)); // 等待时钟稳定
  
  // 设置LED引脚为输出
  PAC |= (1 << LED_PIN);
  
  // 设置按钮引脚为输入（带上拉）
  PAC &= ~(1 << BUTTON_PIN);
  PAPH |= (1 << BUTTON_PIN); // 上拉电阻
  
  uint8_t blink_speed = 1; // 默认闪烁速度
  uint16_t delay_time = 500; // ms
  
  // 主循环
  while (1) {
    // 检测按钮
    if (is_button_pressed()) {
      blink_speed = (blink_speed % 3) + 1; // 切换速度1-3
      
      switch (blink_speed) {
        case 1: delay_time = 500; break; // 慢速
        case 2: delay_time = 250; break; // 中速
        case 3: delay_time = 100; break; // 快速
      }
    }
    
    // LED闪烁
    PA ^= (1 << LED_PIN); // 翻转LED
    delay_ms(delay_time);
  }
}

sdcc -mpdk14 -c blink.c && sdld -mpdk14 blink.rel5