MySensors

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/relay
 */

#define MY_DEBUG
#define MY_RADIO_NRF24
#define MY_REPEATER_FEATURE
#define MY_NODE_ID 1
#include <SPI.h>
#include <MySensors.h>
#include <Bounce2.h>

#define RELAY_PIN  5
#define BUTTON_PIN  3
#define CHILD_ID 1
#define RELAY_ON 1
#define RELAY_OFF 0

Bounce debouncer = Bounce();
bool state = false;
bool initialValueSent = false;

MyMessage msg(CHILD_ID, V_STATUS);

void setup()
{
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  debouncer.attach(BUTTON_PIN);
  debouncer.interval(10);

  // 启动时确保继电器是关闭的
  digitalWrite(RELAY_PIN, RELAY_OFF);
  pinMode(RELAY_PIN, OUTPUT);
}

void presentation()  {
  sendSketchInfo("Relay+button", "1.0");
  present(CHILD_ID, S_BINARY);
}

void loop()
{
  if (!initialValueSent) {
    Serial.println("发送初始值");
    send(msg.set(state?RELAY_ON:RELAY_OFF));
    Serial.println("请求控制器的初始值");
    request(CHILD_ID, V_STATUS);
    wait(2000, C_SET, V_STATUS);
  }
  if (debouncer.update()) {
    if (debouncer.read()==LOW) {
      state = !state;
      // 发送新状态并请求确认
      send(msg.set(state?RELAY_ON:RELAY_OFF), true);
    }
  }
}

void receive(const MyMessage &message) {
  if (message.isAck()) {
     Serial.println("这是来自网关的确认");
  }

  if (message.type == V_STATUS) {
    if (!initialValueSent) {
      Serial.println("接收到来自控制器的初始值");
      initialValueSent = true;
    }
    // 更改继电器状态
    state = (bool)message.getInt();
    digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);
    send(msg.set(state?RELAY_ON:RELAY_OFF));
  }
}

/**
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/binary
 */


#include <MySensor.h>
#include <SPI.h>
#include <Bounce2.h>

#define SN "BinarySensor"
#define SV "1.0"
#define CHILD_ID 1
#define BUTTON_PIN 3  // Arduino 数字 I/O 引脚用于按钮/磁簧开关。

MySensor gw;
Bounce debouncer = Bounce();
MyMessage msg(CHILD_ID, V_TRIPPED);

void setup()
{
  gw.begin();
  gw.sendSketchInfo(SN, SV);
  // 设置按钮。
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  // 设置按钮后，设置去抖器。
  debouncer.attach(BUTTON_PIN);
  debouncer.interval(5);
  gw.present(CHILD_ID, S_DOOR);
  gw.send(msg.set(0));
}

void loop()
{
  if (debouncer.update()) {
    // 获取更新值。
    int value = debouncer.read();
    // 发送新值。
    gw.send(msg.set(value == LOW ? 1 : 0));
  }
}

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 */

// 启用调试打印到串行监视器
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <MySensors.h> // 测试版本 2.3.2

#define SENSOR_NAME "Heatpump Sensor"
#define SENSOR_VERSION "2.3"

#define CHILD_ID_HVAC 0

#define IR_PIN  3  // Arduino 引脚连接到 IR LED，使用 PWM


// 取消注释您的热泵型号
//#include <FujitsuHeatpumpIR.h>
//#include <PanasonicCKPHeatpumpIR.h>
//#include <PanasonicHeatpumpIR.h>
//#include <CarrierHeatpumpIR.h>
//#include <MideaHeatpumpIR.h>
//#include <MitsubishiHeatpumpIR.h>
//#include <SamsungHeatpumpIR.h> // 测试版本 1.0.15，见 http://librarymanager#HeatpumpIR by Toni Arte
//#include <SharpHeatpumpIR.h>
//#include <DaikinHeatpumpIR.h>

