move common files to submodule

src/esp_platform.cpp

@@ -0,0 +1,122 @@
+#include "esp_platform.h"
+#include <user_interface.h>
+#include <Arduino.h>
+#include <EEPROM.h>
+
+EspPlatform::EspPlatform()
+{
+}
+
+uint32_t EspPlatform::currentIpAddress()
+{
+    return WiFi.localIP();
+}
+
+uint32_t EspPlatform::currentSubnetMask()
+{
+    return WiFi.subnetMask();
+}
+
+uint32_t EspPlatform::currentDefaultGateway()
+{
+    return WiFi.gatewayIP();
+}
+
+void EspPlatform::macAddress(uint8_t * addr)
+{
+    wifi_get_macaddr(STATION_IF, addr);
+}
+
+uint32_t EspPlatform::millis()
+{
+    return ::millis();
+}
+
+void EspPlatform::mdelay(uint32_t millis)
+{
+    delay(millis);
+}
+
+void EspPlatform::restart()
+{
+    Serial.println("restart");
+    ESP.reset();
+}
+
+void EspPlatform::fatalError()
+{
+    const int period = 200;
+    while (true)
+    {
+        if ((millis() % period) > (period / 2))
+            digitalWrite(LED_BUILTIN, HIGH);
+        else
+            digitalWrite(LED_BUILTIN, LOW);
+    }
+}
+
+void EspPlatform::setupMultiCast(uint32_t addr, uint16_t port)
+{
+    _mulitcastAddr = htonl(addr);
+    _mulitcastPort = port;
+    IPAddress mcastaddr(_mulitcastAddr);
+    
+    Serial.printf("setup multicast addr: %s port: %d ip: %s\n", mcastaddr.toString().c_str(), port,
+        WiFi.localIP().toString().c_str());
+    uint8 result = _udp.beginMulticast(WiFi.localIP(), mcastaddr, port);
+    Serial.printf("result %d\n", result);
+}
+
+void EspPlatform::closeMultiCast()
+{
+    _udp.stop();
+}
+
+void printHex(const char* suffix, uint8_t *data, uint8_t length)
+{
+    Serial.print(suffix);
+    for (int i = 0; i<length; i++) {
+        if (data[i]<0x10) { Serial.print("0"); }
+        Serial.print(data[i], HEX);
+        Serial.print(" ");
+    }
+    Serial.print("\n");
+}
+
+bool EspPlatform::sendBytes(uint8_t * buffer, uint16_t len)
+{
+    printHex("<- ",buffer, len);
+    int result = 0;
+    result = _udp.beginPacketMulticast(_mulitcastAddr, _mulitcastPort, WiFi.localIP());
+    result = _udp.write(buffer, len);
+    result = _udp.endPacket();
+    return true;
+}
+
+int EspPlatform::readBytes(uint8_t * buffer, uint16_t maxLen)
+{
+    int len = _udp.parsePacket();
+    if (len == 0)
+        return 0;
+    
+    if (len > maxLen)
+    {
+        Serial.printf("udp buffer to small. was %d, needed %d\n", maxLen, len);
+        fatalError();
+    }
+
+    _udp.read(buffer, len);
+    printHex("-> ", buffer, len);
+    return len;
+}
+
+uint8_t * EspPlatform::getEepromBuffer(uint16_t size)
+{
+    EEPROM.begin(size);
+    return EEPROM.getDataPtr();
+}
+
+void EspPlatform::commitToEeprom()
+{
+    EEPROM.commit();
+}

src/esp_platform.h

