Minor fixes in EDA

time

eda/atmega/atmega.kicad_pro

@@ -440,6 +440,7 @@
       "single_global_label": "ignore",
       "unannotated": "error",
       "unconnected_wire_endpoint": "warning",
+      "undefined_netclass": "error",
       "unit_value_mismatch": "error",
       "unresolved_variable": "error",
       "wire_dangling": "error"

firmware/atmega/Makefile

@@ -13,7 +13,7 @@ O_FLAG = -Os
 BUILD_DIR = build
 OBJ_DIR = $(BUILD_DIR)/obj
 
-SRCS_C = source/adc.c source/moisture.c source/main.c source/pump.c source/eeprom.c
+SRCS_C = source/adc.c source/moisture.c source/main.c source/pump.c source/eeprom.c source/twi.c
 OBJS = $(addprefix $(OBJ_DIR)/, $(notdir $(SRCS_C:.c=.o)))
 
 CFLAGS = -Wall $(O_FLAG) -DF_CPU=$(F_CPU) -mmcu=$(MCU) -Iinclude

firmware/atmega/include/config.h

@@ -27,6 +27,7 @@
 inline void eeprom_init() {
     #define DICT_SIZE 4
 
+    // EEPROM addresses
     #define TWI_ADDR        0x22
     #define SENSOR_READINGS 0x23
     #define MOISTURE_MIN    0x24
@@ -39,8 +40,9 @@ inline void eeprom_init() {
         MOISTURE_MAX
     };
 
+    // actual values
     uint16_t values[DICT_SIZE] = {
-        0x20,
+        0x30,
         5,
         400,
         200
@@ -51,4 +53,6 @@ inline void eeprom_init() {
     for (int i = 0; i < DICT_SIZE; i++) if (eepromRead(keys[i]) == 0) eepromWrite(keys[i], values[i]);
 }
 
+extern volatile uint16_t *pLastMoistureVal;
+
 #endif

firmware/atmega/include/moisture.h

@@ -44,7 +44,6 @@ static const int8_t sensorPins[] = {
 extern volatile bool readSensors;
 
 void sensorsInit(void);
-inline void triggerMoistureRead(void);
 uint16_t moistureRead(void);
 
 #endif

firmware/atmega/include/twi.h

@@ -0,0 +1,10 @@
+#ifndef TWI_H
+#define TWI_H
+
+extern volatile uint16_t *pLastMoistureVal;
+
+void twiInit(void);
+void twiListen(void);
+void twiRespond(void);
+
+#endif

firmware/atmega/source/main.c

@@ -3,15 +3,20 @@
 #include <avr/sleep.h>
 #include <avr/wdt.h>
 #include <avr/interrupt.h>
+#include "config.h"
 #include "adc.h"
 #include "moisture.h"
 #include "pump.h"
+#include "twi.h"
 
-ISR(WDT_vect) {
-    triggerMoistureRead();
+volatile uint16_t lastMoistureVal = 0;
+volatile uint16_t *pLastMoistureVal = &lastMoistureVal;
+
+ISR(TWI_vect) {
+    twiListen();
 }
 
-void watchdogs(void) {
+static void watchdogs(void) {
     cli();
     MCUSR &= ~(1 << WDRF);
     WDTCSR |= (1 << WDCE) | (1 << WDE);
@@ -19,15 +24,16 @@ void watchdogs(void) {
     sei();
 }
 
-void enterSleep(void) {
+static inline void enterSleep(void) {
     set_sleep_mode(SLEEP_MODE_PWR_DOWN);
     sleep_enable();
     sleep_cpu();
     sleep_disable();
 }
 
-void setup(void) {
+static void setup(void) {
     adcInit();
+    twiInit();
     sensorsInit();
     pumpsInit();
     watchdogs();
@@ -36,16 +42,13 @@ void setup(void) {
 int main(void) {
     setup();
 
-    while(true) {
-        if (readSensors) {
-            uint16_t result = moistureRead();
-            //espSend(VASE_NUM, result)
-        }
-        // if(espGet("ask if i need to water plants") == true) {waterPlant()}
-        // or maybe it's better to do this with interrupts?
+    pLastMoistureVal = &lastMoistureVal;
 
-        readSensors = false;
+    while(true) {
+        if ((*pLastMoistureVal = moistureRead()) < MOISTURE_MIN) waterPlant();
+        twiRespond();
         enterSleep();
     }
+
     return -1;
 }

firmware/atmega/source/moisture.c

@@ -17,10 +17,6 @@ void sensorsInit(void) {
     PORTC &= ~sensorMask;
 }
 
-inline void triggerMoistureRead(void) {
-    readSensors = true;
-}
-
 static uint16_t moistureAverage(uint8_t sensorPin) {
     uint16_t sum = 0;
     for (uint8_t i = 0; i < SENSOR_READINGS; i++) {

firmware/atmega/source/twi.c

@@ -0,0 +1,101 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include "config.h"
+#include "pump.h"
+#include "twi.h"
+
+#define BUFFER_SIZE 4
+
+static uint8_t twiBuffer[BUFFER_SIZE] = {0};
+static uint8_t bufferIndex = 0;
+bool respondFlag = false;
+
+static inline void twiReset(void) {
+    // Enable TWI; enable ACK; clear interrupt flag; enable twi external interrupt
+    TWCR = (1 << TWEN) | (1 << TWEA) | (1 << TWINT) | (1 << TWIE);
+}
+
+void twiInit(void) {
+    TWAR = ((eepromRead(TWI_ADDR)) << 1); //address definition found in config.h
+    twiReset();
+}
+
+static inline void twiSendAck(void) {
+    TWCR = (1 << TWEA) | (1 << TWINT);
+}
+
+static inline void twiSendNack(void) {
+    TWCR = (TWCR & ~(1 << TWEA)) | (1 << TWINT);
+}
+
+static void twiSendData(uint8_t data) {
+    TWDR = data;
+    twiSendAck();
+}
+
+void twiRespond(void) {
+    if (!respondFlag) return;
+
+    uint8_t cmd   = twiBuffer[0];
+    uint8_t param = twiBuffer[1];
+
+    switch(cmd) {
+        // READ
+        case 0x01:
+            twiSendData(*pLastMoistureVal);
+            break;
+        case 0x02:
+            twiSendData(eepromRead(SENSOR_READINGS));
+            break;
+        case 0x03:
+            twiSendData(eepromRead(MOISTURE_MIN));
+            break;
+        case 0x04:
+            twiSendData(eepromRead(MOISTURE_MAX));
+            break;
+        // WRITE
+        case 0x05:
+            eepromWrite(SENSOR_READINGS, param);
+            twiSendAck();
+            break;
+        case 0x06:
+            eepromWrite(MOISTURE_MIN, param);
+            twiSendAck();
+            break;
+        case 0x07:
+            eepromWrite(MOISTURE_MAX, param);
+            twiSendAck();
+            break;
+        case 0x08:
+            waterPlant();
+            twiSendAck();
+            break;
+        default:
+            twiSendNack();
+            break;
+    }
+}
+
+
+void twiListen(void) {
+    switch (TWSR & 0xF8) {
+        case 0x60: // SLA+W received
+            bufferIndex = 0;
+            twiSendAck();
+            break;
+        case 0x80: // data received
+            if(bufferIndex < BUFFER_SIZE) {
+                twiBuffer[bufferIndex++] = TWDR;
+                twiSendAck();
+            } else twiSendNack();
+            break;
+        case 0xA0: // stop condition
+            respondFlag = true;
+            twiReset();
+            break;
+        default:
+            twiSendNack();
+            break;
+    }
+}

firmware/esp32/CMakeLists.txt

@@ -1,4 +1,4 @@
 cmake_minimum_required(VERSION 3.16)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(plant-manager)
+project(plant-thing)

firmware/esp32/Dockerfile

@@ -45,4 +45,4 @@ RUN rm -rf build && /bin/bash -c "source $IDF_PATH/export.sh && idf.py set-targe
 RUN mkdir -p /usr/src/build && \
     cp build/bootloader/bootloader.bin /usr/src/build/ && \
     cp build/partition_table/partition-table.bin /usr/src/build/ && \
-    cp build/plant-manager.bin /usr/src/build/
+    cp build/plant-thing.bin /usr/src/build/

firmware/esp32/build-esp32.sh

@@ -22,6 +22,6 @@ esptool --chip esp32c3 --port /dev/tty.usbmodem101 --baud 115200 write-flash \
   --flash-size 4MB \
   0x0000 "$DEST_DIR/bootloader.bin" \
   0x8000 "$DEST_DIR/partition-table.bin" \
-  0x10000 "$DEST_DIR/plant-manager.bin"
+  0x10000 "$DEST_DIR/plant-thing.bin"
 
 screen -fn /dev/tty.usbmodem101 115200

firmware/esp32/include/config.h

@@ -1,7 +1,7 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 
-// TODO: make this a config.h
+#pragma once
 
 // WI-FI
 #define SSID       "your_wifi_ssid"
@@ -14,4 +14,18 @@
 #define MQTT_USER "your_username"
 #define MQTT_PASS "your_password"
 
+#define CMD_GET_MOISTURE        0x01
+#define CMD_GET_SENSOR_READS    0x02
+#define CMD_GET_MOISTURE_MIN    0x03
+#define CMD_GET_MOISTURE_MAX    0x04
+#define CMD_SET_SENSOR_READS    0x05   // [cmd, value]
+#define CMD_SET_PARAMS          0x06   // [cmd, min, max, reads]
+#define CMD_FORCE_PUMP          0x07   // [cmd]
+
+// Change based on how many vases max to manage [1 to ~100]
+// larger numberss will require larger arrays stored in memory
+// see AVR limitation on TWI addresses
+#define SLAVES_NUMBER 8
+
+
 #endif

firmware/esp32/include/i2c.hpp

@@ -0,0 +1,12 @@
+#ifndef I2C_HPP
+#define I2C_HPP
+
+#pragma once
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+extern TaskHandle_t i2c_task;
+
+void i2cTask(void *pvParameters);
+
+#endif

firmware/esp32/include/main.hpp

@@ -1,13 +1,15 @@
-   #ifndef MAIN_HPP
-   #define MAIN_HPP
+#ifndef MAIN_HPP
+#define MAIN_HPP
 
-   #include "freertos/FreeRTOS.h"
-   #include "freertos/event_groups.h"
+#pragma once
 
-   extern volatile bool criticalErrorFlag;
-   extern EventGroupHandle_t connectivity_event_group;
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
 
-   #define WIFI_CONNECTED_BIT BIT0
-   #define MQTT_CONNECTED_BIT BIT1
+extern volatile bool criticalErrorFlag;
+extern EventGroupHandle_t connectivity_event_group;
 
-   #endif
+#define WIFI_CONNECTED_BIT BIT0
+#define MQTT_CONNECTED_BIT BIT1
+
+#endif

firmware/esp32/include/mqtt.hpp

@@ -1,6 +1,8 @@
 #ifndef MQTT_HPP
 #define MQTT_HPP
 
+#pragma once
+
 void mqttTask(void *pvParameters);
 
 #endif

firmware/esp32/include/wifi.hpp

@@ -1,6 +1,8 @@
 #ifndef WIFI_HPP
 #define WIFI_HPP
 
+#pragma once
+
 void wifiTask(void *pvParameters);
 
 #endif

firmware/esp32/main/CMakeLists.txt

@@ -1,12 +1,16 @@
-idf_component_register(SRCS "./main.cpp"
-                            "./wifi.cpp"
-                            "./mqtt.cpp"
-                       INCLUDE_DIRS "../include"
-                       REQUIRES esp_wifi
-                                nvs_flash
-                                esp_pm
-                                esp_hw_support
-                                esp_system
-                                freertos
-                                log
-                                mqtt)
+idf_component_register(
+    SRCS "./main.cpp"
+         "./wifi.cpp"
+         "./i2c.cpp"
+         "./mqtt.cpp"
+    INCLUDE_DIRS "../include"
+    REQUIRES esp_wifi
+             nvs_flash
+             esp_pm
+             esp_hw_support
+             esp_system
+             freertos
+             log
+             mqtt
+             esp_driver_i2c
+)

firmware/esp32/main/i2c.cpp

@@ -0,0 +1,100 @@
+#include <cstdint>
+#include <stdint.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "esp_task_wdt.h"
+#include "driver/i2c_master.h"
+#include "esp_log.h"
+#include "config-erick.h"
+
+#define I2C_TASK_TIMEOUT_MS 4500
+
+// for ESP32-C3
+#define I2C_MASTER_SCL_IO ((gpio_num_t)9)
+#define I2C_MASTER_SDA_IO ((gpio_num_t)8)
+
+#define DATA_LENGTH 100
+
+static const char* TAG = "I2C";
+
+TaskHandle_t i2c_task = NULL;
+
+i2c_master_bus_handle_t bus_handle;
+static i2c_master_dev_handle_t slave_handles[SLAVES_NUMBER];
+uint8_t slave_count = 0;
+uint8_t slave_addrs[SLAVES_NUMBER];
+
+uint8_t data_rd[DATA_LENGTH];
+
+static void register_slave(uint8_t addr) {
+    i2c_device_config_t slave_dev_cfg = {};
+    slave_dev_cfg.dev_addr_length = I2C_ADDR_BIT_LEN_7;
+    slave_dev_cfg.device_address = addr;
+    slave_dev_cfg.scl_speed_hz = 100000;
+    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus_handle, &slave_dev_cfg, &slave_handles[slave_count]));
+    slave_addrs[slave_count++] = addr;
+}
+
+static void i2c_init(void) {
+    i2c_master_bus_config_t i2c_mst_config = {};
+    i2c_mst_config.i2c_port = I2C_NUM_0;
+    i2c_mst_config.scl_io_num = I2C_MASTER_SCL_IO;
+    i2c_mst_config.sda_io_num = I2C_MASTER_SDA_IO;
+    i2c_mst_config.clk_source = I2C_CLK_SRC_DEFAULT;
+    i2c_mst_config.glitch_ignore_cnt = 7;
+    i2c_mst_config.intr_priority = 1;
+    i2c_mst_config.trans_queue_depth = 4;
+    ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_mst_config, &bus_handle));
+
+    register_slave(0x30);
+    register_slave(0x31);
+}
+
+static void i2c_send(uint32_t packet) {
+    uint8_t cmd = (packet >> 24) & 0xFF;
+    uint8_t slave_addr = (packet >> 16) & 0xFF;
+    uint8_t param = packet & 0xFF;
+
+    i2c_master_dev_handle_t dev = NULL;
+    for(uint8_t i = 0; i < slave_count; i++) {
+        if(slave_addrs[i] == slave_addr) {
+            dev = slave_handles[i];
+            break;
+        }
+    }
+    if(!dev) { ESP_LOGE(TAG,"Slave 0x%02X not found", slave_addr); return; }
+
+    uint8_t tx[2] = {cmd, param};
+    esp_err_t err;
+    switch(cmd) {
+        case CMD_GET_MOISTURE:
+        case CMD_GET_SENSOR_READS:
+        case CMD_GET_MOISTURE_MIN:
+        case CMD_GET_MOISTURE_MAX: {
+            uint8_t rx;
+            err = i2c_master_transmit_receive(dev, tx, 2, &rx, 1, 250);
+            if(err == ESP_OK) ESP_LOGI(TAG,"I2C READ cmd=0x%02X val=%u", cmd, rx);
+            break;
+        }
+        default:
+            err = i2c_master_transmit(dev, tx, 2, 250);
+            break;
+    }
+    if(err != ESP_OK) ESP_LOGE(TAG,"I2C transaction failed: %s", esp_err_to_name(err));
+}
+
+void i2cTask(void *pvParameters) {
+    i2c_init();
+    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
+
+    uint32_t packet;
+    for(;;) {
+        if(xTaskNotifyWait(0, 0, &packet, pdMS_TO_TICKS(I2C_TASK_TIMEOUT_MS)) == pdPASS) {
+            i2c_send(packet);
+        }
+        ESP_ERROR_CHECK(esp_task_wdt_reset());
+        vTaskDelay(pdMS_TO_TICKS(150));
+    }
+}

firmware/esp32/main/main.cpp

@@ -6,6 +6,7 @@
 #include "esp_pm.h"
 #include "esp_task_wdt.h"
 #include "wifi.hpp"
+#include "i2c.hpp"
 #include "mqtt.hpp"
 
 #define WATCHDOG_KEEPALIVE_MS 8000
@@ -53,6 +54,6 @@ extern "C" void app_main(void)
 
     xTaskCreate(watchdogTask, "watchdogs", 2048, NULL, configMAX_PRIORITIES-1, NULL);
     xTaskCreate(wifiTask, "wifi", 4096, NULL, configMAX_PRIORITIES-4, NULL);
-
+    xTaskCreate(i2cTask, "i2c", 4096, NULL, configMAX_PRIORITIES-6, &i2c_task);
     xTaskCreate(mqttTask, "mqtt", 2048, NULL, configMAX_PRIORITIES-8, NULL);
 }

firmware/esp32/main/mqtt.cpp

@@ -1,23 +1,30 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
 #include "esp_task_wdt.h"
 #include "esp_event.h"
 #include "esp_log.h"
+#include "stdlib.h"
+#include "string.h"
 #include "mqtt_client.h"
 #include "main.hpp"
-//#include "i2c.hpp"
-#include "config-erick.h"
+#include "i2c.hpp"
+#include "config.h"
+#include <cstdint>
 
 #define MQTT_TASK_TIMEOUT_MS 3000
+#define DEFAULT_SLAVE_ADDR 0x30
 
 static const char* TAG = "MQTT";
 
 static esp_mqtt_client_handle_t mqtt_client = NULL;
 
-static char global_rx_buffer[50];
+static char rx_buffer[50];
 
 static void mqtt_subscribe(void) {
-    esp_mqtt_client_subscribe(mqtt_client, "/topic/qos0", 0);
+    esp_mqtt_client_subscribe(mqtt_client, "/plant/moisture/qos0", 0);
+    esp_mqtt_client_subscribe(mqtt_client, "/plant/humidity/qos0", 0);
 }
 
 static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
@@ -26,8 +33,9 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
     switch(event->event_id) {
         case MQTT_EVENT_CONNECTED:
             xEventGroupSetBits(connectivity_event_group, MQTT_CONNECTED_BIT);
-            mqtt_subscribe();
             ESP_LOGV(TAG, "Connected to broker");
+            mqtt_subscribe();
+            ESP_LOGV(TAG, "Subscribed to topic");
             break;
 
         case MQTT_EVENT_DISCONNECTED:
@@ -40,10 +48,11 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
             ESP_LOGD(TAG, "Data received");
 
             int len = event->data_len;
-            if(len > sizeof(global_rx_buffer) - 1) len = sizeof(global_rx_buffer) - 1;
+            if(len > sizeof(rx_buffer) - 1) len = sizeof(rx_buffer) - 1;
+
+            memcpy(rx_buffer, event->data, len);
+            rx_buffer[len] = '\0';
 
-            memcpy(global_rx_buffer, event->data, len);
-            global_rx_buffer[len] = '\0';
             break;
         }
 
@@ -60,9 +69,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
 
 static void mqtt_init(void) {
     esp_mqtt_client_config_t mqtt_cfg = {};
-
     mqtt_cfg.broker.address.uri = MQTT_ADDR;
-    mqtt_cfg.broker.address.port = MQTT_PORT;
     mqtt_cfg.credentials.username = MQTT_USER;
     mqtt_cfg.credentials.authentication.password = MQTT_PASS;
 
@@ -96,11 +103,54 @@ void mqttTask(void *pvParameters) {
         if ((bits & (WIFI_CONNECTED_BIT | MQTT_CONNECTED_BIT)) == (WIFI_CONNECTED_BIT | MQTT_CONNECTED_BIT)) {
             ESP_LOGV(TAG, "Wi-Fi and MQTT up");
 
+            uint8_t params[3] = {0};
+            uint8_t param_len = 0;
 
+            uint8_t i2c_cmd = 0;
+            uint8_t slave_addr = DEFAULT_SLAVE_ADDR;
 
-        } else ESP_LOGV(TAG, "Wi-Fi or MQTT down");
+            char *action = strtok(rx_buffer, ":");
+            char *target = strtok(NULL, ":");
+            char *value  = strtok(NULL, ":");
+            char *slave  = strtok(NULL, ":");
+
+            if(slave) slave_addr = (uint8_t)strtol(slave, NULL, 0);
+
+            if(action && target) {
+                if (strcmp(action, "READ") == 0) {
+                    if (strcmp(target, "moisture") == 0) i2c_cmd = CMD_GET_MOISTURE;
+                    else if (strcmp(target, "eeprom") == 0 && value) {
+                        if (strcmp(value, "sensor_reads") == 0) i2c_cmd = CMD_GET_SENSOR_READS;
+                        else if (strcmp(value, "moisture_min") == 0) i2c_cmd = CMD_GET_MOISTURE_MIN;
+                        else if (strcmp(value, "moisture_max") == 0) i2c_cmd = CMD_GET_MOISTURE_MAX;
+                    }
+                } else if (strcmp(action, "WRITE") == 0) {
+                    if (strcmp(target, "force") == 0) i2c_cmd = CMD_FORCE_PUMP;
+                    else if (strcmp(target, "eeprom") == 0 && value) {
+                        if (strncmp(value, "params:", 7) == 0) {
+                            sscanf(value + 7, "%hhu,%hhu,%hhu", &params[0], &params[1], &params[2]);
+                            i2c_cmd = CMD_SET_PARAMS;
+                            param_len = 3;
+                        }
+                        else {
+                            uint8_t v = (uint8_t)atoi(value);
+
+                            if (strcmp(value, "sensor_reads") == 0) {
+                                i2c_cmd = CMD_SET_SENSOR_READS;
+                                params[0] = v;
+                                param_len = 1;
+                            }
+                        }
+                    }
+                }
+            }
+            uint32_t packet = (i2c_cmd<<24) | (slave_addr<<16) | params[0];
+            xTaskNotify(i2c_task, packet, eSetValueWithOverwrite);
+        } else ESP_LOGW(TAG, "Wi-Fi or MQTT down");
 
         ESP_ERROR_CHECK(esp_task_wdt_reset());
         ESP_LOGV(TAG, "Task reset");
+        vTaskDelay(pdMS_TO_TICKS(3000));
     }
+    ESP_LOGW(TAG, "Task exited");
 }

firmware/esp32/main/wifi.cpp

@@ -6,7 +6,7 @@
 #include "esp_log.h"
 #include "nvs_flash.h"
 #include "main.hpp"
-#include "config-erick.h"
+#include "config.h"
 
 #define WIFI_TIMEOUT_MS 4500
 
@@ -27,6 +27,7 @@ static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t e
                 xEventGroupClearBits(connectivity_event_group, WIFI_CONNECTED_BIT);
 
                 esp_wifi_connect();
+                vTaskDelay(pdMS_TO_TICKS(2000));
                 break;
             }
             default:
@@ -82,4 +83,5 @@ void wifiTask(void *pvParameters) {
         ESP_LOGV(TAG, "Task reset");
         vTaskDelay(pdMS_TO_TICKS(WIFI_TIMEOUT_MS));
     }
+    ESP_LOGW(TAG, "Task exited");
 }