//一些全局变量用于保存发送到空调单元的数值状态
int POWER_STATE;
int TEMP_STATE;
int FAN_STATE;
int MODE_STATE;
int VDIR_STATE;
int HDIR_STATE;

// 一些全局变量用于保存发送到 Home Assistant 控制器的文本状态
String FAN_STATE_TXT;  // 可能值（“Min”，“Normal”，“Max”，“Auto”）
String MODE_STATE_TXT; // 可能值（“Off”，“HeatOn”，“CoolOn”或“AutoChangeOver”）


IRSenderPWM irSender(IR_PIN);

// 更改为您自己的热泵
//HeatpumpIR *heatpumpIR = new SamsungAQV12MSANHeatpumpIR();
/*
new PanasonicDKEHeatpumpIR()
new PanasonicJKEHeatpumpIR()
new PanasonicNKEHeatpumpIR()
new CarrierHeatpumpIR()
new MideaHeatpumpIR()
new FujitsuHeatpumpIR()
new MitsubishiFDHeatpumpIR()
new MitsubishiFEHeatpumpIR()
new SamsungAQVHeatpumpIR()
new SamsungFJMHeatpumpIR()
// new SamsungHeatpumpIR() 是一个受保护的通用方法，无法直接创建
new SharpHeatpumpIR()
new DaikinHeatpumpIR()
*/

MyMessage msgHVACSetPointC(CHILD_ID_HVAC, V_HVAC_SETPOINT_COOL);
MyMessage msgHVACSpeed(CHILD_ID_HVAC, V_HVAC_SPEED);
MyMessage msgHVACFlowState(CHILD_ID_HVAC, V_HVAC_FLOW_STATE);

bool initialValueSent = false;

void presentation() {
  // 向网关和控制器发送草图版本信息
  sendSketchInfo(SENSOR_NAME, SENSOR_VERSION);

  // 按照其 ID 和 S_TYPE 将所有传感器注册到网关（它们将作为子设备创建）
  present(CHILD_ID_HVAC, S_HVAC, "Thermostat");
}

void setup() {
}

void loop() {
  // 在此处放置您的主代码，以便重复运行：
  if (!initialValueSent) {
    FAN_STATE_TXT = "Auto"; // 默认风扇启动状态
    TEMP_STATE = 20; // 默认开始温度
    MODE_STATE_TXT = "Off"; // 默认模式状态

    send(msgHVACSetPointC.set(TEMP_STATE));
    send(msgHVACSpeed.set(FAN_STATE_TXT.c_str()));
    send(msgHVACFlowState.set(MODE_STATE_TXT.c_str()));

    initialValueSent = true;
  }
}

void receive(const MyMessage &message) {
  if (message.isAck()) {
     Serial.println("这是来自网关的确认");
     return;
  }

  Serial.print("接收到的消息： ");
  Serial.print(message.sensor);

  String recvData = message.data;
  recvData.trim();

  Serial.print(", 新状态： ");
  Serial.println(recvData);
  switch (message.type) {
    case V_HVAC_SPEED:
      Serial.println("V_HVAC_SPEED");

      if(recvData.equalsIgnoreCase("auto")) FAN_STATE = 0;
      else if(recvData.equalsIgnoreCase("min")) FAN_STATE = 1;
      else if(recvData.equalsIgnoreCase("normal")) FAN_STATE = 2;
      else if(recvData.equalsIgnoreCase("max")) FAN_STATE = 3;
      FAN_STATE_TXT = recvData;
    break;

    case V_HVAC_SETPOINT_COOL:
      Serial.println("V_HVAC_SETPOINT_COOL");
      TEMP_STATE = message.getFloat();
      Serial.println(TEMP_STATE);
    break;

    case V_HVAC_FLOW_STATE:
      Serial.println("V_HVAC_FLOW_STATE");
      if (recvData.equalsIgnoreCase("coolon")) {
        POWER_STATE = 1;
        MODE_STATE = MODE_COOL;
      }
      else if (recvData.equalsIgnoreCase("heaton")) {
        POWER_STATE = 1;
        MODE_STATE = MODE_HEAT;
      }
      else if (recvData.equalsIgnoreCase("autochangeover")) {
        POWER_STATE = 1;
        MODE_STATE = MODE_AUTO;
      }
      else if (recvData.equalsIgnoreCase("off")){
        POWER_STATE = 0;
      }
      MODE_STATE_TXT = recvData;
      break;
  }
  sendHeatpumpCommand();
  sendNewStateToGateway();
}