@@ -0,0 +1,36 @@
+#include "knx/platform.h"
+#include <ESP8266WiFi.h>
+#include <WifiUDP.h>
+
+class EspPlatform : public Platform
+{
+public:
+    EspPlatform();
+
+    // ip stuff
+    uint32_t currentIpAddress();
+    uint32_t currentSubnetMask();
+    uint32_t currentDefaultGateway();
+    void macAddress(uint8_t* addr);
+
+    // basic stuff
+    uint32_t millis();
+    void mdelay(uint32_t millis);
+    void restart();
+    void fatalError();
+
+    //multicast
+    void setupMultiCast(uint32_t addr, uint16_t port);
+    void closeMultiCast();
+    bool sendBytes(uint8_t* buffer, uint16_t len);
+    int readBytes(uint8_t* buffer, uint16_t maxLen);
+
+    //memory
+    uint8_t* getEepromBuffer(uint16_t size);
+    void commitToEeprom();
+private:
+    uint32_t _mulitcastAddr;
+    uint16_t _mulitcastPort;
+    WiFiUDP _udp;
+};
+

src/knx_esp.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "knx_facade.h"

src/knx_facade.cpp

@@ -0,0 +1,105 @@
+#include "knx_facade.h"
+
+KnxFacade knx;
+
+KnxFacade::KnxFacade() : _bau(_platform)
+{
+    manufacturerId(0xfa);
+}
+
+bool KnxFacade::enabled()
+{
+    return _bau.enabled();
+}
+
+void KnxFacade::enabled(bool value)
+{
+    _bau.enabled(true);
+}
+
+bool KnxFacade::progMode()
+{
+    return _bau.deviceObject().progMode();
+}
+
+void KnxFacade::progMode(bool value)
+{
+    _bau.deviceObject().progMode(value);
+}
+
+bool KnxFacade::configured()
+{
+    return _bau.configured();
+}
+
+void KnxFacade::readMemory()
+{
+    _bau.readMemory();
+}
+
+void KnxFacade::loop()
+{
+    _bau.loop();
+}
+
+void KnxFacade::registerGroupObjects(GroupObject* groupObjects, uint16_t count)
+{
+    _bau.groupObjectTable().groupObjects(groupObjects, count);
+}
+
+void KnxFacade::manufacturerId(uint16_t value)
+{
+    _bau.deviceObject().manufacturerId(value);
+}
+
+void KnxFacade::bauNumber(uint32_t value)
+{
+    _bau.deviceObject().bauNumber(value);
+}
+
+void KnxFacade::orderNumber(const char* value)
+{
+    _bau.deviceObject().orderNumber(value);
+}
+
+void KnxFacade::hardwareType(uint8_t* value)
+{
+    _bau.deviceObject().hardwareType(value);
+}
+
+void KnxFacade::version(uint16_t value)
+{
+    _bau.deviceObject().version(value);
+}
+
+uint8_t* KnxFacade::paramData(uint32_t addr)
+{
+    if (!_bau.configured())
+        return nullptr;
+    
+    return _bau.parameters().data(addr);
+}
+
+uint8_t KnxFacade::paramByte(uint32_t addr)
+{
+    if (!_bau.configured())
+        return 0;
+
+    return _bau.parameters().getByte(addr);
+}
+
+uint16_t KnxFacade::paramWord(uint32_t addr)
+{
+    if (!_bau.configured())
+        return 0;
+
+    return _bau.parameters().getWord(addr);
+}
+
+uint32_t KnxFacade::paramInt(uint32_t addr)
+{
+    if (!_bau.configured())
+        return 0;
+
+    return _bau.parameters().getInt(addr);
+}

src/knx_facade.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "esp_platform.h"
+#include "knx/bau57B0.h"
+
+class KnxFacade
+{
+public:
+    KnxFacade();
+    bool enabled();
+    void enabled(bool value);
+    bool progMode();
+    void progMode(bool value);
+    bool configured();
+    void readMemory();
+    void loop();
+    void registerGroupObjects(GroupObject* groupObjects, uint16_t count);
+    void manufacturerId(uint16_t value);
+    void bauNumber(uint32_t value);
+    void orderNumber(const char* value);
+    void hardwareType(uint8_t* value);
+    void version(uint16_t value);
+    uint8_t* paramData(uint32_t addr);
+    uint8_t paramByte(uint32_t addr);
+    uint16_t paramWord(uint32_t addr);
+    uint32_t paramInt(uint32_t addr);
+private:
+    EspPlatform _platform;
+    Bau57B0 _bau;
+};
+
+extern KnxFacade knx;