点灯科技blinker控制四路继电器

📦 项目简介#

本项目实现了通过 点灯科技 Blinker App，远程控制一个淘宝购买的 四路继电器模块（LC-Relay-ESP01-4R-12V）。它基于 ESP8266-01 模块，适合智能家居、遥控开关等场景。

✅ 实现功能：手机远程控制 1-4 路继电器的开关

🔀 准备材料#

名称	说明
LC-Relay-ESP01-4R-12V	四路继电器模块，支持 ESP-01s，ESP-01
ESP8266-01 模块	带 WiFi 功能，插入继电器模块上
12V 直流电源	继电器供电，注意极性
安卓/iOS 手机	安装 Blinker App
杜邦线/USB转串口模块，C341	如需刷写固件

LC-Relay-ESP01-4R-12V 四路继电器模块

微信图片_20250701121729

usb烧录器

建议使用这种插入式烧录器接线麻烦了

微信图片_20250701121729

📱 第一步：配置 Blinker App#

打开 Blinker App，注册并登录；
添加设备，选择点灯-独立设备：
- 接入方式：网络接入；
创建完后，进入设备-点击设置复制 设备密钥（authKey），稍后在代码中使用；
拖入四个开关按钮 Widget，分别命名为 b1 ~ b4；
点击“保存”。

🔧 第二步：准备固件代码#

使用 Arduino IDE 编写以下程序并烧录至 ESP-01 模块：

✅ 下载串口驱动#

C341驱动

✅ 安装库#

下载 Blinker 库，选择Arduino (C++)下载
打开 Arduino IDE文件-首选项-设置开发板管理地址，任意一个都可以

1
https://arduino.me/packages/esp8266.json
2
https://arduino.esp8266.com/stable/package_esp8266com_index.json

导入Blinker 库
板子选择：Generic ESP8266 Module

✅ 四路继电器代码#

1
//1.默认！在#include <Blinker.h>前定义点灯库通信方式为WiFi
2
#define BLINKER_WIFI  //定义点灯库通信模式，必须加在#include <Blinker.h>前! 以保证编译器对代码进行预处理时能够包含正确的库代码组合
3
#define BLINKER_MIOT_MULTI_OUTLET  // 新增：支持米家多插座
4

5
//2.必须填写！参考说明书第五节
6

7
//没有硬件请注释掉该行
8
#define RELAYPIN_1 0  //定义继电器1在8266芯片的引脚GPIO0，对应NodeMCU开发板D3
9
#define RELAYPIN_2 2  //定义继电器2在8266芯片的引脚GPIO2，对应NodeMCU开发板D4
10
#define RELAYPIN_3 4  //定义继电器3在8266芯片的引脚GPIO4，对应NodeMCU开发板D2
11
#define RELAYPIN_4 5  //定义继电器4在8266芯片的引脚GPIO5，对应NodeMCU开发板D1
12
//#define SELF_LOCK     //焊接自复位按钮注释掉本句，焊接自锁开关取消注释
13
// #define BUTTONPIN 3 //实体开关，定义后检测IO3（RX），低电平则调用按钮1回调翻转一次灯状态
14
/****************************************
15
   预处理命令——软件库包含
16
****************************************/
17
#include <Blinker.h>  //包含点灯库，编译器根据“宏定义的通信方式、工具中选择的开发板”来选择合适的端口定义、顶层调度函数、底层适配函数
18

19
/****************************************
20
   声明——全局变量
21
****************************************/
22
//必须修改！参考说明书第四节
23
char auth[] = "你的Blinker授权码";     // 替换为你的授权码
24
char ssid[] = "你的WiFi名称";          // 替换为你的WiFi
25
char pswd[] = "你的WiFi密码";          // 替换为你的密码
26

27
bool button1_state = false;   //                   按钮1状态
28
bool button2_state = false;  //                   按钮2状态
29
bool button3_state = false;   //                   按钮3状态
30
bool button4_state = false;  //                   按钮4状态
31

32
bool oState[4] = { false, false, false, false }; // 新增：多路插座状态数组，4路
33

