STM32 相关函数学习 “mbed.h“库

1.mbed GPIO: DigitalIn,DigitalOut

mode有三种方式：pullup，pulldown，pullnone

#include "mbed.h"                  // 引入 Mbed 库

DigitalIn mypin(SW2, PullUp);    // 创建数字输入对象 mypin，连接到 SW2 引脚，并设置为上拉模式，上拉模式保持为高电平 1
DigitalOut myled(LED_A);         // 创建数字输出对象 myled，连接到 LED_A 引脚

void main(void) {                 // 主函数
    long long i = 0;             // 定义长整型变量 i，初始化为 0，用作计数器
    long long j = 0;             // 定义长整型变量 j，初始化为 0，跟踪输入状态变化

    mypin.mode(PullDown);        // 设置 mypin 的模式为下拉，未按下时为低电平（0）

    while(1) {                   // 无限循环
        i++;                      // 每次循环 i 自增 1

        j += (mypin == 1) ? 1 : -1; // 根据 mypin 的状态更新 j，若为高（1）则 j 加 1，低（0）则 j 减 1

        myled = mypin;           // 将 mypin 的状态直接赋值给 myled，控制 LED 状态

        myled.write(mypin.read()); // 读取 mypin 的状态并写入 myled（实际是多余的）
    }
}

2.mbed GPIO: BusIn,BusOut

#include "mbed.h"

// 定义输入引脚（开关）
BusIn switches(p5, p6, p7, p8);

// 定义输出引脚（LED）
BusOut leds(p9, p10, p11, p12);

int main() {
    // 初始化 LED 状态为 OFF
    leds = 0;

    while (true) {
        // 读取开关状态
        int switch_state = switches;

        // 更新 LED 状态
        leds = switch_state;

        // 添加延迟，避免过快循环
        wait(0.1);
    }
}

3.mbed DAC: AnalogIn,AnalogOut（模拟信号输入输出）

AnalogIn 是 Mbed 库中的一个类，用于读取模拟输入信号。具体来说，AnalogIn 类用于从指定的模拟引脚获取模拟电压值，例如来自传感器或其他电路组件的信号。

#include "mbed.h"  // 引入 Mbed OS 库

// 创建一个 AnalogIn 对象，使用 A0 引脚作为模拟输入
AnalogIn input(A0);  

// 主函数
int main(void) {  
    // 创建一个数组来存储采样数据，大小为 1024
    uint16_t samples[1024];  

    // 循环 1024 次以读取样本
    for (int i = 0; i < 1024; i++) {
        // 从模拟输入读取一个 16 位无符号整数值，并存储到数组中
        samples[i] = input.read_u16();  
        
        // 暂停 1 毫秒，以设置采样间隔（即采样频率控制）
        ThisThread::sleep_for(1);  
    }

    // 在这里可以添加代码处理采集到的样本
}

4.mbed IRQ: InterruptIn（中断监测）

void rise(void (*handler)(void)) void fall(void (*handler)(void)),这里有两个函数用于中断，下降沿（即按钮被按下）和上升沿。

#include "mbed.h"  // 引入 Mbed OS 库

// 创建一个 InterruptIn 对象，用于处理连接到 p28 引脚的按钮输入
InterruptIn mypin(p28);  

// 创建一个 BusOut 对象，控制四个 LED 灯（LED_A, LED_B, LED_C, LED_D）
BusOut myleds(LED_A, LED_B, LED_C, LED_D);  

// 中断处理函数，当按钮被按下时调用
void mypin_handler(void) { 
    myleds = myleds + 1;  // 将当前 LED 状态加一
}

// 主函数
void main(void) {
    mypin.mode(PullUp);  // 设置 mypin 的模式为上拉输入
    mypin.fall(mypin_handler); // 当 mypin 下降沿触发时调用 mypin_handler 函数
    myleds = 0;  // 初始化 LED 状态为 0（全熄灭）

    while(true) {  // 无限循环
        // 空循环，等待中断触发
    }
}

4.Timer(检测时间值)

1. void start(): 启动定时器，从当前时间开始计时。

2. void stop(): 停止定时器，停止计时并保留当前计时值。

3. void reset(): 重置定时器，将计时值设置为零。

4. float read(): 返回自定时器启动以来经过的时间（以秒为单位）。

5. int read_ms(): 返回自定时器启动以来经过的时间（以毫秒为单位）。

6. int read_us(): 返回自定时器启动以来经过的时间（以微秒为单位）。

7. std::chrono::microseconds elapsed_time(): 返回一个 std::chrono::microseconds 类型的对象，表示自定时器启动以来经过的时间。

8. operator float(): 允许将 Timer 对象转换为 float，表示经过的时间（以秒为单位）。

