3/5V继电器模块

# 3/5V继电器模块驱动代码例程

## 硬件连接

| 继电器模块 | MCU/开发板 |
|-----------|-----------|
| VCC | 5V（独立供电，勿从MCU 3.3V取电） |
| GND | GND（共地） |
| IN | GPIO D4 |

> 跳线帽设置为低电平触发（L）。

---

## 例程一：Arduino 基础驱动

```cpp
/*
 * 3/5V继电器模块 Arduino 驱动
 * 低电平触发模式
 * 硬件：IN → D4
 */

#define RELAY_PIN   4

// 触发模式定义（根据跳线帽设置）
#define TRIGGER_LOW    // 低电平触发 - 注释此行则切换为高电平触发

void setup() {
    pinMode(RELAY_PIN, OUTPUT);

#ifdef TRIGGER_LOW
    digitalWrite(RELAY_PIN, HIGH);  // 初始释放（低电平触发时初始为HIGH）
#else
    digitalWrite(RELAY_PIN, LOW);   // 初始释放（高电平触发时初始为LOW）
#endif

    Serial.begin(9600);
    Serial.println("继电器模块测试开始");
}

void loop() {
    relayOn();
    delay(2000);
    relayOff();
    delay(2000);
}

/* ====== 驱动函数 ====== */

/**
 * @brief 继电器吸合（NO与COM导通）
 */
void relayOn(void) {
#ifdef TRIGGER_LOW
    digitalWrite(RELAY_PIN, LOW);
#else
    digitalWrite(RELAY_PIN, HIGH);
#endif
    Serial.println("继电器: 吸合 (ON)");
}

/**
 * @brief 继电器释放（NO与COM断开）
 */
void relayOff(void) {
#ifdef TRIGGER_LOW
    digitalWrite(RELAY_PIN, HIGH);
#else
    digitalWrite(RELAY_PIN, LOW);
#endif
    Serial.println("继电器: 释放 (OFF)");
}

/**
 * @brief 继电器状态翻转
 */
void relayToggle(void) {
    digitalWrite(RELAY_PIN, !digitalRead(RELAY_PIN));
}

/**
 * @brief 读取继电器状态
 * @return true=吸合, false=释放
 */
bool relayGetState(void) {
#ifdef TRIGGER_LOW
    return (digitalRead(RELAY_PIN) == LOW);
#else
    return (digitalRead(RELAY_PIN) == HIGH);
#endif
}
```

---

## 例程二：Arduino 高级封装（类方式）

```cpp
/*
 * 继电器类封装 - 支持多路继电器
 */

class Relay {
private:
    uint8_t _pin;
    bool _activeLow;  // true=低电平触发, false=高电平触发

public:
    /**
     * @brief 构造函数
     * @param pin       GPIO引脚号
     * @param activeLow true=低电平触发, false=高电平触发
     */
    Relay(uint8_t pin, bool activeLow = true) {
        _pin = pin;
        _activeLow = activeLow;
        pinMode(_pin, OUTPUT);
        off();  // 初始释放
    }

    /** @brief 吸合 */
    void on() {
        digitalWrite(_pin, _activeLow ? LOW : HIGH);
    }

    /** @brief 释放 */
    void off() {
        digitalWrite(_pin, _activeLow ? HIGH : LOW);
    }

    /** @brief 翻转 */
    void toggle() {
        digitalWrite(_pin, !digitalRead(_pin));
    }

    /** @brief 获取状态 */
    bool isOn() {
        uint8_t val = digitalRead(_pin);
        return _activeLow ? (val == LOW) : (val == HIGH);
    }

    /**
     * @brief 脉冲吸合
     * @param ms 吸合时长(ms)
     */
    void pulse(uint32_t ms) {
        on();
        delay(ms);
        off();
    }
};

// ====== 使用示例 ======

Relay relay1(4, true);   // D4, 低电平触发
Relay relay2(5, true);   // D5, 低电平触发

void setup() {
    Serial.begin(9600);
}

void loop() {
    relay1.on();
    relay2.off();
    delay(3000);

    relay1.off();
    relay2.on();
    delay(3000);

    // 脉冲模式
    relay1.pulse(500);
    delay(500);
    relay2.pulse(500);
    delay(1000);
}
```

---

## 例程三：STM32 HAL 库驱动

