Merge branch 'SuperHouse/master'

core/cplusplus_operators.cpp

@@ -4,22 +4,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-void *operator new(size_t size)
+void * __attribute__((weak)) operator new(size_t size)
 {
     return malloc(size);
 }
 
-void *operator new[](size_t size)
+void * __attribute__((weak)) operator new[](size_t size)
 {
     return malloc(size);
 }
 
-void operator delete(void * ptr)
+void __attribute__((weak)) operator delete(void * ptr)
 {
     free(ptr);
 }
 
-void operator delete[](void * ptr)
+void __attribute__((weak)) operator delete[](void * ptr)
 {
     free(ptr);
 }

core/include/esp/gpio_regs.h

@@ -70,7 +70,7 @@ struct GPIO_REGS {
     uint32_t volatile STATUS_SET;       // 0x20
     uint32_t volatile STATUS_CLEAR;     // 0x24
     uint32_t volatile CONF[16];         // 0x28 - 0x64
-    uint32_t volatile PWM;              // 0x68
+    uint32_t volatile DSM;              // 0x68
     uint32_t volatile RTC_CALIB;        // 0x6c
     uint32_t volatile RTC_CALIB_RESULT; // 0x70
 };
@@ -117,9 +117,9 @@ _Static_assert(sizeof(struct GPIO_REGS) == 0x74, "GPIO_REGS is the wrong size");
  *     GPIO_CONF_OPEN_DRAIN does not appear to work on all pins.
  *
  *
- * GPIO_CONF_SOURCE_PWM (boolean)
+ * GPIO_CONF_SOURCE_DSM (boolean)
- *     When set, GPIO pin output will be connected to the sigma-delta PWM
+ *     When set, GPIO pin output will be connected to the sigma-delta
- *     generator (controlled by the GPIO.PWM register).  When cleared, pin
+ *     generator (controlled by the GPIO.DSM register).  When cleared, pin
  *     output will function as a normal GPIO output (controlled by the
  *     GPIO.OUT* registers).
  */
@@ -130,7 +130,7 @@ _Static_assert(sizeof(struct GPIO_REGS) == 0x74, "GPIO_REGS is the wrong size");
 #define GPIO_CONF_INTTYPE_M      0x00000007
 #define GPIO_CONF_INTTYPE_S      7
 #define GPIO_CONF_OPEN_DRAIN     BIT(2)