34
uint32_t hebt_time = 0;        //心跳包持续强制发送变量
35
uint32_t hebt_time_limit = 0;  //心跳包发送周期限制，时间戳变量
36

37

38
/****************************************
39
   定义——功能函数
40

41
   7.(1)按钮1回调函数(基于Arduino>文件>示例>鼠标滚轮往下滚>第三方库示例>Blinker>Blinker_Widgets>Blinker_Button>Botton_Wifi)
42
   7.(2)按钮2回调函数
43
   8.用户心跳包回调函数(基于Blinker库自带的心跳包函数，官方教程https://arduino.me/s/blinker-arduino?aid=711官方说明见https://diandeng.tech/doc/arduino-support#%E5%BF%83%E8%B7%B3%E5%8C%85heartbeat的心跳包小节)
44
   11.主函数初始化部分setup(执行一次)
45
   12.主函数循环执行部分loop(循环到关机)
46
****************************************/
47

48
#if defined(RELAYPIN_1)
49

50
void button1_callback(const String& state);  //按钮1回调函数声明
51
//下面这句是类库实例化语句，类名BlinkerButton（按钮组件类），实例名Button1，数据键名“b1”，当blinker.run检测到APP发来数据包含键名“b1”就调用回调button1_callback。
52
BlinkerButton Button1("b1", button1_callback);  //用此句不需要在setup里attach回调了
53
void button1_callback(const String& state)      //按钮1回调函数定义，按下后设备开启继电器1
54
{
55
  if (state == "tap") {
56
    button1_state = !button1_state;  //普通按键：tap反转状态
57
  } else if (state == "on") {
58
    button1_state = true;  //开关按键：on 短按开启
59
  } else if (state == "off") {
60
    button1_state = false;  //开关按键：off短按关闭
61
  } else if (state == "press") {
62
    button1_state = true;  //普通按键或开关按键：press长按开启
63
  } else if (state == "pressup") {
64
    button1_state = false;  //普通按键或开关按键：pressup松开关闭
65
  }
66

67
  Button1.print(button1_state ? "on" : "off");  //立即反馈状态到APP
68

69
  digitalWrite(RELAYPIN_1, !button1_state);     //IO输出到继电器
70
    Serial.write(0xA0);                         //串口输出到继电器
71
    Serial.write(0x01);
72
    Serial.write(button1_state?0x01:0x00);
73
    Serial.write(button1_state?0xA2:0xA1);
74

75
  // 新增：同步oState[0]状态
76
  oState[0] = button1_state;
77
}
78
#endif
79
#if defined(RELAYPIN_2)
80
BlinkerButton Button2("b2", button2_callback);  //类库实例化语句，类名BlinkerButton按钮组件，实例名Button2，组件键名“b2”
81
void button2_callback(const String& state)      //7.(2)按钮2回调函数，按下后设备开启继电器2
82
{
83
  if (state == "tap") {
84
    button2_state = !button2_state;  //普通按键：tap反转状态
85
  } else if (state == "on") {
86
    button2_state = true;  //开关按键：on 短按开启
87
  } else if (state == "off") {
88
    button2_state = false;  //开关按键：off短按关闭
89
  } else if (state == "press") {
90
    button2_state = true;  //普通按键或开关按键：press长按开启
91
  } else if (state == "pressup") {
92
    button2_state = false;  //普通按键或开关按键：pressup松开关闭
93
  }
94
  Button2.print(button2_state ? "on" : "off");  //反馈状态到APP
95
    digitalWrite(RELAYPIN_2, !button2_state);//IO输出到继电器
96
    Serial.write(0xA0);                        //串口输出到继电器
97
    Serial.write(0x02);
98
    Serial.write(button2_state?0x01:0x00);
99
    Serial.write(button2_state?0xA3:0xA2);
100

101
  // 新增：同步oState[1]状态
102
  oState[1] = button2_state;
103
}
104
#endif
105
#if defined(RELAYPIN_3)
106
BlinkerButton Button3("b3", button3_callback);  //类库实例化语句，类名BlinkerButton按钮组件，实例名Button3，组件键名“b3”
107
void button3_callback(const String& state)      //7.(3)按钮3回调函数，按下后设备开启继电器3
108
{
109
  if (state == "tap") {
110
    button3_state = !button3_state;  //普通按键：tap反转状态
111
  } else if (state == "on") {
112
    button3_state = true;  //开关按键：on 短按开启
113
  } else if (state == "off") {
114
    button3_state = false;  //开关按键：off短按关闭
115
  } else if (state == "press") {
116
    button3_state = true;  //普通按键或开关按键：press长按开启
117
  } else if (state == "pressup") {
118
    button3_state = false;  //普通按键或开关按键：pressup松开关闭
119
  }
120
  Button3.print(button3_state ? "on" : "off");  //反馈状态到APP
121
    digitalWrite(RELAYPIN_3, !button3_state);//IO输出到继电器
122
    Serial.write(0xA0);                        //串口输出到继电器
123
    Serial.write(0x03);
124
    Serial.write(button3_state?0x01:0x00);
125
    Serial.write(button3_state?0xA4:0xA3);
126

127
  // 新增：同步oState[2]状态
128
  oState[2] = button3_state;
129
}
130
#endif
131
#if defined(RELAYPIN_4)
132
BlinkerButton Button4("b4", button4_callback);  //类库实例化语句，类名BlinkerButton按钮组件，实例名Button4，组件键名“b4”
133
void button4_callback(const String& state)      //7.(4)按钮4回调函数，按下后设备开启继电器4
134
{
135
  if (state == "tap") {
136
    button4_state = !button4_state;  //普通按键：tap反转状态
137
  } else if (state == "on") {
138
    button4_state = true;  //开关按键：on 短按开启
139
  } else if (state == "off") {
140
    button4_state = false;  //开关按键：off短按关闭
141
  } else if (state == "press") {
142
    button4_state = true;  //普通按键或开关按键：press长按开启
143
  } else if (state == "pressup") {
144
    button4_state = false;  //普通按键或开关按键：pressup松开关闭
145
  }
146
  Button4.print(button4_state ? "on" : "off");  //反馈状态到APP
147
    digitalWrite(RELAYPIN_4, !button4_state);//IO输出到继电器
148
    Serial.write(0xA0);                        //串口输出到继电器
149
    Serial.write(0x04);
150
    Serial.write(button4_state?0x01:0x00);
151
    Serial.write(button4_state?0xA5:0xA4);
152

153
  // 新增：同步oState[3]状态
154
  oState[3] = button4_state;
155
}
156
#endif
157

