Merge branch 'ftdi'

Author: pschatzmann

Arduino.cmake

@@ -119,5 +119,14 @@ function(arduino_sketch name ino_file)
         target_compile_definitions(${name} PUBLIC ${ARG_DEFINITIONS})
     endif()
 
+    # Handle FTDI support if specified
+    if (USE_FTDI)
+        # Find and link libftdi1
+        find_package(PkgConfig REQUIRED)
+        pkg_check_modules(FTDI REQUIRED libftdi1)
+        target_link_libraries(${name} ${FTDI_LIBRARIES})
+        target_include_directories(${name} PUBLIC ${FTDI_INCLUDE_DIRS})
+        target_compile_options(${name} PUBLIC ${FTDI_CFLAGS_OTHER})
+    endif(USE_FTDI)
 endfunction()
 

ArduinoCore-Linux/cores/arduino/Arduino.cpp

@@ -1,5 +1,5 @@
 /*
-  Arduino.cpp 
+  Arduino.cpp
   Copyright (c) 2025 Phil Schatzmann. All right reserved.
 
   This library is free software; you can redistribute it and/or
@@ -17,7 +17,9 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #include "Arduino.h"
+
 #include <stdio.h>
+
 #include <chrono>
 #include <cstring>
 #include <ctime>
@@ -57,23 +59,39 @@ PluggableUSB_::PluggableUSB_() {}
 
 }  // namespace arduino
 
-// sleep ms milliseconds
+/**
+ * @brief Pause the program for the amount of time (in milliseconds) specified as parameter
+ * @param ms The number of milliseconds to pause (unsigned long)
+ */
 void delay(unsigned long ms) {
   std::this_thread::sleep_for(std::chrono::milliseconds(ms));
 }
 
-// sleep us milliseconds
+/**
+ * @brief Pause the program for the amount of time (in microseconds) specified as parameter
+ * @param us The number of microseconds to pause (unsigned int)
+ */
 void delayMicroseconds(unsigned int us) {
   std::this_thread::sleep_for(std::chrono::microseconds(us));
 }
 
-// double to string conversion -> we can use sprintf which is complete in linux
+/**
+ * @brief Convert a floating point number to string
+ * @param val The double value to convert
+ * @param width The minimum field width (signed char)
+ * @param prec The precision (number of digits after decimal point)
+ * @param sout The output string buffer
+ * @return Pointer to the output string
+ */
 char* dtostrf(double val, signed char width, unsigned char prec, char* sout) {
   sprintf(sout, "%*.*lf", width, prec, val);
   return sout;
 }
 
