Das Entschlüsseln von Kinetic RF-Schaltern

#include <Arduino.h>
#include <ELECHOUSE_CC1101_SRC_DRV.h>
#include <IotWebConf.h>
#include <IotWebConfUsing.h>
#include <PubSubClient.h>
#include <string.h>
#include <DNSServer.h>
#include <ESP8266WiFi.h>

// IotWebConf configuration
#define CONFIG_PARAM_MAX_LEN 128
#define CONFIG_VERSION "mqt2"
#define CONFIG_PIN 4  // D2 (config button/pin)
#define STATUS_PIN 16 // D0 (status LED)

const char deviceName[] = "redected";
const char apPassword[] = "redacted";

// MQTT configuration parameters
char mqttServerValue[CONFIG_PARAM_MAX_LEN];
char mqttUserNameValue[CONFIG_PARAM_MAX_LEN];
char mqttUserPasswordValue[CONFIG_PARAM_MAX_LEN];
char mqttTopicValue[CONFIG_PARAM_MAX_LEN];

// Set up DNS, web server, and MQTT client for IotWebConf
DNSServer dnsServer;
WebServer server(80);
WiFiClient net;
PubSubClient mqttClient(net);

// Set up IotWebConf and configuration parameter groups
IotWebConf iotWebConf(deviceName, &dnsServer, &server, apPassword, CONFIG_VERSION);
IotWebConfParameterGroup mqttGroup = IotWebConfParameterGroup("mqtt", "MQTT configuration");
IotWebConfTextParameter mqttServerParam = IotWebConfTextParameter("MQTT server", "mqttServer", mqttServerValue, CONFIG_PARAM_MAX_LEN);
IotWebConfTextParameter mqttUserNameParam = IotWebConfTextParameter("MQTT user", "mqttUser", mqttUserNameValue, CONFIG_PARAM_MAX_LEN);
IotWebConfPasswordParameter mqttUserPasswordParam = IotWebConfPasswordParameter("MQTT password", "mqttPass", mqttUserPasswordValue, CONFIG_PARAM_MAX_LEN);
IotWebConfTextParameter mqttTopicParam = IotWebConfTextParameter("MQTT Topic", "mqttTopic", mqttTopicValue, CONFIG_PARAM_MAX_LEN);

// Flag for scheduling a reset after configuration change
bool needReset = false;

// MQTT command topic (set after configuration is loaded)
String commandTopic;

// CC1101 configuration
#define GDO0_Pin 5 // Use GDO0 on pin 5

// Predefined binary message for first signal as a string of '0's and '1's
const char *binaryMessage = "10000000000000000000000000000000100010001000111011101110100011101000100011101110100011101000111010001000100011101000100010001110";

// Buffers to hold the packed data and their lengths
uint8_t dataBuffer[128];
int dataLength = 0;

// Converts a binary string ("0" and "1") to packed bytes (MSB-first)
int binaryStringToBytes(const char *binStr, uint8_t *output)
{
  int len = strlen(binStr);
  int byteCount = (len + 7) / 8;
  memset(output, 0, byteCount);
  for (int i = 0; i < len; i++)
  {
    int byteIndex = i / 8;
    int bitIndex = 7 - (i % 8);
    if (binStr[i] == '1')
    {
      output[byteIndex] |= (1 << bitIndex);
    }
  }
  return byteCount;
}

// Minimal raw transmission using the CC1101 TX FIFO.
void sendRawData(uint8_t *txBuffer, uint8_t size)
{
  ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size);
  ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
  ELECHOUSE_cc1101.SpiStrobe(CC1101_STX);
  // Wait for the transmission to complete using GDO0 as an indicator.
  while (!digitalRead(GDO0_Pin))
  {
    yield();
  }
  while (digitalRead(GDO0_Pin))
  {
    yield();
  }
  ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX);
}

// MQTT callback: when a message is received, check the command and trigger the corresponding transmission.
void mqttCallback(char *topic, byte *payload, unsigned int length)
{
  Serial.print("MQTT message received on topic: ");
  Serial.println(topic);

  // Convert payload to a String
  String message;
  for (unsigned int i = 0; i < length; i++)
  {
    message += (char)payload[i];
  }
  Serial.print("Message: ");
  Serial.println(message);

  // Check for command and trigger the first signal transmission.
  if (String(topic) == commandTopic)
  {
    if (message == "transmit_01")
    {
      Serial.println("Transmitting first signal via CC1101...");
      sendRawData(dataBuffer, dataLength);
    }
    else
    {
      Serial.println("Unknown command received.");
    }
  }
}

// Called when configuration is saved via the captive portal; schedules a reboot.
void configSaved()
{
  Serial.println("Configuration was updated.");
  needReset = true;
}