void sendNewStateToGateway() {
  Serial.println("状态更新发送到 HA：");
  Serial.println("*************************");
  Serial.println("模式 = " + MODE_STATE_TXT + "(" + (String)MODE_STATE + ")");
  Serial.println("风扇 = " + FAN_STATE_TXT + "(" + (String)FAN_STATE + ")");
  Serial.println("温度 = " + (String)TEMP_STATE);
  send(msgHVACFlowState.set(MODE_STATE_TXT.c_str()));
  send(msgHVACSpeed.set(FAN_STATE_TXT.c_str()));
  send(msgHVACSetPointC.set(TEMP_STATE));
}

void sendHeatpumpCommand() {
  Serial.println("热泵命令发送到空调：");
  Serial.println("********************************");
  Serial.println("电源 = " + (String)POWER_STATE);
  Serial.println("模式 = " + (String)MODE_STATE);
  Serial.println("风扇 = " + (String)FAN_STATE);
  Serial.println("温度 = " + (String)TEMP_STATE);

  heatpumpIR->send(irSender, POWER_STATE, MODE_STATE, FAN_STATE, TEMP_STATE, VDIR_AUTO, HDIR_AUTO);
}

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 */

// 启用调试打印到串行监视器
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <MySensors.h>

#define SN "Cover"
#define SV "1.1"

// 用于上下移动遮罩的执行器。
#define COVER_UP_ACTUATOR_PIN 2
#define COVER_DOWN_ACTUATOR_PIN 3
// 用于查找遮罩何时达到其上/下位置的传感器。
// 这些可以是简单的按钮或线性霍尔传感器。
#define COVER_UP_SENSOR_PIN 4
#define COVER_DOWN_SENSOR_PIN 5

#define CHILD_ID 0

// 遮罩状态的内部表示。
enum State {
  IDLE,
  UP, // 窗户遮盖。向上。
  DOWN, // 窗户遮盖。向下。
};

static int state = IDLE;
static int status = 0; // 0=遮罩在下，1=遮罩在上
static bool initial_state_sent = false;
MyMessage upMessage(CHILD_ID, V_UP);
MyMessage downMessage(CHILD_ID, V_DOWN);
MyMessage stopMessage(CHILD_ID, V_STOP);
MyMessage statusMessage(CHILD_ID, V_STATUS);

void sendState() {
  // 将当前状态和状态发送到网关。
  send(upMessage.set(state == UP));
  send(downMessage.set(state == DOWN));
  send(stopMessage.set(state == IDLE));
  send(statusMessage.set(status));
}

void setup() {
  pinMode(COVER_UP_SENSOR_PIN, INPUT);
  pinMode(COVER_DOWN_SENSOR_PIN, INPUT);
}

void presentation() {
  sendSketchInfo(SN, SV);

  present(CHILD_ID, S_COVER);
}

void loop() {
  if (!initial_state_sent) {
    sendState();
    initial_state_sent = true;
  }

  if (state == IDLE) {
    digitalWrite(COVER_UP_ACTUATOR_PIN, LOW);
    digitalWrite(COVER_DOWN_ACTUATOR_PIN, LOW);
  }

  if (state == UP && digitalRead(COVER_UP_SENSOR_PIN) == HIGH) {
    Serial.println("遮罩向上。");
    // 更新状态并状态；发送到网关。
    status = 1;
    state = IDLE;
    sendState();
    // 执行器将在下一个 loop() 迭代中被禁用。
  }

  if (state == DOWN && digitalRead(COVER_DOWN_SENSOR_PIN) == HIGH) {
    Serial.println("遮罩向下。");
    // 更新状态并状态；发送到网关。
    status = 0;
    state = IDLE;
    sendState();
    // 执行器将在下一个 loop() 迭代中被禁用。
  }
}