-// Returns the number of milliseconds passed since epich
+/**
+ * @brief Returns the number of milliseconds passed since the Arduino board began running the current program
+ * @return Number of milliseconds passed since the program started (unsigned long)
+ */
 unsigned long millis() {
   static uint64_t start = 0;
   using namespace std::chrono;
@@ -89,7 +107,10 @@ unsigned long millis() {
   return result - start;
 }
 
-// Returns the micros of milliseconds passed since epich
+/**
+ * @brief Returns the number of microseconds since the Arduino board began running the current program
+ * @return Number of microseconds passed since the program started (unsigned long)
+ */
 unsigned long micros(void) {
   using namespace std::chrono;
   // Get current time with precision of milliseconds
@@ -100,30 +121,114 @@ unsigned long micros(void) {
   return now.time_since_epoch().count();
 }
 
+/**
+ * @brief Configure the specified pin to behave either as an input or an output
+ * @param pinNumber The pin whose mode you wish to set
+ * @param pinMode INPUT, OUTPUT, or INPUT_PULLUP
+ */
 void pinMode(pin_size_t pinNumber, PinMode pinMode) {
   GPIO.pinMode(pinNumber, pinMode);
 }
+
+/**
+ * @brief Write a HIGH or a LOW value to a digital pin
+ * @param pinNumber The pin number
+ * @param status HIGH or LOW
+ */
 void digitalWrite(pin_size_t pinNumber, PinStatus status) {
   GPIO.digitalWrite(pinNumber, status);
 }
+
+/**
+ * @brief Reads the value from a specified digital pin, either HIGH or LOW
+ * @param pinNumber The number of the digital pin you want to read
+ * @return HIGH or LOW
+ */
 PinStatus digitalRead(pin_size_t pinNumber) {
   return GPIO.digitalRead(pinNumber);
 }
+
+/**
+ * @brief Reads the value from the specified analog pin
+ * @param pinNumber The number of the analog input pin to read from (0 to 5 on most boards)
+ * @return The analog reading on the pin (int 0 to 1023)
+ */
 int analogRead(pin_size_t pinNumber) { return GPIO.analogRead(pinNumber); }
+
+/**
+ * @brief Configures the reference voltage used for analog input
+ * @param mode Which type of reference to use (DEFAULT, INTERNAL, EXTERNAL)
+ */
 void analogReference(uint8_t mode) { GPIO.analogReference(mode); }
+
+/**
+ * @brief Writes an analog value (PWM wave) to a pin
+ * @param pinNumber The pin to write to
+ * @param value The duty cycle: between 0 (always off) and 255 (always on)
+ */
 void analogWrite(pin_size_t pinNumber, int value) {
   GPIO.analogWrite(pinNumber, value);
 }
+
+
+/**
+ * @brief Generates a square wave of the specified frequency (and 50% duty cycle) on a pin
+ * @param pinNumber The pin on which to generate the tone
+ * @param frequency The frequency of the tone in hertz - unsigned int
+ * @param duration The duration of the tone in milliseconds (optional) - unsigned long
+ */
 void tone(uint8_t pinNumber, unsigned int frequency, unsigned long duration) {
   GPIO.tone(pinNumber, frequency, duration);
 }
+
+/**
+ * @brief Stops the generation of a square wave triggered by tone()
+ * @param pinNumber The pin on which to stop generating the tone
+ */
 void noTone(uint8_t pinNumber) { GPIO.noTone(pinNumber); }
+
+/**
+ * @brief Reads a pulse (either HIGH or LOW) on a pin
+ * @param pinNumber The number of the pin on which you want to read the pulse
+ * @param state Type of pulse to read: either HIGH or LOW
+ * @param timeout The number of microseconds to wait for the pulse to be completed (optional)
+ * @return The length of the pulse (in microseconds) or 0 if no complete pulse was received within the timeout
+ */
 unsigned long pulseIn(uint8_t pinNumber, uint8_t state, unsigned long timeout) {
   return GPIO.pulseIn(pinNumber, state, timeout);
 }
+
+/**
+ * @brief Alternative to pulseIn() which is better at handling long pulses and interrupt affected systems
+ * @param pinNumber The number of the pin on which you want to read the pulse
+ * @param state Type of pulse to read: either HIGH or LOW
+ * @param timeout The number of microseconds to wait for the pulse to be completed (optional)
+ * @return The length of the pulse (in microseconds) or 0 if no complete pulse was received within the timeout
+ */
 unsigned long pulseInLong(uint8_t pinNumber, uint8_t state,
                           unsigned long timeout) {
   return GPIO.pulseInLong(pinNumber, state, timeout);
 }
 
+/**
+ * @brief Set the PWM frequency for analogWrite() on the specified pin
+ * @param pin The pin number to configure PWM frequency for
+ * @param freq The desired PWM frequency in Hz
+ */
+void analogWriteFrequency(pin_size_t pin, uint32_t freq) {
+  GPIO.analogWriteFrequency(pin, freq);
+}
+
+/**
+ * @brief Set the resolution of the analogWrite() values
+ * @param bits The resolution in bits (e.g., 8 for 0-255, 10 for 0-1023)
+ */
+void analogWriteResolution(uint8_t bits) { 
+  GPIO.analogWriteResolution(bits); 
+}
+
+/**
+ * @brief Passes control to other tasks when called
+ * @note This is used to prevent watchdog timer resets in long-running loops
+ */
 void yield() {}

ArduinoCore-Linux/cores/arduino/Arduino.h

@@ -46,3 +46,7 @@
 #include "HardwareSetup.h"
 
 using namespace arduino;
+
+// supported by some platforms
+void analogWriteFrequency(pin_size_t pin, uint32_t freq);
+void analogWriteResolution(uint8_t bits);

ArduinoCore-Linux/cores/arduino/GPIOWrapper.cpp

@@ -1,25 +1,30 @@
 /*
-	GPIOWrapper.cpp
-	Copyright (c) 2025 Phil Schatzmann. All right reserved.
-
-	This library is free software; you can redistribute it and/or
-	modify it under the terms of the GNU Lesser General Public
-	License as published by the Free Software Foundation; either
-	version 2.1 of the License, or (at your option) any later version.
-
-	This library is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-	Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public
-	License along with this library; if not, write to the Free Software
-	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+        GPIOWrapper.cpp
+        Copyright (c) 2025 Phil Schatzmann. All right reserved.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public
+        License as published by the Free Software Foundation; either
+        version 2.1 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+        Lesser General Public License for more details.
+
+        You should have received a copy of the GNU Lesser General Public
+        License along with this library; if not, write to the Free Software
+        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
 #include "GPIOWrapper.h"
+
+#include "ArduinoLogger.h"
 #include "HardwareGPIO.h"
 #include "HardwareService.h"
+#ifdef USE_FTDI
+#include "../ftdi/HardwareGPIO_FTDI.h"
+#endif
 
 /**
  * We support different implementations for the GPIO
@@ -75,6 +80,7 @@ void GPIOWrapper::analogWrite(pin_size_t pinNumber, int value) {
   }
 }
 
+
 void GPIOWrapper::tone(uint8_t _pin, unsigned int frequency,
                        unsigned long duration) {
   HardwareGPIO* gpio = getGPIO();
@@ -110,4 +116,18 @@ unsigned long GPIOWrapper::pulseInLong(uint8_t pin, uint8_t state,
   }
 }
 
+void GPIOWrapper::analogWriteFrequency(pin_size_t pin, uint32_t freq) {
+  HardwareGPIO* gpio = getGPIO();
+  if (gpio != nullptr) {
+    gpio->analogWriteFrequency(pin, freq);
+  }
+}
+
+void GPIOWrapper::analogWriteResolution(uint8_t bits) {
+  HardwareGPIO* gpio = getGPIO();
+  if (gpio != nullptr) {
+    gpio->analogWriteResolution(bits);
+  }
+}
+
 }  // namespace arduino