-#define GPIO_CONF_SOURCE_PWM     BIT(0)
+#define GPIO_CONF_SOURCE_DSM     BIT(0)
 
 /* Valid values for the GPIO_CONF_INTTYPE field */
 typedef enum {
@@ -142,13 +142,13 @@ typedef enum {
     GPIO_INTTYPE_LEVEL_HIGH = 5,
 } gpio_inttype_t;
 
-/* Details for PWM register */
+/* Details for DSM register */
 
-#define GPIO_PWM_ENABLE          BIT(16)
+#define GPIO_DSM_ENABLE          BIT(16)
-#define GPIO_PWM_PRESCALER_M     0x000000ff
+#define GPIO_DSM_PRESCALER_M     0x000000ff
-#define GPIO_PWM_PRESCALER_S     8
+#define GPIO_DSM_PRESCALER_S     8
-#define GPIO_PWM_TARGET_M        0x000000ff
+#define GPIO_DSM_TARGET_M        0x000000ff
-#define GPIO_PWM_TARGET_S        0
+#define GPIO_DSM_TARGET_S        0
 
 /* Details for RTC_CALIB register */
 

core/sysparam.c

@@ -505,6 +505,8 @@ sysparam_status_t sysparam_init(uint32_t base_addr, uint32_t top_addr) {
     struct sysparam_context ctx;
     uint16_t num_sectors;
 
+    _sysparam_info.sem = xSemaphoreCreateMutex();
+
     // Make sure we're starting at the beginning of the sector
     base_addr -= (base_addr % sdk_flashchip.sector_size);
 
@@ -584,8 +586,6 @@ sysparam_status_t sysparam_init(uint32_t base_addr, uint32_t top_addr) {
         _sysparam_info.end_addr = ctx.addr;
     }
 
-    _sysparam_info.sem = xSemaphoreCreateMutex();
-
     return SYSPARAM_OK;
 }
 

examples/dsm_test/Makefile

@@ -0,0 +1,4 @@
+# Simple makefile for simple example
+PROGRAM=dsm_test
+EXTRA_COMPONENTS = extras/dsm
+include ../../common.mk

examples/dsm_test/dsm_test.c

@@ -0,0 +1,67 @@
+/* Very basic example to test the dsm library
+ * Led intensity from module will change over time.
+ *
+ * Part of esp-open-rtos
+ * Copyright (C) 2018 zaltora (https://github.com/Zaltora)
+ * BSD Licensed as described in the file LICENSE
+ */
+#include "espressif/esp_common.h"
+#include "esp/uart.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "dsm.h"
+
+#define TEST_WITH_160MHZ (0)
+#define DSM_PIN          (2)
+
+void task1(void *pvParameters)
+{
+    uint32_t const init_count = 0;
+    uint32_t count = init_count;
+    while(1)
+    {
+        vTaskDelay(100/portTICK_PERIOD_MS);
+        printf("Target set to %3u, ", count);
+        //Freq = (80,000,000/prescale) * (target / 256) HZ           (0   < target < 128)
+        //Freq = (80,000,000/prescale) * ((256 - target) / 256)  HZ  (128 < target < 256)
+        if (count < 128)
+        {
+           printf("Freqency: %.1f Hz\r\n", (80000000.0/255.0 * (count/ 256.0)));
+        }
+        else
+        {
+            printf("Freqency: %.1f Hz\r\n", 80000000.0/255.0 * ((256.0-count)/ 256.0));
+        }
+        dsm_set_target(count);
+        count++;
+        if (count > UINT8_MAX)
+            count = init_count;
+    }
+}
+
+void user_init(void)
+{
+    uint8_t pins[1];
+    uart_set_baud(0, 115200);
+
+#if (TEST_WITH_160MHZ)
+    sdk_system_update_cpu_freq(160);
+#endif
+
+    printf("SDK version:%s\r\n", sdk_system_get_sdk_version());
+
+    pins[0] = DSM_PIN;
+
+    /* register pin to use with DSM */
+    dsm_init(1, pins);
+    /* Set prescale to FF to get a proper signal */
+    dsm_set_prescale(0xFF);
+    /* Target initial */
+    dsm_set_target(0);
+    /* start dsm to pin */
+    dsm_start();
+
+    printf("dsm start\r\n");
+
+    xTaskCreate(task1, "tsk1", 256, NULL, 2, NULL);
+}

extras/dsm/component.mk

@@ -0,0 +1,9 @@
+# Component makefile for extras/dsm
+
+INC_DIRS += $(ROOT)extras/dsm
+
+# args for passing into compile rule generation
+extras/dsm_INC_DIR =  $(ROOT)extras/dsm
+extras/dsm_SRC_DIR =  $(ROOT)extras/dsm
+
+$(eval $(call component_compile_rules,extras/dsm))

extras/dsm/dsm.c

@@ -0,0 +1,111 @@
+/* Implementation of Delta-Sigma modulator support.
+ *
+ * Part of esp-open-rtos
+ * Copyright (C) 2018 ourairquality (https://github.com/ourairquality)
+ * Copyright (C) 2018 Zaltora (https://github.com/Zaltora)
+ * BSD Licensed as described in the file LICENSE
+ */
+#include "dsm.h"
+
+#include <espressif/esp_common.h>
+#include <esp8266.h>
+
+
+#if (DSM_DEBUG)
+#define debug(fmt, ...) printf("%s: " fmt "\n", "DSM", ## __VA_ARGS__)
+#else
+#define debug(fmt, ...)
+#endif
+
+typedef struct dsmInfoDefinition
+{
+    uint8_t running;
+    uint8_t preScale;
+    uint8_t target;
+    bool output;
+
+    /* private */
+    uint8_t usedPins;
+    uint8_t pins[8];
+} DSMInfo;
+
+static DSMInfo dsmInfo;
+
+void dsm_init(uint8_t npins, const uint8_t* pins)
+{
+    /* Assert number of pins is correct */
+    if (npins > MAX_DSM_PINS)
+    {
+        debug("Incorrect number of DSM pins (%d)\n", npins);
+        return;
+    }
+
+    /* Save pins information */
+    dsmInfo.usedPins = npins;
+
+    for (uint8_t i = 0 ; i < npins; ++i)
+    {
+        dsmInfo.pins[i] = pins[i];
+        /* configure GPIOs */
+        gpio_enable(pins[i], GPIO_OUTPUT);
+    }
+
+    /* Set output to LOW */
+    dsm_stop();
+
+    /* Flag not running */
+    dsmInfo.running = 0;
+}
+
+void dsm_set_prescale(uint8_t prescale)
+{
+    //TODO: Add a freq/prescale converter
+    dsmInfo.preScale = prescale;
+    debug("Set Prescale: %u",dsmInfo.preScale);
+}
+
+void dsm_set_target(uint8_t target)
+{
+    dsmInfo.target = target;
+    if (target == 0 || target == UINT8_MAX)
+    {
+      dsmInfo.output = (target == UINT8_MAX);
+    }
+    debug("Duty set at %u",dsmInfo.target);
+    if (dsmInfo.running)
+    {
+        dsm_start();
+    }
+}
+
+void dsm_start()
+{
+    if (dsmInfo.target > 0 && dsmInfo.target < UINT8_MAX)
+    {
+        for (uint8_t i = 0; i < dsmInfo.usedPins; ++i)
+        {
+            SET_MASK_BITS(GPIO.CONF[dsmInfo.pins[i]], GPIO_CONF_SOURCE_DSM);
+        }
+        GPIO.DSM = GPIO_DSM_ENABLE | (dsmInfo.preScale << 8) | dsmInfo.target;
+    }
+    else
+    {
+      for (uint8_t i = 0; i < dsmInfo.usedPins; ++i)
+      {
+        gpio_write(dsmInfo.pins[i], dsmInfo.output );
+      }       
+    }
+    debug("start");
+    dsmInfo.running = 1;
+}
+
+void dsm_stop()
+{
+    for (uint8_t i = 0; i < dsmInfo.usedPins; ++i)
+    {
+      CLEAR_MASK_BITS(GPIO.CONF[dsmInfo.pins[i]], GPIO_CONF_SOURCE_DSM);
+      gpio_write(dsmInfo.pins[i], false);
+    }       
+    debug("stop");
+    dsmInfo.running = 0;
+}

extras/dsm/dsm.h

@@ -0,0 +1,36 @@
+/* Implementation of Delta-Sigma modulator support.
+ *
+ * Part of esp-open-rtos
+ * Copyright (C) 2018 ourairquality (https://github.com/ourairquality)
+ * Copyright (C) 2018 Zaltora (https://github.com/Zaltora)
+ * BSD Licensed as described in the file LICENSE
+ */
+#ifndef EXTRAS_DSM_H_
+#define EXTRAS_DSM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define MAX_DSM_PINS    (8)
+#define DSM_DEBUG       (0)
+
+/*
+ * Freq = (80,000,000/prescale) * (target / 256) HZ           (0   < target < 128)
+ * Freq = (80,000,000/prescale) * ((256 - target) / 256)  HZ  (128 < target < 256)
+ */
+
+void dsm_init(uint8_t npins, const uint8_t* pins);
+void dsm_set_prescale(uint8_t prescale);
+void dsm_set_target(uint8_t target);
+
+void dsm_start();
+void dsm_stop();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EXTRAS_DSM_H_ */

extras/i2c/i2c.c

@@ -32,6 +32,7 @@
 //#define I2C_DEBUG true
 
 #ifdef I2C_DEBUG
+#include <stdio.h>
 #define debug(fmt, ...) printf("%s: " fmt "\n", "I2C", ## __VA_ARGS__)
 #else
 #define debug(fmt, ...)

extras/ssd1306/component.mk

@@ -7,11 +7,13 @@ INC_DIRS += $(ssd1306_ROOT)..
 SSD1306_I2C_SUPPORT ?= 1
 # SPI4 support is on by default
 SSD1306_SPI4_SUPPORT ?= 1
+# SPI3 support is on by default
+SSD1306_SPI3_SUPPORT ?= 1
 
 # args for passing into compile rule generation
 ssd1306_SRC_DIR = $(ssd1306_ROOT)
 
-ssd1306_CFLAGS = -DSSD1306_I2C_SUPPORT=${SSD1306_I2C_SUPPORT} -DSSD1306_SPI4_SUPPORT=${SSD1306_SPI4_SUPPORT} $(CFLAGS)
+ssd1306_CFLAGS = -DSSD1306_I2C_SUPPORT=${SSD1306_I2C_SUPPORT} -DSSD1306_SPI4_SUPPORT=${SSD1306_SPI4_SUPPORT} -DSSD1306_SPI3_SUPPORT=${SSD1306_SPI3_SUPPORT} $(CFLAGS)
 
 
 $(eval $(call component_compile_rules,ssd1306))

extras/ssd1306/ssd1306.c

@@ -236,7 +236,9 @@ static int sh1106_go_coordinate(const ssd1306_t *dev, uint8_t x, uint8_t y)
 int ssd1306_load_frame_buffer(const ssd1306_t *dev, uint8_t buf[])
 {
     uint16_t i;
+#if (SSD1306_SPI3_SUPPORT)
     uint8_t j;
+#endif
 #if (SSD1306_I2C_SUPPORT)
     uint8_t tab[16] = { 0 };
 #endif

extras/stdin_uart_interrupt/stdin_uart_interrupt.c

@@ -43,6 +43,8 @@
 static SemaphoreHandle_t uart0_sem = NULL;
 static bool inited = false;
 static void uart0_rx_init(void);
+static int uart0_nonblock;
+static TickType_t uart0_vtime;
 
 IRAM void uart0_rx_handler(void *arg)
 {
@@ -75,6 +77,20 @@ uint32_t uart0_num_char(void)
     return count;
 }
 
+int uart0_set_nonblock(int nonblock)
+{
+    int current = uart0_nonblock;
+    uart0_nonblock = nonblock;
+    return current;
+}
+
+TickType_t uart0_set_vtime(TickType_t ticks)
+{
+    TickType_t current = uart0_vtime;
+    uart0_vtime = ticks;
+    return current;
+}
+
 // _read_stdin_r in core/newlib_syscalls.c will be skipped by the linker in favour
 // of this function
 long _read_stdin_r(struct _reent *r, int fd, char *ptr, int len)
@@ -83,7 +99,21 @@ long _read_stdin_r(struct _reent *r, int fd, char *ptr, int len)
     for(int i = 0; i < len; i++) {
         if (!(UART(UART0).STATUS & (UART_STATUS_RXFIFO_COUNT_M << UART_STATUS_RXFIFO_COUNT_S))) {
             _xt_isr_unmask(1 << INUM_UART);
-            if (!xSemaphoreTake(uart0_sem, portMAX_DELAY)) {
+            if (uart0_nonblock) {
+                if (i > 0) {
+                    return i;
+                }
+                r->_errno = EAGAIN;
+                return -1;
+            }
+            if (uart0_vtime) {
+                if (!xSemaphoreTake(uart0_sem, uart0_vtime)) {
+                    if (i > 0) {
+                        return i;
+                    }
+                    return 0;
+                }
+            } else if (!xSemaphoreTake(uart0_sem, portMAX_DELAY)) {
                 printf("\nFailed to get sem\n");
             }
         }

extras/stdin_uart_interrupt/stdin_uart_interrupt.h

@@ -27,6 +27,16 @@
 
 #include <stdint.h>
 
-// Return number of characters waiting in UART0
+/* Return number of characters waiting in UART0. */
 uint32_t uart0_num_char(void);
+
+/* Set UART0 input to nonblocking or blocking, returning the old state. */
+int uart0_set_nonblock(int);
+
+/* Set the UART0 input wait time in ticks, or zero to wait indefinitely,
+ * returning the old wait time. The wait time is only used when the input is
+ * blocking.
+ */
+TickType_t uart0_set_vtime(TickType_t ticks);
+
 #endif

ld/program.ld

@@ -113,7 +113,11 @@ SECTIONS
     *libc.a:*bzero.o(.literal .text .literal.* .text.*)
     *libc.a:*lock.o(.literal .text .literal.* .text.*)
 
-    *libc.a:*printf.o(.literal .text .literal.* .text.*)
+    *libc.a:*-printf.o(.literal .text .literal.* .text.*)
+    *libc.a:*-sprintf.o(.literal .text .literal.* .text.*)
+    *libc.a:*-fprintf.o(.literal .text .literal.* .text.*)
+    *libc.a:*-svfprintf.o(.literal .text .literal.* .text.*)
+    *libc.a:*-vfprintf.o(.literal .text .literal.* .text.*)
     *libc.a:*findfp.o(.literal .text .literal.* .text.*)
     *libc.a:*fputwc.o(.literal .text .literal.* .text.*)
 
@@ -249,10 +253,13 @@ SECTIONS
     *(.gnu.linkonce.r.*)
     __XT_EXCEPTION_TABLE__ = ABSOLUTE(.);
     *(.xt_except_table)
-    *(.gcc_except_table)
+    *(.gcc_except_table .gcc_except_table.*)
     *(.gnu.linkonce.e.*)
     *(.gnu.version_r)
-    *(.eh_frame)
+    . = (. + 3) & ~ 3;
+    __eh_frame = ABSOLUTE(.);
+    KEEP(*(.eh_frame))
+    . = (. + 7) & ~ 3;
     . = ALIGN(4);
     *(.dynamic)
     *(.gnu.version_d)