// Validate the IotWebConf configuration form.
bool formValidator(iotwebconf::WebRequestWrapper *webRequestWrapper)
{
  Serial.println("Validating form.");
  bool valid = true;

  int l = webRequestWrapper->arg(mqttServerParam.getId()).length();
  if (l < 3)
  {
    mqttServerParam.errorMessage = "Please provide at least 3 characters!";
    valid = false;
  }

  l = webRequestWrapper->arg(mqttUserNameParam.getId()).length();
  if (l < 1)
  {
    mqttUserNameParam.errorMessage = "Please provide a username!";
    valid = false;
  }

  l = webRequestWrapper->arg(mqttUserPasswordParam.getId()).length();
  if (l < 1)
  {
    mqttUserPasswordParam.errorMessage = "Please provide a password!";
    valid = false;
  }

  l = webRequestWrapper->arg(mqttTopicParam.getId()).length();
  if (l < 3)
  {
    mqttTopicParam.errorMessage = "Please provide at least 3 characters!";
    valid = false;
  }

  return valid;
}

// Attempt to connect to the MQTT broker and subscribe to the command topic.
void connectMqtt()
{
  Serial.print("Attempting MQTT connection...");
  String clientId = iotWebConf.getThingName();
  clientId += "-";
  clientId += String(random(0xffff), HEX);
  // Use the username and password for MQTT authentication.
  if (mqttClient.connect(clientId.c_str(), mqttUserNameValue, mqttUserPasswordValue))
  {
    Serial.println(" connected");
    // Publish connection announcement on a status topic.
    String statusTopic = String(mqttTopicValue) + "/status/connection";
    mqttClient.publish(statusTopic.c_str(), "connected");

    // Define and subscribe to the command topic.
    commandTopic = String(mqttTopicValue) + "/command";
    mqttClient.subscribe(commandTopic.c_str());
    Serial.print("Subscribed to command topic: ");
    Serial.println(commandTopic);
  }
  else
  {
    Serial.print(" failed, state: ");
    Serial.println(mqttClient.state());
    delay(5000);
  }
}

void setup()
{
  Serial.begin(115200);
  delay(500);

  // Convert the binary string into packed bytes.
  dataLength = binaryStringToBytes(binaryMessage, dataBuffer);
  Serial.print("First signal data length (bytes): ");
  Serial.println(dataLength);

  // Initialize the CC1101 module.
  if (!ELECHOUSE_cc1101.getCC1101())
  {
    Serial.println("CC1101 Connection Error!");
    while (1)
    {
      delay(1000);
    }
  }
  Serial.println("CC1101 Connection OK");

  ELECHOUSE_cc1101.Init();
  pinMode(GDO0_Pin, INPUT);
  ELECHOUSE_cc1101.setGDO0(GDO0_Pin);
  ELECHOUSE_cc1101.setCCMode(1);                       // Advanced/raw mode
  ELECHOUSE_cc1101.setModulation(2);                   // ASK (OOK)
  ELECHOUSE_cc1101.setMHZ(433.92);                     // Frequency (adjust as needed)
  ELECHOUSE_cc1101.setSyncMode(0);                     // Disable sync word
  ELECHOUSE_cc1101.setCrc(0);                          // Disable CRC
  ELECHOUSE_cc1101.setDRate(30);                       // Data rate in kbps
  ELECHOUSE_cc1101.SpiWriteReg(CC1101_PKTCTRL0, 0x00); // Disable preamble/sync/length
  Serial.println("TX Mode Initialized. Ready to transmit.");

  // Initialize IotWebConf (captive portal and configuration)
  pinMode(CONFIG_PIN, INPUT_PULLUP);
  iotWebConf.setStatusPin(STATUS_PIN);
  iotWebConf.setConfigPin(CONFIG_PIN);
  mqttGroup.addItem(&mqttServerParam);
  mqttGroup.addItem(&mqttUserNameParam);
  mqttGroup.addItem(&mqttUserPasswordParam);
  mqttGroup.addItem(&mqttTopicParam);
  iotWebConf.addParameterGroup(&mqttGroup);
  iotWebConf.setConfigSavedCallback(&configSaved);
  iotWebConf.setFormValidator(&formValidator);

  bool validConfig = iotWebConf.init();
  if (!validConfig)
  {
    // Clear saved configuration if it is invalid.
    mqttServerValue[0] = '\0';
    mqttUserNameValue[0] = '\0';
    mqttUserPasswordValue[0] = '\0';
    mqttTopicValue[0] = '\0';
  }

  // Disable AP timeout so the captive portal is always available when needed.
  iotWebConf.setApTimeoutMs(0);

  server.on("/", []()
            { iotWebConf.handleConfig(); });
  server.onNotFound([]()
                    { iotWebConf.handleNotFound(); });

  // Set up MQTT client with the configured server and our callback.
  mqttClient.setServer(mqttServerValue, 1883);
  mqttClient.setCallback(mqttCallback);
}

void loop()
{
  iotWebConf.doLoop();

  if (needReset)
  {
    Serial.println("Rebooting after 1 second.");
    iotWebConf.delay(1000);
    ESP.restart();
  }

  // If WiFi is connected and MQTT is not, try to connect to the broker.
  if ((iotWebConf.getState() == iotwebconf::OnLine) && !mqttClient.connected())
  {
    connectMqtt();
  }
  mqttClient.loop();
}