Merge branch 'main' of https://github.com/pschatzmann/Arduino-Emulator

pschatzmann · pschatzmann · commit e77ab66f0e90 · 2025-11-08T09:31:57.000+01:00
diff --git a/ArduinoCore-Linux/cores/arduino/Ethernet.h b/ArduinoCore-Linux/cores/arduino/Ethernet.h
@@ -22,6 +22,7 @@
 #include <arpa/inet.h>  // for inet_pton
 #include <netdb.h>      // for gethostbyname, struct hostent
 #include <unistd.h>     // for close
+#include <memory>  // This is the include you need
 
 #include "ArduinoLogger.h"
 #include "RingBufferExt.h"
@@ -80,13 +81,13 @@ class EthernetClient : public Client {
  public:
   EthernetClient() {
     setTimeout(2000);
-    p_sock = new SocketImpl();
+    p_sock = std::make_shared<SocketImpl>();
     readBuffer = RingBufferExt(bufferSize);
     writeBuffer = RingBufferExt(bufferSize);
     registerCleanup();
     active_clients().push_back(this);
   }
-  EthernetClient(SocketImpl* sock, int bufferSize = 256, long timeout = 2000) {
+  EthernetClient(std::shared_ptr<SocketImpl> sock, int bufferSize = 256, long timeout = 2000) {
     if (sock) {
       setTimeout(timeout);
       this->bufferSize = bufferSize;
@@ -102,22 +103,8 @@ class EthernetClient : public Client {
     setTimeout(2000);
     readBuffer = RingBufferExt(bufferSize);
     writeBuffer = RingBufferExt(bufferSize);
-    p_sock = new SocketImpl(socket);
+    p_sock = std::make_shared<SocketImpl>(socket);
     is_connected = p_sock->connected();
-    registerCleanup();
-    active_clients().push_back(this);
-  }
-
-  virtual ~EthernetClient() {
-    auto& clients = active_clients();
-    auto it = std::find(clients.begin(), clients.end(), this);
-    if (it != clients.end()) {
-      clients.erase(it);
-    }
-    if (p_sock) {
-      delete p_sock;
-      p_sock = nullptr;
-    }
   }
 
   // checks if we are connected - using a timeout
@@ -269,7 +256,7 @@ class EthernetClient : public Client {
 
  protected:
   const char* WIFICLIENT = "EthernetClient";
-  SocketImpl* p_sock = nullptr;
+  std::shared_ptr<SocketImpl> p_sock = nullptr;
   int bufferSize = 256;
   RingBufferExt readBuffer;
   RingBufferExt writeBuffer;
diff --git a/ArduinoCore-Linux/cores/arduino/EthernetServer.h b/ArduinoCore-Linux/cores/arduino/EthernetServer.h
@@ -186,7 +186,7 @@ class EthernetServer : public Server {
       Logger.error("accept failed");
       return result;
     }
-    SocketImpl* sock_impl = new SocketImpl(client_fd, (struct sockaddr_in*)&client_addr);
+    std::shared_ptr<SocketImpl> sock_impl = std::make_shared<SocketImpl>(client_fd, (struct sockaddr_in*)&client_addr);
     EthernetClient result{sock_impl};
     return result;
   }
diff --git a/ArduinoCore-Linux/cores/arduino/SocketImpl.cpp b/ArduinoCore-Linux/cores/arduino/SocketImpl.cpp
@@ -103,7 +103,7 @@ int SocketImpl::connect(const char *address, uint16_t port) {
 // -1=>Error
 size_t SocketImpl::write(const uint8_t *str, size_t len) {
   Logger.debug(SOCKET_IMPL, "write");
-  return ::send(sock, str, len, 0);
+  return ::send(sock, str, len, MSG_NOSIGNAL);
 }
 
 // provides the available bytes
@@ -118,7 +118,7 @@ size_t SocketImpl::available() {
 
 // direct read
 size_t SocketImpl::read(uint8_t *buffer, size_t len) {
-  size_t result = ::recv(sock, buffer, len, MSG_DONTWAIT);
+  size_t result = ::recv(sock, buffer, len, MSG_DONTWAIT | MSG_NOSIGNAL);
   char lenStr[80];
   sprintf(lenStr, "%ld -> %ld", len, result);
   Logger.debug(SOCKET_IMPL, "read->", lenStr);
diff --git a/ArduinoCore-Linux/cores/arduino/SocketImpl.h b/ArduinoCore-Linux/cores/arduino/SocketImpl.h
@@ -36,6 +36,11 @@ class SocketImpl {
     is_connected = true;
     serv_addr = *address;
   };
+  virtual ~SocketImpl() {
+    if (sock != -1) {
+      close();
+    }
+  }
   // checks if we are connected
   virtual uint8_t connected();
   // opens a conection
diff --git a/ArduinoCore-Linux/cores/firmata/HardwareGPIO_FIR.cpp b/ArduinoCore-Linux/cores/firmata/HardwareGPIO_FIR.cpp
@@ -0,0 +1,167 @@
+
+
+#include "HardwareGPIO_FIR.h"
+#include "Stream.h" // or <Stream.h> if needed
+#include <map>
+#include <vector>
+#include <cstdint>
+
+namespace arduino {
+
+
+Stream* firmataStream = nullptr;
+std::map<pin_size_t, PinMode> pinModes;
+std::map<pin_size_t, PinStatus> pinStates;
+std::map<pin_size_t, int> analogValues;
+std::vector<uint8_t> rxBuffer;
+
+// Firmata protocol constants
+constexpr uint8_t DIGITAL_MESSAGE = 0x90;
+constexpr uint8_t ANALOG_MESSAGE = 0xE0;
+constexpr uint8_t SET_PIN_MODE = 0xF4;
+constexpr uint8_t REPORT_DIGITAL = 0xD0;
+constexpr uint8_t REPORT_ANALOG = 0xC0;
+
+HardwareGPIO_FIRMATA::~HardwareGPIO_FIRMATA() {
+    end();
+}
+
+bool HardwareGPIO_FIRMATA::begin(Stream &stream) {
+    firmataStream = &stream;
+    is_open = true;
+    rxBuffer.clear();
+    return true;
+}
+
+void HardwareGPIO_FIRMATA::end() {
+    is_open = false;
+    firmataStream = nullptr;
+    pinModes.clear();
+    pinStates.clear();
+    analogValues.clear();
+    rxBuffer.clear();
+}
+
+void HardwareGPIO_FIRMATA::pinMode(pin_size_t pinNumber, PinMode pinMode) {
+    pinModes[pinNumber] = pinMode;
+    if (firmataStream) {
+        firmataStream->write(SET_PIN_MODE);
+        firmataStream->write(pinNumber);
+        firmataStream->write(pinMode);
+    }
+}
+
+void HardwareGPIO_FIRMATA::digitalWrite(pin_size_t pinNumber, PinStatus status) {
+    pinStates[pinNumber] = status;
+    if (firmataStream) {
+        uint8_t port = pinNumber / 8;
+        uint8_t portValue = 0;
+        for (int i = 0; i < 8; ++i) {
+            pin_size_t p = port * 8 + i;
+            if (pinStates[p] == HIGH) {
+                portValue |= (1 << i);
+            }
+        }
+        firmataStream->write(DIGITAL_MESSAGE | port);
+        firmataStream->write(portValue & 0x7F);
+        firmataStream->write((portValue >> 7) & 0x7F);
+    }
+}
+
+PinStatus HardwareGPIO_FIRMATA::digitalRead(pin_size_t pinNumber) {
+    // Request digital report for the port
+    if (firmataStream) {
+        uint8_t port = pinNumber / 8;
+        firmataStream->write(REPORT_DIGITAL | port);
+        firmataStream->write(1); // enable reporting
+    }
+    // Try to parse digital message from rxBuffer
+    for (size_t i = 0; i + 2 < rxBuffer.size(); ++i) {
+        uint8_t msg = rxBuffer[i];
+        if ((msg & 0xF0) == DIGITAL_MESSAGE) {
+            uint8_t port = msg & 0x0F;
+            uint8_t lsb = rxBuffer[i+1];
+            uint8_t msb = rxBuffer[i+2];
+            uint16_t portValue = lsb | (msb << 7);
+            pin_size_t p = port * 8;
+            for (int j = 0; j < 8; ++j) {
+                pinStates[p + j] = (portValue & (1 << j)) ? HIGH : LOW;
+            }
+            // Remove processed message
+            rxBuffer.erase(rxBuffer.begin(), rxBuffer.begin() + i + 3);
+            break;
+        }
+    }
+    auto it = pinStates.find(pinNumber);
+    if (it != pinStates.end()) {
+        return it->second;
+    }
+    return LOW;
+}
+
+int HardwareGPIO_FIRMATA::analogRead(pin_size_t pinNumber) {
+    // Request analog report for the pin
+    if (firmataStream) {
+        firmataStream->write(REPORT_ANALOG | (pinNumber & 0x0F));
+        firmataStream->write(1); // enable reporting
+    }
+    // Try to parse analog message from rxBuffer
+    for (size_t i = 0; i + 2 < rxBuffer.size(); ++i) {
+        uint8_t msg = rxBuffer[i];
+        if ((msg & 0xF0) == ANALOG_MESSAGE) {
+            uint8_t pin = msg & 0x0F;
+            uint8_t lsb = rxBuffer[i+1];
+            uint8_t msb = rxBuffer[i+2];
+            int value = lsb | (msb << 7);
+            analogValues[pin] = value;
+            // Remove processed message
+            rxBuffer.erase(rxBuffer.begin(), rxBuffer.begin() + i + 3);
+            break;
+        }
+    }
+    auto it = analogValues.find(pinNumber);
+    if (it != analogValues.end()) {
+        return it->second;
+    }
+    return 0;
+}
+
+void HardwareGPIO_FIRMATA::analogReference(uint8_t mode) {
+    // Not supported by Firmata, do nothing
+}
+
+void HardwareGPIO_FIRMATA::analogWrite(pin_size_t pinNumber, int value) {
+    if (firmataStream) {
+        firmataStream->write(ANALOG_MESSAGE | (pinNumber & 0x0F));
+        firmataStream->write(value & 0x7F);
+        firmataStream->write((value >> 7) & 0x7F);
+    }
+}
+
+void HardwareGPIO_FIRMATA::analogWriteFrequency(pin_size_t pinNumber, uint32_t frequency) {
+    // Not supported by Firmata, do nothing
+}
+
+void HardwareGPIO_FIRMATA::tone(uint8_t _pin, unsigned int frequency, unsigned long duration) {
+    // Not supported by Firmata, do nothing
+}
+
+void HardwareGPIO_FIRMATA::noTone(uint8_t _pin) {
+    // Not supported by Firmata, do nothing
+}
+
+unsigned long HardwareGPIO_FIRMATA::pulseIn(uint8_t pin, uint8_t state, unsigned long timeout) {
+    // Not supported by Firmata, return 0
+    return 0;
+}
+
+unsigned long HardwareGPIO_FIRMATA::pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout) {
+    // Not supported by Firmata, return 0
+    return 0;
+}
+
+void HardwareGPIO_FIRMATA::analogWriteResolution(uint8_t bits) {
+    // Firmata supports 8-bit resolution, do nothing
+}
+
+} // namespace arduino
diff --git a/ArduinoCore-Linux/cores/firmata/HardwareGPIO_FIR.h b/ArduinoCore-Linux/cores/firmata/HardwareGPIO_FIR.h

Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ class EthernetServer : public Server {`
`186`	`186`	`Logger.error("accept failed");`
`187`	`187`	`return result;`
`188`	`188`	`}`
`189`		`- SocketImpl* sock_impl = new SocketImpl(client_fd, (struct sockaddr_in*)&client_addr);`
	`189`	`+ std::shared_ptr<SocketImpl> sock_impl = std::make_shared<SocketImpl>(client_fd, (struct sockaddr_in*)&client_addr);`
`190`	`190`	`EthernetClient result{sock_impl};`
`191`	`191`	`return result;`
`192`	`192`	`}`