void receive(const MyMessage &message) {
  if (message.type == V_UP) {
    // 设置状态为遮罩向上并发送回网关。
    state = UP;
    sendState();
    Serial.println("正在移动遮罩向上。");

    // 激活执行器，直到传感器在 loop() 中返回 HIGH。
    digitalWrite(COVER_UP_ACTUATOR_PIN, HIGH);
  }

  if (message.type == V_DOWN) {
    // 设置状态为遮罩向下并发送到网关。
    state = DOWN;
    sendState();
    Serial.println("正在移动遮罩向下。");
    // 激活执行器，直到传感器在 loop() 中返回 HIGH。
    digitalWrite(COVER_DOWN_ACTUATOR_PIN, HIGH);
  }

  if (message.type == V_STOP) {
    // 设置状态为闲置并发送回网关。
    state = IDLE;
    sendState();
    Serial.println("停止遮罩。");

    // 执行器将在 loop() 中关闭。
  }
}

/**
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/gps
 */

// 启用调试打印到串行监视器
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <MySensors.h>

#define SN "GPS Sensor"
#define SV "1.0"

// GPS 位置发送间隔（以毫秒为单位）
#define GPS_SEND_INTERVAL 30000
// 用于 GPS 传感器的儿童 ID
#define CHILD_ID_GPS 1

MyMessage msg(CHILD_ID_GPS, V_POSITION);

// 上次 GPS 位置发送到控制器的时间
unsigned long lastGPSSent = -31000;

// 一些缓存
char latBuf[11];
char lngBuf[11];
char altBuf[6];
char payload[30];

// 虚拟值。真实 GPS 设备的实现尚未完成。
float gpsLocationLat = 40.741895;
float gpsLocationLng = -73.989308;
float gpsAltitudeMeters = 12.0;

void setup() {

}

void presentation() {
  sendSketchInfo(SN, SV);
  present(CHILD_ID_GPS, S_GPS);
}

void loop()
{
  unsigned long currentTime = millis();

  // 评估是否是发送新位置的时间
  bool timeToSend = currentTime - lastGPSSent > GPS_SEND_INTERVAL;

  if (timeToSend) {
    // 发送当前 GPS 位置
    // 构建要发送的位置和高度字符串
    dtostrf(gpsLocationLat, 1, 6, latBuf);
    dtostrf(gpsLocationLng, 1, 6, lngBuf);
    dtostrf(gpsAltitudeMeters, 1, 0, altBuf);
    sprintf(payload, "%s,%s,%s", latBuf, lngBuf, altBuf);

    Serial.print(F("位置： "));
    Serial.println(payload);

    send(msg.set(payload));
    lastGPSSent = currentTime;
  }
}

/*
 * 示例可调光灯
 * 代码来自 https://github.com/mysensors/MySensors/tree/master/examples/DimmableLight
 *
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 */

// 启用调试打印
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <MySensors.h>

#define CHILD_ID_LIGHT 1

#define LIGHT_OFF 0
#define LIGHT_ON 1

#define SN "Dimmable Light"
#define SV "1.0"

int16_t last_state = LIGHT_ON;
int16_t last_dim = 100;

MyMessage light_msg( CHILD_ID_LIGHT, V_STATUS );
MyMessage dimmer_msg( CHILD_ID_LIGHT, V_PERCENTAGE );

void setup()
{
  update_light();
  Serial.println( "节点准备接收消息..." );
}

void loop()
{
  // 在 MySensors2.x 中，第一条消息必须来自 loop() 内部
  static bool first_message_sent = false;
  if ( first_message_sent == false ) {
    Serial.println( "发送初始状态..." );
    send_dimmer_message();
    send_status_message();
    first_message_sent = true;
  }
}