158
// 新增：米家多插座回调函数
159
void miotPowerState(const String & state, uint8_t num)
160
{
161
    if (num >= 4) return; // 只支持4路
162
    BLINKER_LOG("need set outlet: ", num, ", power state: ", state);
163

164
    if (state == BLINKER_CMD_ON) {
165
        oState[num] = true;
166
    }
167
    else if (state == BLINKER_CMD_OFF) {
168
        oState[num] = false;
169
    }
170

171
    // 控制对应继电器
172
    switch(num) {
173
      case 0:
174
        button1_state = oState[0];
175
        digitalWrite(RELAYPIN_1, !oState[0]);
176
        Button1.print(oState[0] ? "on" : "off");
177
        break;
178
      case 1:
179
        button2_state = oState[1];
180
        digitalWrite(RELAYPIN_2, !oState[1]);
181
        Button2.print(oState[1] ? "on" : "off");
182
        break;
183
      case 2:
184
        button3_state = oState[2];
185
        digitalWrite(RELAYPIN_3, !oState[2]);
186
        Button3.print(oState[2] ? "on" : "off");
187
        break;
188
      case 3:
189
        button4_state = oState[3];
190
        digitalWrite(RELAYPIN_4, !oState[3]);
191
        Button4.print(oState[3] ? "on" : "off");
192
        break;
193
    }
194

195
    BlinkerMIOT.powerState(oState[num] ? "on" : "off", num);
196
    BlinkerMIOT.print();
197
}
198