9. #include "mbed.h"
   
   DigitalOut led(LED1); // 定义一个 LED 输出
   Timer timer;          // 创建 Timer 对象
   
   int main() {
       timer.start(); // 启动定时器
   
       // 模拟一些延迟操作
       wait(2.0); // 等待 2 秒
   
       timer.stop(); // 停止定时器
   
       // 读取经过的时间
       float elapsed_seconds = timer.read();
       int elapsed_milliseconds = timer.read_ms();
       int elapsed_microseconds = timer.read_us();
   
       // 打印结果
       printf("Elapsed time: %.2f seconds\n", elapsed_seconds);
       printf("Elapsed time: %d milliseconds\n", elapsed_milliseconds);
       printf("Elapsed time: %d microseconds\n", elapsed_microseconds);
   
       // 重置定时器并重新开始
       timer.reset();
       timer.start();
   
       // 再次模拟一些延迟
       wait(1.0); // 等待 1 秒
   
       // 获取新的经过时间
       auto elapsed = timer.elapsed_time(); // 使用 std::chrono
       printf("New elapsed time: %lld microseconds\n", elapsed.count());
   
       // 将 Timer 对象转换为 float
       float elapsed_float = (float)timer; 
       printf("Elapsed time using operator float: %.2f seconds\n", elapsed_float);
   
       while (true) {
           led = !led; // 切换 LED 状态
           wait(0.5); // 每 0.5 秒切换一次
       }
   }
   

   5.Ticker（定时器）

10. Ticker 类用于设置一个定期中断，用于执行某个函数。Ticker 可以用于周期性地执行任务，比如读取传感器数据或更新状态。

11. #include "mbed.h"
    
    DigitalOut led(LED1); // 定义一个 LED 输出
    Ticker ticker;        // 创建 Ticker 对象
    
    // 定时处理函数
    void toggle_led() {
        led = !led; // 切换 LED 状态
        printf("LED toggled!\n");
    }
    
    int main() {
        ticker.attach(toggle_led, 1.0); // 每隔 1 秒调用 toggle_led 函数
    
        // 主循环
        while (true) {
            // 在这里可以执行其他任务
            wait(5); // 每 5 秒打印一次信息
            printf("Main loop running...\n");
        }
    }
    

    5.Timeout（延时器）

#include "mbed.h"

DigitalOut led(LED1); // 定义一个 LED 输出

int main() {
    while (true) {
        led = 1; // 打开 LED
        ThisThread::sleep_for(500ms); // 等待 500 毫秒
        
        led = 0; // 关闭 LED
        ThisThread::sleep_for(500ms); // 等待 500 毫秒
    }
}

1. ThisThread::sleep_for(chrono::milliseconds(ms)):用于在多线程环境中暂停当前线程的执行，推荐使用。

2. void wait(float s):

   • 暂停执行指定的秒数。该函数已被弃用，建议使用更明确的睡眠函数。

3. void wait_ms(int ms):

   • 暂停执行指定的毫秒数。

4. void wait_us(int us):

   • 暂停执行指定的微秒数。

5.mbed PWM: PwmOut

PwmOut 类用于生成脉宽调制（PWM）信号。这可以用于控制电机速度、LED亮度等。

1. 脉冲宽度 (Pulse Width)：

   • 指PWM信号在一个周期内处于高电平的时间长度，通常用时间单位（如毫秒或微秒）表示。

2. 占空比 (Duty Cycle)：

   • 表示高电平时间与整个周期时间的比例，通常以百分比表示。
   • 计算公式为：

     

3. PWM频率 (Frequency)：

   • 指PWM信号每秒钟循环的次数，单位为赫兹（Hz）。
   • 计算公式为：

     

举例：

• 一个1000 Hz的PWM信号，周期为1毫秒。假设占空比是30%，那么高电平持续0.3毫秒，低电平持续0.7毫秒。

总结：

1. • 频率决定了PWM信号的响应速度，比如控制电机的转速或亮度时，频率过低可能会导致不平滑的输出。
   • 占空比则直接影响功率的输送，比如LED的亮度和电机的速度等。
2. PWM频率控制着信号的变化速度，而占空比则控制着在每个周期内信号的高低状态比例。两者结合使用，能够实现对设备的精确控制。

1. void period(float s):

   • 设置 PWM 周期，以秒为单位。例如，period(0.02) 设置周期为 20 毫秒。

2. void pulsewidth(float s):

   • 设置脉冲宽度，以秒为单位。

3. void write(float duty_cycle):

   • 设置占空比，范围从 0.0 到 1.0（0% 到 100%）。

4. operator=(float duty_cycle):

   • 支持通过赋值运算符设置占空比，功能与 write 相同。

5. float read():

   • 返回当前的占空比。

6. operator float():

   • 返回当前的占空比，支持隐式转换。

#include "mbed.h"

PwmOut led(PA_5); // 定义 PWM 输出引脚

int main() {
    led.period(0.02); // 设置周期为 20 毫秒

    while (true) {
        // 增加亮度
        for (float duty_cycle = 0.0; duty_cycle <= 1.0; duty_cycle += 0.1) {
            led.write(duty_cycle); // 设置占空比
            ThisThread::sleep_for(500ms); // 等待 500 毫秒
        }

        // 减少亮度
        for (float duty_cycle = 1.0; duty_cycle >= 0.0; duty_cycle -= 0.1) {
            led.write(duty_cycle); // 设置占空比
            ThisThread::sleep_for(500ms); // 等待 500 毫秒
        }
    }
}