Fix RPI

Author: pschatzmann

ArduinoCore-API/api/Print.h

@@ -50,7 +50,8 @@ class Print
     virtual size_t write(uint8_t) = 0;
     size_t write(const char *str) {
       if (str == NULL) return 0;
-      return write((const uint8_t *)str, strlen(str));
+      int len = strlen(str);
+      return write((const uint8_t *)str, len);
     }
     virtual size_t write(const uint8_t *buffer, size_t size);
     size_t write(const char *buffer, size_t size) {

ArduinoCore-Linux/cores/arduino/ArdStdio.h

@@ -28,58 +28,72 @@ class StdioDevice : public Stream {
         // nothing to be done
     }
 
-    virtual void print(const char* str){
+    virtual size_t print(const char* str){
         std::cout << str;
         if (auto_flush) flush();
+        return strlen(str);
     }
 
-    virtual void println(const char* str=""){
+    virtual size_t println(const char* str=""){
         std::cout << str << "\n";
         if (auto_flush) flush();
+        return strlen(str) + 1;
     }
 
-    virtual void print(int val, int radix = DEC){
-        if (radix == DEC) { std::cout << val; } else { Stream::print(val, radix); }
+    virtual size_t print(int val, int radix = DEC){
+        size_t result = Stream::print(val, radix); 
         if (auto_flush) flush();
+        return result;
     }
 
-    virtual void println(int val, int radix = DEC){
-        if (radix == DEC) { std::cout << val << "\n"; } else { Stream::println(val, radix); }
+    virtual size_t println(int val, int radix = DEC){
+        size_t result = Stream::println(val, radix); 
         if (auto_flush) flush();
+        return result;
     }
 
-    virtual void println(String &str){
-        println(str.c_str());
+    virtual size_t println(String &str){
+        return println(str.c_str());
     }
 
-    virtual void print(String &str){
-        print(str.c_str());
+    virtual size_t print(String &str){
+        return print(str.c_str());
     }
 
 
-    virtual void println(Printable &p){
-        p.printTo(*this);
+    virtual size_t println(Printable &p){
+        size_t result = p.printTo(*this);
         std::cout << "\n";
         if (auto_flush) flush();
+        return result + 1;
     }
 
-    virtual void print(Printable &p){
-        p.printTo(*this);
+    virtual size_t print(Printable &p){
+        auto result = p.printTo(*this);
         if (auto_flush) flush();
+        return result;
     }
 
     virtual void flush() {
         std::cout.flush();
     }
 
-    virtual void write(const char* str, int len) {
+    virtual size_t write(const char* str, size_t len) {
         std::cout.write(str, len);
         if (auto_flush) flush();
+        return len;
     }
 
-    virtual void write(uint8_t* str, int len) {
+    virtual size_t write(uint8_t* str, size_t len) {
         std::cout.write((const char*)str, len);
         if (auto_flush) flush();
+        return len;
+
+    }
+    size_t write(const uint8_t* str, size_t len) override {
+        std::cout.write((const char*)str, len);
+        if (auto_flush) flush();
+        return len;
     }
 
     virtual size_t write(int32_t value){
@@ -88,7 +102,7 @@ class StdioDevice : public Stream {
         return 1;
     }
 
-    virtual size_t write(uint8_t value){
+    size_t write(uint8_t value) override {
         std::cout.put(value);    
         if (auto_flush) flush();
         return 1;

ArduinoCore-Linux/cores/arduino/Arduino.h

@@ -38,11 +38,9 @@
 
 #include "ArduinoAPI.h"
 #include "ArdStdio.h"
-#include "ArduinoLogger.h"
 #include "Serial.h"
+#include "ArduinoLogger.h"
 #include "RemoteSerial.h"
 #include "HardwareSetup.h"
-#ifdef USE_RPI
-#  include "HardwareSetupRPI.h"
-#endif
-using namespace arduino;
+
+using namespace arduino;

ArduinoCore-Linux/cores/rasperry_pi/HardwareGPIO_RPI.cpp

@@ -14,9 +14,12 @@ static std::map<pin_size_t, gpiod_line*> gpio_lines;
 static gpiod_chip* gpio_chip = nullptr;
 
 HardwareGPIO_RPI::HardwareGPIO_RPI() {
+  Logger.warning("Activating Rasperry PI: GPIO");
   gpio_chip = gpiod_chip_open_by_name("gpiochip0");
   if (!gpio_chip) {
     Logger.error("HardwareGPIO_RPI", "Failed to open gpiochip0");
+  } else {
+    is_open = true;
   }
 }
 

ArduinoCore-Linux/cores/rasperry_pi/HardwareGPIO_RPI.h

@@ -91,13 +91,16 @@ class HardwareGPIO_RPI : public HardwareGPIO {
    */
   void analogWriteFrequency(uint8_t pin, uint32_t freq);
 
+  operator bool() { return is_open; }
+
  private:
   /** Analog reference mode (default AR_DEFAULT) */
   int m_analogReference = 0;
   /** Map of pin numbers to their PWM frequencies */
   std::map<pin_size_t, uint32_t> gpio_frequencies;
   /** PWM-capable pins on Raspberry Pi */
   int pwm_pins[4] = {12, 13, 18, 19};
+  bool is_open = false;
 };
 
 }  // namespace arduino

ArduinoCore-Linux/cores/rasperry_pi/HardwareI2C_RPI.cpp

@@ -16,14 +16,21 @@ void HardwareI2C_RPI::begin(uint8_t address) {
   current_address = address;
   if (ioctl(i2c_fd, I2C_SLAVE, address) < 0) {
     Logger.error("HardwareI2C_RPI: Failed to set I2C address");
+    is_open = false;
+  } else {
+    is_open = true;
   }
 }
 
 void HardwareI2C_RPI::begin() {
+  Logger.warning("Activating Rasperry PI: I2C");
   if (i2c_fd < 0) {
     i2c_fd = open(i2c_device, O_RDWR);
     if (i2c_fd < 0) {
       Logger.error("HardwareI2C_RPI: Failed to open I2C device");
+      is_open = false;
+    } else {
+      is_open = true;
     }
   }
 }

ArduinoCore-Linux/cores/rasperry_pi/HardwareI2C_RPI.h

@@ -37,6 +37,8 @@ class HardwareI2C_RPI : public HardwareI2C {
   int peek() override;
   void flush() override { fsync(i2c_fd);}
 
+  operator bool() { return is_open; }
+
  private:
   int i2c_fd = -1;
   uint8_t current_address = 0;
@@ -45,6 +47,7 @@ class HardwareI2C_RPI : public HardwareI2C {
   std::vector<uint8_t> i2c_tx_buffer;
   int i2c_rx_pos = 0;
   const char* i2c_device;
+  bool is_open = false;
 };
 
 }  // namespace arduino

ArduinoCore-Linux/cores/rasperry_pi/HardwareSPI_RPI.cpp

@@ -23,13 +23,18 @@ HardwareSPI_RPI::~HardwareSPI_RPI() {
   end();
 }
 void HardwareSPI_RPI::begin() {
+  Logger.warning("Activating Rasperry PI: SPI");
   spi_fd = open(device, O_RDWR);
   if (spi_fd < 0) {
     Logger.error("HardwareSPI_RPI: Failed to open SPI device");
+    is_open = false;
+    return;
   }
   ioctl(spi_fd, SPI_IOC_WR_MODE, &spi_mode);
   ioctl(spi_fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bits);
   ioctl(spi_fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed);
+  is_open = true;
+  return;
 }
 
 void HardwareSPI_RPI::end() {

ArduinoCore-Linux/cores/rasperry_pi/HardwareSPI_RPI.h

@@ -30,12 +30,15 @@ class HardwareSPI_RPI : public HardwareSPI {
   void begin() override;
   void end() override;
 
+  operator bool() { return is_open;  }
+  
  protected:
   int spi_fd = -1;
   const char* device = "/dev/spidev0.0";
   uint32_t spi_speed = 500000;  // Default to 500kHz
   uint8_t spi_mode = 0;         // Default to SPI mode 0
   uint8_t spi_bits = 8;         // Default to 8 bits per word
+  bool is_open = false;
 };
 
 }  // namespace arduino

ArduinoCore-Linux/cores/rasperry_pi/HardwareSetupRPI.h

@@ -1,4 +1,5 @@
 
+#pragma once
 #ifdef USE_RPI
 #include "Hardware.h" // for Hardware; 
 #include "HardwareGPIO_RPI.h"
@@ -26,11 +27,12 @@ class HardwareSetupRPI {
   /**
    * @brief Initializes hardware pointers to Raspberry Pi interfaces.
    */
-  void begin() {
+  bool begin() {
     Logger.info("Using Raspberry Pi hardware interfaces");
     Hardware.gpio = &gpio;
     Hardware.i2c = &i2c;
     Hardware.spi = &spi;
+    return gpio && i2c && spi;
   }
 
   /**