Doorbell interrupts working.

GPIO cannot do both ADC and ISR so split the pins.

3 files changed, 106 insertions, 46 deletions

diff --git a/main/src/bell.c b/main/src/bell.c
index 985ca4e..730d031 100644
--- a/main/src/bell.c
+++ b/main/src/bell.c
@@ -1,8 +1,11 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/timers.h>
+#include <freertos/task.h>
+#include <freertos/portmacro.h>
 #include <esp_log.h>
 #include <driver/gpio.h>
 #include <driver/adc.h>
+#include <soc/adc_channel.h>
 #include <hap.h>
 #include <hap_apple_servs.h>
 #include <hap_apple_chars.h>
@@ -12,30 +15,64 @@
 
 static hap_val_t HAP_PROGRAMMABLE_SWITCH_EVENT_SINGLE_PRESS = {.u = 0};
 
+#define INTERCOM_BELL_TASK_PRIORITY 1
+#define INTERCOM_BELL_TASK_STACKSIZE 4 * 1024
+#define INTERCOM_BELL_TASK_NAME "hap_intercom_bell"
+
+static TaskHandle_t intercom_bell_read_task;
+
 volatile bool is_intercom_bell_blocked;
 static TimerHandle_t intercom_bell_timer; // ignore new bells until timer triggered
 static hap_char_t *intercom_bell_current_state;
 
 bool is_bell_ringing(int val)
 {
+    ESP_LOGI(TAG, "Intercom bell rang with value %d", val);
     return 2340 < val && val < 2360;
 }
-
-void IRAM_ATTR intercom_bell_isr(void *arg)
+int read_adc()
 {
-    if (is_intercom_bell_blocked)
-        return;
+    return adc1_get_raw(ADC1_GPIO33_CHANNEL);
+}
 
-    // TODO: Can ADC1 be read from ISR?
-    int val = adc1_get_raw(CONFIG_HOMEKIT_INTERCOM_BELL_ADC1_CHANNEL);
+int read_adc_avg()
+{
+    //new average = old average + (next data - old average) / next count
+    int avg = 0;
+    for (int i = 1; i < 10; i++)
+    {
+        avg = avg + ((read_adc() - avg) / i);
+    }
+    return avg;
+}
 
-    if (!is_bell_ringing(val))
-        return;
+void intercom_bell_read(void *p)
+{
+    ESP_LOGI(TAG, "Intercom bell task started");
+    for (;;)
+    {
+        ESP_LOGI(TAG, "Intercom bell task waiting");
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+        ESP_LOGI(TAG, "Intercom bell task triggered");
+        if (is_bell_ringing(read_adc()))
+        {
+            ESP_LOGI(TAG, "Intercom bell HAP ring");
+            hap_char_update_val(intercom_bell_current_state, &HAP_PROGRAMMABLE_SWITCH_EVENT_SINGLE_PRESS);
+            is_intercom_bell_blocked = true;
+            xTimerReset(intercom_bell_timer, pdFALSE);
+        }
+    }
+}
 
-    // TODO: Can hap function be called from an ISR?
-    hap_char_update_val(intercom_bell_current_state, &HAP_PROGRAMMABLE_SWITCH_EVENT_SINGLE_PRESS);
-    is_intercom_bell_blocked = true;
-    xTimerResetFromISR(intercom_bell_timer, pdFALSE);
+void IRAM_ATTR intercom_bell_isr(void *arg)
+{
+    if (!is_intercom_bell_blocked)
+    {
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+        configASSERT(intercom_bell_read_task != NULL);
+        vTaskNotifyGiveFromISR(intercom_bell_read_task, &xHigherPriorityTaskWoken);
+        portYIELD_FROM_ISR();
+    }
 }
 
 void intercom_bell_timer_cb(TimerHandle_t timer)
@@ -44,31 +81,50 @@ void intercom_bell_timer_cb(TimerHandle_t timer)
     is_intercom_bell_blocked = false;
 }
 