void presentation()
{
  // 将草图版本信息发送到网关
  sendSketchInfo( SN, SV );
  present( CHILD_ID_LIGHT, S_DIMMER );
}

void receive(const MyMessage &message)
{
  // 接收到 V_STATUS 命令时，在关闭状态与最后接收到的调光值间切换灯光
  if ( message.type == V_STATUS ) {
    Serial.println( "接收到 V_STATUS 命令..." );

    int lstate = message.getInt();
    if (( lstate < 0 ) || ( lstate > 1 )) {
      Serial.println( "V_STATUS 数据无效（应为 0/1）" );
      return;
    }
    last_state = lstate;

    // 如果最后调光状态为零，则将调光器设置为 100
    if (( last_state == LIGHT_ON ) && ( last_dim == 0 )) {
      last_dim=100;
    }

    // 更新控制器状态
    send_status_message();

  } else if ( message.type == V_PERCENTAGE ) {
    Serial.println( "接收到 V_PERCENTAGE 命令..." );
    int dim_value = constrain( message.getInt(), 0, 100 );
    if ( dim_value == 0 ) {
      last_state = LIGHT_OFF;

      // 更新控制器的调光值和状态
      send_dimmer_message();
      send_status_message();
    } else {
      last_state = LIGHT_ON;
      last_dim = dim_value;

      // 更新控制器的调光值
      send_dimmer_message();
    }

  } else {
    Serial.println( "接收到的命令无效..." );
    return;
  }

  // 在这里设置实际的灯光状态/级别
  update_light();
}

void update_light()
{
  // 对于此示例，仅将灯光状态打印到控制台。
  if ( last_state == LIGHT_OFF ) {
    Serial.println( "灯光状态：关闭" );
  } else {
    Serial.print( "灯光状态：开启，级别： " );
    Serial.println( last_dim );
  }
}

void send_dimmer_message()
{
  send( dimmer_msg.set( last_dim ) );
}

void send_status_message()
{
  if ( last_state == LIGHT_OFF ) {
    send( light_msg.set( (int16_t)0) );
  } else {
    send( light_msg.set( (int16_t)1) );
  }
}

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/ir
 */

#include <MySensor.h>
#include <SPI.h>
#include <IRLib.h>

#define SN "IR Sensor"
#define SV "1.0"
#define CHILD_ID 1

MySensor gw;

char code[10] = "abcd01234";
char oldCode[10] = "abcd01234";
MyMessage msgCodeRec(CHILD_ID, V_IR_RECEIVE);
MyMessage msgCode(CHILD_ID, V_IR_SEND);
MyMessage msgSendCode(CHILD_ID, V_LIGHT);

void setup()
{
  gw.begin(incomingMessage);
  gw.sendSketchInfo(SN, SV);
  gw.present(CHILD_ID, S_IR);
  // 发送初始值。
  gw.send(msgCodeRec.set(code));
  gw.send(msgCode.set(code));
  gw.send(msgSendCode.set(0));
}

void loop()
{
  gw.process();
  // IR 接收器未实现，仅在代码更改时虚拟报告
  if (String(code) != String(oldCode)) {
    Serial.print("接收到代码 ");
    Serial.println(code);
    gw.send(msgCodeRec.set(code));
    strcpy(oldCode, code);
  }
}

void incomingMessage(const MyMessage &message) {
  if (message.type==V_LIGHT) {
    // IR 发送器未实现，仅打印虚拟信息。
    if (message.getBool()) {
      Serial.print("发送代码 ");
      Serial.println(code);
    }
    gw.send(msgSendCode.set(message.getBool() ? 1 : 0));
    // 始终关闭设备
    gw.wait(100);
    gw.send(msgSendCode.set(0));
  }
  if (message.type == V_IR_SEND) {
    // 从传入消息中检索 IR 代码值。
    String codestring = message.getString();
    codestring.toCharArray(code, sizeof(code));
    Serial.print("更改代码为 ");
    Serial.println(code);
    gw.send(msgCode.set(code));
  }
}

