feat: enhance Print class with float support and printf functionality

Signed-off-by: Aymane Bahssain <[email protected]>

Author: Aymane-ST

Common.h

@@ -36,11 +36,14 @@ typedef enum {
 } PinStatus;
 
 typedef enum {
-  INPUT            = 0x0,
-  OUTPUT           = 0x1,
-  INPUT_PULLUP     = 0x2,
-  INPUT_PULLDOWN   = 0x3,
-  OUTPUT_OPENDRAIN = 0x4,
+  INPUT             = 0x0,
+  OUTPUT            = 0x1,
+  INPUT_PULLUP      = 0x2,
+  INPUT_FLOATING    = INPUT,
+  INPUT_PULLDOWN    = 0x3,
+  INPUT_ANALOG      = 0x4,
+  OUTPUT_OPEN_DRAIN = 0x5,
+  OUTPUT_OPENDRAIN  = OUTPUT_OPEN_DRAIN,
 } PinMode;
 
 typedef enum {
@@ -93,12 +96,12 @@ typedef void (*voidFuncPtrParam)(void*);
 #endif
 
 /* TODO: request for removal */
-typedef bool      boolean;
+typedef bool boolean __attribute__((deprecated));
 typedef uint8_t   byte;
 typedef uint16_t  word;
 
 void init(void);
-void initVariant(void);
+extern void initVariant() __attribute__((weak));
 
 #ifndef HOST
 int atexit(void (*func)()) __attribute__((weak));
@@ -141,13 +144,13 @@ void loop(void);
 #endif
 
 #ifdef __cplusplus
-  template<class T, class L> 
+  template<class T, class L>
   auto min(const T& a, const L& b) -> decltype((b < a) ? b : a)
   {
     return (b < a) ? b : a;
   }
 
-  template<class T, class L> 
+  template<class T, class L>
   auto max(const T& a, const L& b) -> decltype((b < a) ? b : a)
   {
     return (a < b) ? b : a;

Print.cpp

@@ -21,11 +21,17 @@
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
+#include <unistd.h>
 
+#include "uart.h"
 #include "Print.h"
 
 using namespace arduino;
 
+#if defined (VIRTIO_LOG)
+  #include "virtio_log.h"
+#endif
+
 // Public Methods //////////////////////////////////////////////////////////////
 
 /* default implementation: may be overridden */
@@ -130,6 +136,11 @@ size_t Print::print(unsigned long long n, int base)
   else return printULLNumber(n, base);
 }
 
+size_t Print::print(float n, int digits)
+{
+  return printFloat(n, digits);
+}
+
 size_t Print::print(double n, int digits)
 {
   return printFloat(n, digits);
@@ -222,6 +233,13 @@ size_t Print::println(unsigned long long num, int base)
   return n;
 }
 
+size_t Print::println(float num, int digits)
+{
+  size_t n = print(num, digits);
+  n += println();
+  return n;
+}
+
 size_t Print::println(double num, int digits)
 {
   size_t n = print(num, digits);
@@ -236,6 +254,58 @@ size_t Print::println(const Printable& x)
   return n;
 }
 
+extern "C" {
+  __attribute__((weak))
+  int _write(int file, char *ptr, int len)
+  {
+    switch (file) {
+      case STDOUT_FILENO:
+      case STDERR_FILENO:
+        /* Used for core_debug() */
+#if defined (VIRTIO_LOG)
+        virtio_log((uint8_t *)ptr, (uint32_t)len);
+#elif defined(HAL_UART_MODULE_ENABLED) && !defined(HAL_UART_MODULE_ONLY)
+        uart_debug_write((uint8_t *)ptr, (uint32_t)len);
+#endif
+        break;
+      case STDIN_FILENO:
+        break;
+      default:
+        ((class Print *)file)->write((uint8_t *)ptr, len);
+        break;
+    }
+    return len;
+  }
+}
+
+int Print::printf(const char *format, ...)
+{
+  va_list ap;
+  va_start(ap, format);
+  int retval = vdprintf((int)this, format, ap);
+  va_end(ap);
+  return retval;
+}
+
+int Print::printf(const __FlashStringHelper *format, ...)
+{
+  va_list ap;
+  va_start(ap, format);
+  int retval = vdprintf((int)this, (const char *)format, ap);
+  va_end(ap);
+  return retval;
+}
+
+int Print::vprintf(const char *format, va_list ap)
+{
+  return vdprintf((int)this, format, ap);
+}
+
+int Print::vprintf(const __FlashStringHelper *format, va_list ap)
+{
+  return vdprintf((int)this, (const char *)format, ap);
+}
+
 // Private Methods /////////////////////////////////////////////////////////////
 
 size_t Print::printNumber(unsigned long n, uint8_t base)

Print.h

@@ -21,6 +21,7 @@
 
 #include <inttypes.h>
 #include <stdio.h> // for size_t
+#include <stdarg.h> // for printf
 
 #include "String.h"
 #include "Printable.h"
@@ -72,6 +73,7 @@ class Print
     size_t print(unsigned long, int = DEC);
     size_t print(long long, int = DEC);
     size_t print(unsigned long long, int = DEC);
+    size_t print(float, int = 2);
     size_t print(double, int = 2);
     size_t print(const Printable&);
 
@@ -86,12 +88,18 @@ class Print
     size_t println(unsigned long, int = DEC);
     size_t println(long long, int = DEC);
     size_t println(unsigned long long, int = DEC);
+    size_t println(float, int = 2);
     size_t println(double, int = 2);
     size_t println(const Printable&);
     size_t println(void);
 
+    int printf(const char *format, ...);
+    int printf(const __FlashStringHelper *format, ...);
+    int vprintf(const __FlashStringHelper *format, va_list ap);
+    int vprintf(const char *format, va_list ap);
+
     virtual void flush() { /* Empty implementation for backward compatibility */ }
 };
 
 }
-using arduino::Print;
+using arduino::Print;

RingBuffer.h

@@ -31,7 +31,7 @@ namespace arduino {
 // using a ring buffer (I think), in which head is the index of the location
 // to which to write the next incoming character and tail is the index of the
 // location from which to read.
-#define SERIAL_BUFFER_SIZE 64
+#define SERIAL_BUFFER_SIZE 128 //64
 
 template <int N>
 class RingBufferN