cores/psoc6: ./libraries: Add all source files from main branch.

Signed-off-by: Ramya Subramanyam <[email protected]>

Author: ramya-subramanyam

cores/psoc6/Arduino.h

@@ -20,7 +20,7 @@
 #ifndef Arduino_h
 #define Arduino_h
 
-#include "ArduinoAPI.h"
+#include "api/ArduinoAPI.h"
 #include "cyhal_gpio.h"
 
 #define RAMSTART (HMCRAMC0_ADDR)
@@ -40,32 +40,30 @@ extern "C" {
 extern const cyhal_gpio_t mapping_gpio_pin[];
 extern const uint8_t GPIO_PIN_COUNT;
 
-enum {
-    GPIO_INTERRUPT_PRIORITY = 3 // GPIO interrupt priority
-};
-
+#define GPIO_INTERRUPT_PRIORITY 3 // GPIO interrupt priority
 #define digitalPinToInterrupt(p) ((p) < GPIO_PIN_COUNT ? (p) : -1)
+#define PWM_FREQUENCY_HZ 1000 // 1 kHz
+void analogWriteResolution(int res);
 
 #undef LITTLE_ENDIAN
 
 #define clockCyclesPerMicrosecond() (SystemCoreClock / 1000000L)
 #define clockCyclesToMicroseconds(a) (((a) * 1000L) / (SystemCoreClock / 1000L))
 #define microsecondsToClockCycles(a) ((a) * (SystemCoreClock / 1000000L))
 
+typedef enum { DEFAULT } analog_reference_t;
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
+// undefine stdlib's abs if encountered
 #ifdef abs
     #undef abs
 #endif // abs
 
 #define abs(x) ((x) > 0 ? (x) : -(x))
 
-#ifndef nullptr
-    #define nullptr 0
-#endif
-
 // Globally enable or disable interrupts
 #define interrupts() __enable_irq()
 #define noInterrupts() __disable_irq()
@@ -79,7 +77,7 @@ extern "C" {
 #endif
 
 // ARM toolchain doesn't provide itoa etc, provide them
-#include "itoa.h"
+#include "api/itoa.h"
 
 #include "pins_arduino.h"
 

cores/psoc6/Uart.cpp

@@ -1,15 +1,18 @@
-#include "Arduino.h"
 #include "Uart.h"
+#include "Arduino.h"
 #include "cyhal_gpio.h"
 
-#define uart_assert(cy_ret, ret_code)   if (cy_ret != CY_RSLT_SUCCESS) { \
-            last_error = ret_code; \
-            return; \
-}
-
-
-Uart::Uart(pin_size_t tx, pin_size_t rx, pin_size_t cts, pin_size_t rts) : tx_pin(tx), rx_pin(rx), cts_pin(cts), rts_pin(rts) {
+#define uart_assert(cy_ret, ret_code) \
+    if (cy_ret != CY_RSLT_SUCCESS) {  \
+        last_error = ret_code;        \
+        return;                       \
+    }
 
+Uart::Uart(pin_size_t tx, pin_size_t rx, pin_size_t cts, pin_size_t rts)
+    : tx_pin(tx),
+      rx_pin(rx),
+      cts_pin(cts),
+      rts_pin(rts) {
 }
 
 Uart::~Uart() {
@@ -59,12 +62,13 @@ void Uart::begin(unsigned long baud, uint16_t config) {
             break;
     }
 
-
-    /* If the user does not define them (or pass NC), they are not connected. No Arduino GPIO mapping */
+    /* If the user does not define them (or pass NC), they are not connected. No Arduino GPIO
+     * mapping */
     cyhal_gpio_t cy_cts_pin = (cts_pin == NC) ? NC : mapping_gpio_pin[cts_pin];
     cyhal_gpio_t cy_rts_pin = (rts_pin == NC) ? NC : mapping_gpio_pin[rts_pin];
 
-    cy_rslt_t ret = cyhal_uart_init(&uart_obj, mapping_gpio_pin[tx_pin], mapping_gpio_pin[rx_pin], cy_cts_pin, cy_rts_pin, NULL, &uart_config);
+    cy_rslt_t ret = cyhal_uart_init(&uart_obj, mapping_gpio_pin[tx_pin], mapping_gpio_pin[rx_pin],
+                                    cy_cts_pin, cy_rts_pin, NULL, &uart_config);
     uart_assert(ret, UART_ERROR_INIT_FAILED);
     ret = cyhal_uart_set_baud(&uart_obj, baud, &actualbaud);
     uart_assert(ret, UART_ERROR_SET_BAUD_FAILED);
@@ -103,14 +107,14 @@ void Uart::flush() {
 
 int Uart::peek(void) {
     if (rx_buffer.available() == 0) {
-        return -1;       // Buffer is empty
+        return -1; // Buffer is empty
     }
     return rx_buffer.peek();
 }
 
 int Uart::read(void) {
     if (rx_buffer.available() == 0) {
-        return -1;       // Buffer is empty
+        return -1; // Buffer is empty
     }
     return rx_buffer.read_char();
 }
@@ -130,7 +134,8 @@ size_t Uart::write(const uint8_t *buffer, size_t size) {
      */
     do {
         uint32_t num_bytes_writable = cyhal_uart_writable(&uart_obj);
-        size_t bytes_to_write = left_to_write > num_bytes_writable ? num_bytes_writable : left_to_write;
+        size_t bytes_to_write =
+            left_to_write > num_bytes_writable ? num_bytes_writable : left_to_write;
         /* Trying to write 0 size will throw an exception. */
         if (bytes_to_write > 0) {
             cy_rslt_t result = cyhal_uart_write(&uart_obj, (void *)buffer, &bytes_to_write);
@@ -153,13 +158,13 @@ uart_error_t Uart::getLastError() {
     return last_error;
 }
 
-void Uart::uart_event_handler(void* handler_arg, cyhal_uart_event_t event) {
-    Uart* uart = static_cast<Uart*>(handler_arg);
+void Uart::uart_event_handler(void *handler_arg, cyhal_uart_event_t event) {
+    Uart *uart = static_cast<Uart *>(handler_arg);
     uart->IrqHandler();
 }
 
 void Uart::IrqHandler() {
-    uint8_t c = 0;
+    uint8_t c;
     size_t size = 1;
     while (cyhal_uart_readable(&uart_obj) > 0) {
         cyhal_uart_read(&uart_obj, &c, &size);

cores/psoc6/Uart.h

@@ -12,7 +12,6 @@ typedef enum {
 
 class Uart : public arduino::HardwareSerial {
 public:
-
     Uart(pin_size_t tx, pin_size_t rx, pin_size_t cts = NC, pin_size_t rts = NC);
     ~Uart();
     void begin(unsigned long baud);
@@ -33,10 +32,7 @@ class Uart : public arduino::HardwareSerial {
 
     static void uart_event_handler(void *handler_arg, cyhal_uart_event_t event);
 
-    static void uart_event_handler(void* handler_arg, cyhal_uart_event_t event);
-
 private:
-
     pin_size_t tx_pin;
     pin_size_t rx_pin;
     pin_size_t cts_pin;
@@ -48,7 +44,7 @@ class Uart : public arduino::HardwareSerial {
     uart_error_t last_error = UART_ERROR_NONE;
 
     static constexpr size_t BUFFER_LENGTH = 512;
-    arduino::RingBufferN < BUFFER_LENGTH > rx_buffer;
+    arduino::RingBufferN<BUFFER_LENGTH> rx_buffer;
 
     void IrqHandler();
 };

cores/psoc6/analog_io.c

@@ -0,0 +1,164 @@
+#include "Arduino.h"
+#include "cyhal_adc.h"
+#include "cyhal_pwm.h"
+
+// Constants and Macros
+
+#define MIN_ACQUISITION_TIME 220
+#define adc_assert(cy_ret)           \
+    if (cy_ret != CY_RSLT_SUCCESS) { \
+        return 0xff;                 \
+    }
+#define pwm_assert(cy_ret)           \
+    if (cy_ret != CY_RSLT_SUCCESS) { \
+        return;                      \
+    }
+
+#define PWM_RESOLUTION_8_BIT 255.0
+#define PWM_RESOLUTION_10_BIT 1023.0
+#define PWM_RESOLUTION_12_BIT 4095.0
+#define PWM_RESOLUTION_16_BIT 65535.0
+
+// Type Definitions
+
+typedef struct {
+    pin_size_t pin;
+    cyhal_adc_channel_t chan_obj;
+    bool initialized;
+} adc_channel_t;
+
+typedef struct {
+    cyhal_pwm_t pwm_obj;
+    pin_size_t pin;
+    bool initialized;
+} pwm_t;
+
+// Static Variables
+
+static cyhal_adc_t adc_obj = {0};
+static cyhal_adc_vref_t desiredVRef = CYHAL_ADC_REF_VDDA;
+static bool adc_initialized = false;
+static adc_channel_t adc_channel[ADC_HOWMANY] = {0};
+static float desiredWriteResolution = PWM_RESOLUTION_8_BIT;
+static pwm_t pwm[PWM_HOWMANY] = {0};
+
+static cy_rslt_t initialize_adc(pin_size_t pinNumber) {
+    if (!adc_initialized) {
+        cy_rslt_t status = cyhal_adc_init(&adc_obj, mapping_gpio_pin[pinNumber], NULL);
+        adc_assert(status);
+        adc_initialized = true;
+    }
+
+    // Configure ADC settings
+    cyhal_adc_config_t adc_config = {.continuous_scanning = false,
+                                     .resolution = ADC_RESOLUTION,
+                                     .average_count = 1,
+                                     .vneg = CYHAL_ADC_VNEG_VSSA,
+                                     .vref = desiredVRef,
+                                     .ext_vref = NC,
+                                     .bypass_pin = NC};
+
+    return cyhal_adc_configure(&adc_obj, &adc_config);
+}
+
+static cy_rslt_t initialize_adc_channel(pin_size_t pinNumber, uint8_t adc_index) {
+    // Ensure ADC hardware is initialized
+    cy_rslt_t status = initialize_adc(pinNumber);
+    adc_assert(status);
+
+    // Configure individual ADC channel
+    cyhal_adc_channel_config_t chan_config = {
+        .enabled = true, .enable_averaging = false, .min_acquisition_ns = MIN_ACQUISITION_TIME};
+
+    status = cyhal_adc_channel_init_diff(&adc_channel[adc_index].chan_obj, &adc_obj,
+                                         mapping_gpio_pin[pinNumber], CYHAL_ADC_VNEG, &chan_config);
+    adc_assert(status);
+
+    adc_channel[adc_index].pin = pinNumber;
+    adc_channel[adc_index].initialized = true;
+
+    return status;
+}
+
+int analogRead(pin_size_t pinNumber) {
+    int adc_value = 0;
+    uint8_t adc_index = 0;
+
+    // Find existing channel or initialize a new one
+    for (adc_index = 0; adc_index < ADC_HOWMANY; adc_index++) {
+        if (adc_channel[adc_index].initialized) {
+            if (adc_channel[adc_index].pin == pinNumber) {
+                // Found an existing channel for the pin
+                break;
+            }
+        } else {
+            // Found an uninitialized channel, initialize it
+            cy_rslt_t result = initialize_adc_channel(pinNumber, adc_index);
+            adc_assert(result);
+            break;
+        }
+    }
+
+    if (adc_index < ADC_HOWMANY) {
+        adc_value = cyhal_adc_read(&adc_channel[adc_index].chan_obj);
+    }
+    return adc_value;
+}
+
+void analogReference(uint8_t mode) {
+    desiredVRef = CYHAL_ADC_REF_VDDA;
+}
+
+void analogWriteResolution(int res) {
+    if (res > 12) {
+        desiredWriteResolution = PWM_RESOLUTION_16_BIT;
+    } else if (res > 10) {
+        desiredWriteResolution = PWM_RESOLUTION_12_BIT;
+    } else if (res > 8) {
+        desiredWriteResolution = PWM_RESOLUTION_10_BIT;
+    } else {
+        desiredWriteResolution = PWM_RESOLUTION_8_BIT;
+    }
+}
+
+void analogWrite(pin_size_t pinNumber, int value) {
+    uint8_t pwm_index = 0;
+    cy_rslt_t result = CY_RSLT_TYPE_ERROR;
+
+    if (pinNumber > GPIO_PIN_COUNT) {
+        return; // Invalid pin number
+    }
+
+    // Find existing channel or initialize a new one
+    for (pwm_index = 0; pwm_index < PWM_HOWMANY; pwm_index++) {
+        if (pwm[pwm_index].initialized) {
+            if (pwm[pwm_index].pin == pinNumber) {
+                // Found an existing channel for the pin
+                break;
+            }
+        } else {
+            // Found an uninitialized channel, initialize it
+            result = cyhal_pwm_init(&pwm[pwm_index].pwm_obj, mapping_gpio_pin[pinNumber], NULL);
+            pwm_assert(result);
+            pwm[pwm_index].pin = pinNumber;
+            pwm[pwm_index].initialized = true;
+            break;
+        }
+    }
+
+    if (value < 0) {
+        value = 0;
+    }
+    if (value > desiredWriteResolution) {
+        value = desiredWriteResolution;
+    }
+
+    float duty_cycle_pertentage = (value / desiredWriteResolution) * 100.0f;
+
+    result =
+        cyhal_pwm_set_duty_cycle(&pwm[pwm_index].pwm_obj, duty_cycle_pertentage, PWM_FREQUENCY_HZ);
+    pwm_assert(result);
+
+    result = cyhal_pwm_start(&pwm[pwm_index].pwm_obj);
+    pwm_assert(result);
+}

cores/psoc6/interrupts.c

@@ -53,7 +53,7 @@ void attachInterrupt(pin_size_t interruptNumber, voidFuncPtr callback, PinStatus
             break;
     }
 
-    gpio_callback_data.callback = (void (*)(void*, cyhal_gpio_event_t))callback;
+    gpio_callback_data.callback = (void (*)(void *, cyhal_gpio_event_t))callback;
     cyhal_gpio_register_callback(pin, &gpio_callback_data);
     cyhal_gpio_enable_event(pin, event, GPIO_INTERRUPT_PRIORITY, true);
 }

cores/psoc6/main.cpp

@@ -21,6 +21,7 @@
 #include "Arduino.h"
 
 #include "cy_retarget_io.h"
+#include "cybsp.h"
 
 #include <FreeRTOS.h>
 #include <task.h>
@@ -32,7 +33,7 @@
 
 TaskHandle_t arduino_main_task_handle;
 
-void arduino_main_task(void* arg);
+void arduino_main_task(void *arg);
 
 // Weak empty variant initialization function.
 // May be redefined by variant files.
@@ -44,8 +45,8 @@ void initVariant() {
 /*
  * \brief Main entry point of Arduino application
  */
-int main() {
-    cy_rslt_t result = 0;
+int main(void) {
+    cy_rslt_t result;
 
     result = cybsp_init();
     if (result != CY_RSLT_SUCCESS) {
@@ -63,7 +64,7 @@ int main() {
     return 0;
 }
 
-void arduino_main_task(void* arg) {
+void arduino_main_task(void *arg) {
 
     /* Enable global interrupts */
     interrupts();
@@ -73,5 +74,8 @@ void arduino_main_task(void* arg) {
 
     for (;;) {
         loop();
+        if (arduino::serialEventRun) {
+            arduino::serialEventRun();
+        }
     }
 }