199
void miotQuery(int32_t queryCode, uint8_t num)
200
{
201
    if (num >= 4) return;
202
    BLINKER_LOG("MIOT Query outlet: ", num,", codes: ", queryCode);
203

204
    switch (queryCode)
205
    {
206
        case BLINKER_CMD_QUERY_ALL_NUMBER :
207
        case BLINKER_CMD_QUERY_POWERSTATE_NUMBER :
208
        default :
209
            BlinkerMIOT.powerState(oState[num] ? "on" : "off", num);
210
            BlinkerMIOT.print();
211
            break;
212
    }
213
}
214

215
void heartbeat()  //8.用户心跳包回调函数(APP定时向设备发送心跳包请求{"get":"state"}，设备默认返回{"state":"online"},若用户有自定义状态需要在收到心跳包时返回, 可声明并在setup()中注册此回调函数)
216
{
217
#if defined(RELAYPIN_1)  //当定义继电器1引脚，编译以下语句
218
  button1_callback("");  //按钮1状态返回
219
#endif
220
#if defined(RELAYPIN_2)  //当定义继电器2引脚，编译以下语句
221
  button2_callback("");  //按钮2状态返回
222
#endif
223
#if defined(RELAYPIN_3)  //当定义继电器3引脚，编译以下语句
224
  button3_callback("");  //按钮3状态返回
225
#endif
226
#if defined(RELAYPIN_4)  //当定义继电器4引脚，编译以下语句
227
  button4_callback("");  //按钮4状态返回
228
#endif
229
}
230
//11.实体按钮处理函数
231
#if defined(BUTTONPIN)    //若定义实体按钮则编译以下语句
232
#define KEY_NO   0  //无按键状态，用于判断是否按下
233
#define KEY_DOWN 1  //有按键按下状态，判断是否为抖动
234
#define KEY_UP   2  //等待松手状态，判断是否弹起
235
int key_state = 0;
236
uint32_t tap_time = 0;        //                   实体按钮切换限制的时间戳，初始化为0
237
void BUTTON_Read(void)
238
{
239
#if defined(SELF_LOCK)//实体开关状态机法（自锁开关）
240
  switch (key_state)
241
  {
242
    case KEY_NO:                    //无按键状态，用于判断是否按下
243
      if (!digitalRead(BUTTONPIN)) key_state = KEY_DOWN;
244
      break;
245

246
    case KEY_DOWN:                  //有按键按下状态，判断是否为抖动
247
      if (!digitalRead(BUTTONPIN) && millis() - tap_time > 10) //非抖动则按下
248
      {
249
        button1_callback(button1_state ? "off" : "on");
250
        tap_time = millis();
251
        key_state = KEY_UP;
252
      }
253
      else
254
        key_state = KEY_NO;     //抖动判定为没按下
255
      break;
256

257
    case KEY_UP:                    //等待松手状态，判断是否弹起
258
      if (digitalRead(BUTTONPIN))
259
      {
260
        button1_callback(button1_state ? "off" : "on");
261
        key_state = KEY_NO;
262
      }
263
      break;
264
  }
265
#else//实体按钮状态机法（自复位开关）
266
  switch (key_state)
267
  {
268
    case KEY_NO:                    //无按键状态，用于判断是否按下
269
      if (!digitalRead(BUTTONPIN)) key_state = KEY_DOWN;
270
      break;
271
    case KEY_DOWN:                  //有按键按下状态，判断是否为抖动
272
      if (!digitalRead(BUTTONPIN) && millis() - tap_time > 10) //非抖动则按下
273
      {
274
        button1_callback("tap");
275
        tap_time = millis();
276
        key_state = KEY_UP;
277
      }
278
      else
279
        key_state = KEY_NO;         //抖动判定为没按下
280
      break;
281
    case KEY_UP:                    //等待松手状态，判断是否弹起
282
      if (digitalRead(BUTTONPIN)) key_state = KEY_NO;
283
      break;
284
  }
285
  //非状态机法
286
  //if(!digitalRead(BUTTONPIN) &&millis()-tap_time>500){button1_callback("tap");tap_time=millis();}//每500ms检测一次按钮
287
#endif
288
}
289
#endif
290
void setup()  //13.主函数初始化部分(开机引导后第一个执行此函数)
291
{
292
#if defined(BUTTONPIN)//当定义实体开关，编译以下语句
293
  pinMode(BUTTONPIN, INPUT_PULLUP);       //实体按钮引脚设置为上拉输入
294
  if (!digitalRead(BUTTONPIN)) key_state = KEY_UP; else key_state = KEY_DOWN; //初始低则等高，初始高则等低
295
#endif
296

297
  Serial.begin(115200);           //初始化硬件串口UART0波特率115200bps(调试时需要相应的调整Aruino>工具>串口监视器>波特率为115200)
298
  BLINKER_DEBUG.stream(Serial);  //将Blinker库代码调试信息流打印到硬件串口
299
  BLINKER_DEBUG.debugAll();      //开启所有调试信息
300

301
  Blinker.begin(auth, ssid, pswd);  //调用Blinker库的开始成员函数，初始化Wifi连接(参数：授权码、WiFi名、密码)
302
  Blinker.attachHeartbeat(heartbeat);  //注册用户心跳包回调函数，Blinker库代码每30秒发送心跳包时会顺带执行此函数(此函数不用返回任何值)
303

304
  // 新增：注册米家多插座回调
305
  BlinkerMIOT.attachPowerState(miotPowerState);
306
  BlinkerMIOT.attachQuery(miotQuery);
307
}
308
 uint32_t offline_millis = 0;//掉线计时