-hap_serv_t *intercom_bell_init(uint32_t key_gpio_pin)
+void intercom_bell_isr_gpio_init()
 {
-    is_intercom_bell_blocked = false;
-    intercom_bell_timer = xTimerCreate("intercom_bell_timer", pdMS_TO_TICKS(CONFIG_HOMEKIT_INTERCOM_LOCK_TIMEOUT), pdFALSE, 0, intercom_bell_timer_cb);
-
-    hap_serv_t *intercom_bell_service = hap_serv_doorbell_create(0);
-    hap_serv_add_char(intercom_bell_service, hap_char_name_create("Intercom Bell"));
-    intercom_bell_current_state = hap_serv_get_char_by_uuid(intercom_bell_service, HAP_CHAR_UUID_PROGRAMMABLE_SWITCH_EVENT);
-
+    // Configure ISR GPIO Pin 27
     gpio_config_t io_conf;
-
-    io_conf.intr_type = GPIO_INTR_ANYEDGE;        /* Interrupt for rising edge  */
-    io_conf.pin_bit_mask = 1ULL << key_gpio_pin;  /* Bit mask of the pins */
+    io_conf.intr_type = GPIO_INTR_NEGEDGE;        /* Interrupt for falling edge  */
+    io_conf.pin_bit_mask = GPIO_SEL_27;           /* Bit mask of the pins */
     io_conf.mode = GPIO_MODE_INPUT;               /* Set as input mode */
     io_conf.pull_up_en = GPIO_PULLUP_DISABLE;     /* Disable internal pull-up */
     io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE; /* Enable internal pull-down */
+    gpio_config(&io_conf);                        /* Set the GPIO configuration */
 
-    gpio_config(&io_conf); /* Set the GPIO configuration */
+    gpio_install_isr_service(0);                                     /* Install gpio isr service */
+    gpio_isr_handler_add(GPIO_NUM_27, intercom_bell_isr, (void *)0); /* Hook isr handler for specified gpio pin */
+}
 
-    gpio_install_isr_service(ESP_INTR_FLAG_EDGE | ESP_INTR_FLAG_LOWMED);         /* Install gpio isr service */
-    gpio_isr_handler_add(key_gpio_pin, intercom_bell_isr, (void *)key_gpio_pin); /* Hook isr handler for specified gpio pin */
+void intercom_bell_adc_gpio_init()
+{
+    // Configure ADC1 Channel 5, GPIO Pin 33
+    gpio_config_t io_conf;
+    io_conf.intr_type = GPIO_INTR_DISABLE;        /* Interrupt for falling edge  */
+    io_conf.pin_bit_mask = GPIO_SEL_33;           /* Bit mask of the pins */
+    io_conf.mode = GPIO_MODE_INPUT;               /* Set as input mode */
+    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;     /* Disable internal pull-up */
+    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE; /* Enable internal pull-down */
+    gpio_config(&io_conf);                        /* Set the GPIO configuration */
 
     // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc.html#_CPPv425adc1_config_channel_atten14adc1_channel_t11adc_atten_t
     adc1_config_width(ADC_WIDTH_BIT_12); /* The value read is 12 bits wide (range 0-4095). */
-    adc1_config_channel_atten(CONFIG_HOMEKIT_INTERCOM_BELL_ADC1_CHANNEL, ADC_ATTEN_DB_11);
+    adc1_config_channel_atten(ADC1_GPIO33_CHANNEL, ADC_ATTEN_DB_11);
+}
+
+hap_serv_t *intercom_bell_init()
+{
+    xTaskCreate(intercom_bell_read, INTERCOM_BELL_TASK_NAME, INTERCOM_BELL_TASK_STACKSIZE, NULL, INTERCOM_BELL_TASK_PRIORITY, &intercom_bell_read_task);
+
+    is_intercom_bell_blocked = false;
+    intercom_bell_timer = xTimerCreate("intercom_bell_timer", pdMS_TO_TICKS(CONFIG_HOMEKIT_INTERCOM_LOCK_TIMEOUT), pdFALSE, 0, intercom_bell_timer_cb);
+
+    hap_serv_t *intercom_bell_service = hap_serv_doorbell_create(0);
+    hap_serv_add_char(intercom_bell_service, hap_char_name_create("Intercom Bell"));
+    intercom_bell_current_state = hap_serv_get_char_by_uuid(intercom_bell_service, HAP_CHAR_UUID_PROGRAMMABLE_SWITCH_EVENT);
+
+    intercom_bell_isr_gpio_init();
+    intercom_bell_adc_gpio_init();
 
     return intercom_bell_service;
 }
diff --git a/main/src/led.c b/main/src/led.c
index 714e0f7..63513f6 100644
--- a/main/src/led.c
+++ b/main/src/led.c
@@ -7,30 +7,31 @@
 #include <led.h>
 #include <intercom.h>
 
+#define LED_ON 1
+#define LED_OFF 0
+
 int intercom_led_identify(hap_acc_t *ha)
 {
     ESP_LOGI(TAG, "Accessory identified");
 
     for (int i = 0; i < 3; i++)
     {
-        gpio_set_level(CONFIG_HOMEKIT_INTERCOM_LED_GPIO_PIN, 1);
+        gpio_set_level(GPIO_NUM_13, LED_ON);
         vTaskDelay(pdMS_TO_TICKS(500));
-        gpio_set_level(CONFIG_HOMEKIT_INTERCOM_LED_GPIO_PIN, 0);
+        gpio_set_level(GPIO_NUM_13, LED_OFF);
         vTaskDelay(pdMS_TO_TICKS(500));
     }
 
     return HAP_SUCCESS;
 }
 