/**
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/light
 */

// 启用调试打印到串行监视器
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <BH1750.h>
#include <Wire.h>
#include <MySensors.h>

#define SN "LightLuxSensor"
#define SV "1.0"
#define CHILD_ID 1
unsigned long SLEEP_TIME = 30000; // 读取之间的睡眠时间（以毫秒为单位）

BH1750 lightSensor;
MyMessage msg(CHILD_ID, V_LEVEL);
MyMessage msgPrefix(CHILD_ID, V_UNIT_PREFIX);  // 自定义单位消息。
uint16_t lastlux = 0;
bool initialValueSent = false;

void setup()
{
  sendSketchInfo(SN, SV);
  present(CHILD_ID, S_LIGHT_LEVEL);
  lightSensor.begin();
}

void loop()
{
  if (!initialValueSent) {
    Serial.println("发送初始值");
    send(msgPrefix.set("custom_lux"));  // 设置自定义单位。
    send(msg.set(lastlux));
    Serial.println("请求控制器的初始值");
    request(CHILD_ID, V_LEVEL);
    wait(2000, C_SET, V_LEVEL);
  }
  uint16_t lux = lightSensor.readLightLevel();  // 获取 Lux 值
  if (lux != lastlux) {
      send(msg.set(lux));
      lastlux = lux;
  }

  sleep(SLEEP_TIME);
}

void receive(const MyMessage &message) {
  if (message.type == V_LEVEL) {
    if (!initialValueSent) {
      Serial.println("接收到来自控制器的初始值");
      initialValueSent = true;
    }
  }
}

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 *
 * https://www.mysensors.org/build/relay
 */

#include <MySensor.h>
#include <SPI.h>

#define SN "Relay"
#define SV "1.0"
#define CHILD_ID 1
#define RELAY_PIN 3

MySensor gw;
MyMessage msgRelay(CHILD_ID, V_STATUS);

void setup()
{
  gw.begin(incomingMessage);
  gw.sendSketchInfo(SN, SV);
  // 初始化数字引脚为输出。
  pinMode(RELAY_PIN, OUTPUT);
  gw.present(CHILD_ID, S_BINARY);
  gw.send(msgRelay.set(0));
}

void loop()
{
  gw.process();
}

void incomingMessage(const MyMessage &message)
{
  if (message.type == V_STATUS) {
     // 更改继电器状态。
     digitalWrite(RELAY_PIN, message.getBool() ? 1 : 0);
     gw.send(msgRelay.set(message.getBool() ? 1 : 0));
  }
}

/*
 * 文档： https://www.mysensors.org
 * 支持论坛： https://forum.mysensors.org
 */

// 启用调试打印到串行监视器
#define MY_DEBUG
#define MY_RADIO_NRF24

#include <MySensors.h>
#include <SPI.h>

#define SN "TextSensor"
#define SV "1.0"
#define CHILD_ID 1

MyMessage textMsg(CHILD_ID, V_TEXT);
bool initialValueSent = false;

void setup(void) {
}

void presentation() {
  sendSketchInfo(SN, SV);
  present(CHILD_ID, S_INFO, "TextSensor1");
}

void loop() {
  if (!initialValueSent) {
    Serial.println("发送初始值");
    // 发送初始值。
    send(textMsg.set("-"));
    Serial.println("请求控制器的初始值");
    request(CHILD_ID, V_TEXT);
    wait(2000, C_SET, V_TEXT);
  }
}

void receive(const MyMessage &message) {
  if (message.type == V_TEXT) {
    if (!initialValueSent) {
      Serial.println("接收到来自控制器的初始值");
      initialValueSent = true;
    }
    // 虚拟打印
    Serial.print("消息： ");
    Serial.print(message.sensor);
    Serial.print(", 消息： ");
    Serial.println(message.getString());
    // 发送消息到控制器
    send(textMsg.set(message.getString()));
  }
}