309
 bool offline_flag = false;  //掉线状态
310
void loop()  //14.主函数循环执行部分(初始化后循环执行此函数直至断电)
311
{
312
  Blinker.run();          //运行一下Blinker库代码(库代码确认没有消息收发需求时将自动暂停，执行后方用户代码)(刚开机会先连HTTP服务器鉴权然后用鉴权信息登录MQTT服务器后才能与APP通信)
313
  if (Blinker.connect())  //调用一下Blinker库的连接检测函数，若检测到MQTT服务器连接成功则执行以下用户代码
314
  {
315
    offline_millis = 0;
316
    offline_flag = false;  //在线，清空掉线状态
317
    //用户代码放这里：*****************************************************************************
318

319
  } else if (!Blinker.connected() && millis() > 180000)  //开机三分钟后，点灯库一旦连不上，就判掉线，触发一次
320
  {
321
    offline_flag = true;  //Blinker.connected()触发标志
322
  }
323
  if (millis() > 180000 && !offline_millis && offline_flag)  //开机后三分钟后，若触发，则记录第一次掉线时间，之后!offline_millis为假，不再触发
324
  {
325
    offline_flag = false;       //Blinker.connected()触发取消
326
    offline_millis = millis();  //记录掉线时间戳后!offline_millis为假，不再触发
327
  }
328
  if (millis() > 180000 && offline_millis && millis() - offline_millis >= 180000)  //开机三分钟后，掉线时间戳不为0，出现三分钟以上断连就重启
329
  {
330
    BLINKER_LOG_ALL(BLINKER_F("******************************************Reatart***************************************"));  //串口打印重启消息
331

332
#if defined(ESP32)
333
    ESP.restart();  //ESP32 重启
334
#elif defined(ESP8266)
335
    ESP.reset();  //ESP8266 硬件重启
336
#endif
337
  }
338
#if defined(BUTTONPIN)    //若定义实体按钮则编译以下语句
339
  if (millis() > 3000)BUTTON_Read();
340
#endif
341

342
}

✅ 一路继电器代码#

1
#define BLINKER_WIFI
2
#define BLINKER_MIOT_OUTLET  // 支持小爱同学控制开关设备
3

4
#include <Blinker.h>
5

6
char auth[] = "你的Blinker授权码";     // 替换为你的授权码
7
char ssid[] = "你的WiFi名称";          // 替换为你的WiFi
8
char pswd[] = "你的WiFi密码";          // 替换为你的密码
9

10
#define RELAY_PIN 0  // ESP-01 可用 GPIO0
11

12
bool relayState = false;  // 当前继电器状态
13
BlinkerButton Button1("btn-relay");  // Blinker App 中的按钮组件
14