-void intercom_led_init(uint32_t key_gpio_pin)
+void intercom_led_init()
 {
     gpio_config_t io_conf;
-
     io_conf.intr_type = GPIO_INTR_DISABLE;       /* Interrupt for falling edge  */
-    io_conf.pin_bit_mask = 1ULL << key_gpio_pin; /* Bit mask of the pins */
+    io_conf.pin_bit_mask = GPIO_SEL_13;          /* Bit mask of the pins */
     io_conf.mode = GPIO_MODE_OUTPUT;             /* Set as input mode */
     io_conf.pull_up_en = GPIO_PULLUP_DISABLE;    /* Disable internal pull-up */
     io_conf.pull_down_en = GPIO_PULLDOWN_ENABLE; /* Enable internal pull-down */
-
-    gpio_config(&io_conf); /* Set the GPIO configuration */
+    gpio_config(&io_conf);                       /* Set the GPIO configuration */
 }
\ No newline at end of file
diff --git a/main/src/lock.c b/main/src/lock.c
index ead0401..558968b 100644
--- a/main/src/lock.c
+++ b/main/src/lock.c
@@ -30,7 +30,7 @@ static hap_char_t *intercom_lock_target_state;
 void intercom_lock_unsecure()
 {
     ESP_LOGI(TAG, "Intercom lock unsecure");
-    gpio_set_level(CONFIG_HOMEKIT_INTERCOM_LOCK_GPIO_PIN, INTERCOM_LOCK_GPIO_UNLOCKED);
+    gpio_set_level(GPIO_NUM_21, INTERCOM_LOCK_GPIO_UNLOCKED);
     hap_char_update_val(intercom_lock_current_state, &HAP_VAL_LOCK_CURRENT_STATE_UNSECURED);
     xTimerReset(intercom_lock_timer, 10);
 }
@@ -38,7 +38,7 @@ void intercom_lock_unsecure()
 void intercom_lock_secure()
 {
     ESP_LOGI(TAG, "Intercom lock secure");
-    gpio_set_level(CONFIG_HOMEKIT_INTERCOM_LOCK_GPIO_PIN, INTERCOM_LOCK_GPIO_LOCKED);
+    gpio_set_level(GPIO_NUM_21, INTERCOM_LOCK_GPIO_LOCKED);
     hap_char_update_val(intercom_lock_current_state, &HAP_VAL_LOCK_CURRENT_STATE_SECURED);
 }
 
@@ -82,7 +82,18 @@ void intercom_lock_timer_cb(TimerHandle_t timer)
     hap_char_update_val(intercom_lock_target_state, &HAP_VAL_LOCK_TARGET_STATE_SECURED);
 }
 
-hap_serv_t *intercom_lock_init(uint32_t key_gpio_pin)
+void intercom_lock_gpio_init()
+{
+    gpio_config_t io_conf;
+    io_conf.intr_type = GPIO_INTR_DISABLE;       /* Disable interrupt  */
+    io_conf.pin_bit_mask = GPIO_SEL_21;          /* Bit mask of the pins */
+    io_conf.mode = GPIO_MODE_OUTPUT;             /* Set as input mode */
+    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;    /* Disable internal pull-up */
+    io_conf.pull_down_en = GPIO_PULLDOWN_ENABLE; /* Enable internal pull-down */
+    gpio_config(&io_conf);
+}
+
+hap_serv_t *intercom_lock_init()
 {
     hap_serv_t *intercom_lock_service = hap_serv_lock_mechanism_create(HAP_VAL_LOCK_CURRENT_STATE_SECURED.u, HAP_LOCK_TARGET_STATE_SECURED);
     hap_serv_add_char(intercom_lock_service, hap_char_name_create("Intercom Lock"));
@@ -94,15 +105,7 @@ hap_serv_t *intercom_lock_init(uint32_t key_gpio_pin)
 
     intercom_lock_timer = xTimerCreate("intercom_lock_timer", pdMS_TO_TICKS(CONFIG_HOMEKIT_INTERCOM_LOCK_TIMEOUT), pdFALSE, 0, intercom_lock_timer_cb);
 
-    gpio_config_t io_conf;
-
-    io_conf.intr_type = GPIO_INTR_DISABLE;       /* Disable interrupt  */
-    io_conf.pin_bit_mask = 1ULL << key_gpio_pin; /* Bit mask of the pins */
-    io_conf.mode = GPIO_MODE_OUTPUT;             /* Set as input mode */
-    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;    /* Disable internal pull-up */
-    io_conf.pull_down_en = GPIO_PULLDOWN_ENABLE; /* Enable internal pull-down */
-
-    gpio_config(&io_conf); /* Set the GPIO configuration */
+    intercom_lock_gpio_init();
 
     return intercom_lock_service;
 }