```c
/*
 * 3/5V继电器模块 STM32 HAL 驱动
 * 低电平触发模式
 * 硬件：IN → PB0
 */

#include "main.h"

#define RELAY_GPIO_PORT    GPIOB
#define RELAY_GPIO_PIN     GPIO_PIN_0
#define RELAY_ACTIVE_LOW   1   // 1=低电平触发, 0=高电平触发

/**
 * @brief 继电器GPIO初始化
 */
void Relay_Init(void) {
    __HAL_RCC_GPIOB_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = RELAY_GPIO_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(RELAY_GPIO_PORT, &GPIO_InitStruct);

    Relay_Off();  // 初始释放
}

/**
 * @brief 继电器吸合
 */
void Relay_On(void) {
#if RELAY_ACTIVE_LOW
    HAL_GPIO_WritePin(RELAY_GPIO_PORT, RELAY_GPIO_PIN, GPIO_PIN_RESET);
#else
    HAL_GPIO_WritePin(RELAY_GPIO_PORT, RELAY_GPIO_PIN, GPIO_PIN_SET);
#endif
}

/**
 * @brief 继电器释放
 */
void Relay_Off(void) {
#if RELAY_ACTIVE_LOW
    HAL_GPIO_WritePin(RELAY_GPIO_PORT, RELAY_GPIO_PIN, GPIO_PIN_SET);
#else
    HAL_GPIO_WritePin(RELAY_GPIO_PORT, RELAY_GPIO_PIN, GPIO_PIN_RESET);
#endif
}

/**
 * @brief 继电器翻转
 */
void Relay_Toggle(void) {
    HAL_GPIO_TogglePin(RELAY_GPIO_PORT, RELAY_GPIO_PIN);
}

/**
 * @brief 获取继电器状态
 * @return 1=吸合, 0=释放
 */
uint8_t Relay_GetState(void) {
    GPIO_PinState state = HAL_GPIO_ReadPin(RELAY_GPIO_PORT, RELAY_GPIO_PIN);
#if RELAY_ACTIVE_LOW
    return (state == GPIO_PIN_RESET) ? 1 : 0;
#else
    return (state == GPIO_PIN_SET) ? 1 : 0;
#endif
}

/**
 * @brief 继电器脉冲吸合
 * @param ms 吸合时长(ms)
 */
void Relay_Pulse(uint32_t ms) {
    Relay_On();
    HAL_Delay(ms);
    Relay_Off();
}

/* ====== 使用示例 ====== */

int main(void) {
    HAL_Init();
    SystemClock_Config();
    Relay_Init();

    while (1) {
        Relay_On();
        HAL_Delay(2000);
        Relay_Off();
        HAL_Delay(2000);

        // 每秒翻转一次，模拟闪烁
        for (int i = 0; i < 5; i++) {
            Relay_Toggle();
            HAL_Delay(1000);
        }
    }
}
```

---

## 例程四：ESP8266 (Arduino) + MQTT 远程控制

```cpp
/*
 * ESP8266 + 继电器模块 MQTT 远程控制
 * 硬件：IN → D4 (GPIO4)
 */

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

#define RELAY_PIN      4      // D2 = GPIO4
#define RELAY_ACTIVE_LOW true

const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_PASS";
const char* mqtt_server = "192.168.1.100";
const char* topic = "home/relay/switch";

WiFiClient espClient;
PubSubClient client(espClient);

class Relay {
private:
    uint8_t _pin;
    bool _activeLow;

public:
    Relay(uint8_t pin, bool activeLow) : _pin(pin), _activeLow(activeLow) {
        pinMode(_pin, OUTPUT);
        off();
    }

    void on()  { digitalWrite(_pin, _activeLow ? LOW : HIGH); }
    void off() { digitalWrite(_pin, _activeLow ? HIGH : LOW); }
    bool isOn() { return digitalRead(_pin) == (_activeLow ? LOW : HIGH); }
};

Relay relay(RELAY_PIN, RELAY_ACTIVE_LOW);

void mqttCallback(char* topic, byte* payload, unsigned int length) {
    payload[length] = '\0';
    String msg = String((char*)payload);

    if (msg == "ON") {
        relay.on();
        client.publish("home/relay/state", "ON");
    } else if (msg == "OFF") {
        relay.off();
        client.publish("home/relay/state", "OFF");
    } else if (msg == "TOGGLE") {
        relay.isOn() ? relay.off() : relay.on();
        client.publish("home/relay/state", relay.isOn() ? "ON" : "OFF");
    }
}

void reconnectMQTT() {
    while (!client.connected()) {
        if (client.connect("ESP8266_Relay")) {
            client.subscribe(topic);
        } else {
            delay(5000);
        }
    }
}

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) delay(500);

    client.setServer(mqtt_server, 1883);
    client.setCallback(mqttCallback);
}

void loop() {
    if (!client.connected()) reconnectMQTT();
    client.loop();
}
```