15
// 小爱同学语音控制回调
16
void miotPowerState(const String &state) {
17
    BLINKER_LOG("MIOT power state: ", state);
18

19
    if (state == BLINKER_CMD_ON) {
20
        digitalWrite(RELAY_PIN, LOW);  // 低电平触发：打开
21
        relayState = true;
22
        BlinkerMIOT.powerState("on");
23
    } else if (state == BLINKER_CMD_OFF) {
24
        digitalWrite(RELAY_PIN, HIGH); // 高电平：关闭
25
        relayState = false;
26
        BlinkerMIOT.powerState("off");
27
    }
28

29
    BlinkerMIOT.print();  // 反馈状态给小爱
30
}
31

32
// App 按钮控制回调
33
void button1_callback(const String &state) {
34
    BLINKER_LOG("App button state: ", state);
35

36
    if (state == BLINKER_CMD_ON) {
37
        digitalWrite(RELAY_PIN, LOW);
38
        relayState = true;
39
    } else if (state == BLINKER_CMD_OFF) {
40
        digitalWrite(RELAY_PIN, HIGH);
41
        relayState = false;
42
    }
43

44
    Button1.print(relayState ? "on" : "off");
45
}
46

47
void setup() {
48
    Serial.begin(115200);
49
    pinMode(RELAY_PIN, OUTPUT);
50
    digitalWrite(RELAY_PIN, HIGH);  // 初始为关闭（高电平）
51

52
    Blinker.begin(auth, ssid, pswd);
53
    Button1.attach(button1_callback);
54
    BlinkerMIOT.attachPowerState(miotPowerState);
55
}
56

57
void loop() {
58
    Blinker.run();
59
}

⚠️ 注意：ESP-01 只有 GPIO0 和 GPIO2 稳定可用，GPIO1 是串口 TX，GPIO3 是 RX，使用时需谨慎或更换 ESP-12F。

🔌 第三步：模块连接图(TTL下载器)#

ESP01 引脚	串口烧录器
RX	TXD
3V3	VCC
IO0	GDN
TX	RXD
GND	GND

✅ 若使用 ESP-12F 模块，可以稳定使用 4 个 GPIO 引脚控制 4 路继电器。

🚀 第四步：烧录和测试#

使用 USB 转串口模块将 ESP-01 与电脑连接；
选择正确端口和开发板，上传代码；
插入继电器模块供电；
打开 Blinker App，控制按钮即可实现开关控制；
可选扩展：绑定小爱同学、添加定时器等。

📌 项目拓展建议#

✅ 支持语音控制（点灯已支持小爱同学、天猫精灵）
✅ MQTT/本地控制（无需云）
✅ 与其他智能家居平台集成（如 Home Assistant）
✅ 控制电灯、电扇、水泵等 220V 设备（注意隔离与安全）

📝 常见问题#

Q：ESP01 只有两个 GPIO 怎么控制四路？
A：使用 IO 扩展、或更换为 ESP-12F 模块。ESP01 控制 GPIO1/TX 和 GPIO3/RX 会影响串口。

Q：继电器没反应？
A：确认供电为 12V、ESP01 正确工作、按键绑定与引脚设置无误。

Q：Blinker 无法连接？
A：检查 WiFi 名称/密码、设备密钥、是否被防火墙拦截。

✅ 总结#

本项目利用淘宝购买的四路继电器模块 + ESP8266，实现了用点灯 App 控制继电器开关，成本低，效果好，适合入门 IoT 和智能家居应用。

如需完整工程文件（.ino 源码）、原理图或 3D 打印外壳设计，可留言获取～

参考资料#

1. Blinker 官方文档：https://diandeng.tech/doc
1. Blinker GitHub 示例：https://github.com/blinker-iot/blinker-library
1. 心跳包机制解释：https://diandeng.tech/doc/faq/heartbeat
1. 小爱音箱对接说明：https://diandeng.tech/doc/device/miot
1. 小爱同学[Blinker]2024最新-小爱联动4路继电器简易开源教程：https://arduino.me/a/2852