Minor fixes in EDA

time

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Erick Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eda/atmega/atmega.kicad_pro

@@ -0,0 +1,639 @@
+{
+  "board": {
+    "3dviewports": [],
+    "design_settings": {
+      "defaults": {
+        "apply_defaults_to_fp_fields": false,
+        "apply_defaults_to_fp_shapes": false,
+        "apply_defaults_to_fp_text": false,
+        "board_outline_line_width": 0.05,
+        "copper_line_width": 0.2,
+        "copper_text_italic": false,
+        "copper_text_size_h": 1.5,
+        "copper_text_size_v": 1.5,
+        "copper_text_thickness": 0.3,
+        "copper_text_upright": false,
+        "courtyard_line_width": 0.05,
+        "dimension_precision": 4,
+        "dimension_units": 3,
+        "dimensions": {
+          "arrow_length": 1270000,
+          "extension_offset": 500000,
+          "keep_text_aligned": true,
+          "suppress_zeroes": true,
+          "text_position": 0,
+          "units_format": 0
+        },
+        "fab_line_width": 0.1,
+        "fab_text_italic": false,
+        "fab_text_size_h": 1.0,
+        "fab_text_size_v": 1.0,
+        "fab_text_thickness": 0.15,
+        "fab_text_upright": false,
+        "other_line_width": 0.1,
+        "other_text_italic": false,
+        "other_text_size_h": 1.0,
+        "other_text_size_v": 1.0,
+        "other_text_thickness": 0.15,
+        "other_text_upright": false,
+        "pads": {
+          "drill": 0.8,
+          "height": 1.27,
+          "width": 2.54
+        },
+        "silk_line_width": 0.1,
+        "silk_text_italic": false,
+        "silk_text_size_h": 1.0,
+        "silk_text_size_v": 1.0,
+        "silk_text_thickness": 0.1,
+        "silk_text_upright": false,
+        "zones": {
+          "min_clearance": 0.5
+        }
+      },
+      "diff_pair_dimensions": [],
+      "drc_exclusions": [],
+      "meta": {
+        "version": 2
+      },
+      "rule_severities": {
+        "annular_width": "error",
+        "clearance": "error",
+        "connection_width": "warning",
+        "copper_edge_clearance": "error",
+        "copper_sliver": "warning",
+        "courtyards_overlap": "error",
+        "creepage": "error",
+        "diff_pair_gap_out_of_range": "error",
+        "diff_pair_uncoupled_length_too_long": "error",
+        "drill_out_of_range": "error",
+        "duplicate_footprints": "warning",
+        "extra_footprint": "warning",
+        "footprint": "error",
+        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_mismatch": "warning",
+        "footprint_type_mismatch": "ignore",
+        "hole_clearance": "error",
+        "hole_to_hole": "warning",
+        "holes_co_located": "warning",
+        "invalid_outline": "error",
+        "isolated_copper": "warning",
+        "item_on_disabled_layer": "error",
+        "items_not_allowed": "error",
+        "length_out_of_range": "error",
+        "lib_footprint_issues": "warning",
+        "lib_footprint_mismatch": "warning",
+        "malformed_courtyard": "error",
+        "microvia_drill_out_of_range": "error",
+        "mirrored_text_on_front_layer": "warning",
+        "missing_courtyard": "ignore",
+        "missing_footprint": "warning",
+        "net_conflict": "warning",
+        "nonmirrored_text_on_back_layer": "warning",
+        "npth_inside_courtyard": "ignore",
+        "padstack": "warning",
+        "pth_inside_courtyard": "ignore",
+        "shorting_items": "error",
+        "silk_edge_clearance": "warning",
+        "silk_over_copper": "warning",
+        "silk_overlap": "warning",
+        "skew_out_of_range": "error",
+        "solder_mask_bridge": "error",
+        "starved_thermal": "error",
+        "text_height": "warning",
+        "text_on_edge_cuts": "error",
+        "text_thickness": "warning",
+        "through_hole_pad_without_hole": "error",
+        "too_many_vias": "error",
+        "track_angle": "error",
+        "track_dangling": "warning",
+        "track_segment_length": "error",
+        "track_width": "error",
+        "tracks_crossing": "error",
+        "unconnected_items": "error",
+        "unresolved_variable": "error",
+        "via_dangling": "warning",
+        "zones_intersect": "error"
+      },
+      "rules": {
+        "max_error": 0.005,
+        "min_clearance": 0.0,
+        "min_connection": 0.0,
+        "min_copper_edge_clearance": 0.5,
+        "min_groove_width": 0.0,
+        "min_hole_clearance": 0.25,
+        "min_hole_to_hole": 0.25,
+        "min_microvia_diameter": 0.2,
+        "min_microvia_drill": 0.1,
+        "min_resolved_spokes": 2,
+        "min_silk_clearance": 0.0,
+        "min_text_height": 0.8,
+        "min_text_thickness": 0.08,
+        "min_through_hole_diameter": 0.3,
+        "min_track_width": 0.0,
+        "min_via_annular_width": 0.1,
+        "min_via_diameter": 0.5,
+        "solder_mask_to_copper_clearance": 0.0,
+        "use_height_for_length_calcs": true
+      },
+      "teardrop_options": [
+        {
+          "td_onpthpad": true,
+          "td_onroundshapesonly": false,
+          "td_onsmdpad": true,
+          "td_ontrackend": false,
+          "td_onvia": true
+        }
+      ],
+      "teardrop_parameters": [
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_round_shape",
+          "td_width_to_size_filter_ratio": 0.9
+        },
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_rect_shape",
+          "td_width_to_size_filter_ratio": 0.9
+        },
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_track_end",
+          "td_width_to_size_filter_ratio": 0.9
+        }
+      ],
+      "track_widths": [],
+      "tuning_pattern_settings": {
+        "diff_pair_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 1.0
+        },
+        "diff_pair_skew_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        },
+        "single_track_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        }
+      },
+      "via_dimensions": [],
+      "zones_allow_external_fillets": false
+    },
+    "ipc2581": {
+      "dist": "",
+      "distpn": "",
+      "internal_id": "",
+      "mfg": "",
+      "mpn": ""
+    },
+    "layer_pairs": [],
+    "layer_presets": [],
+    "viewports": []
+  },
+  "boards": [],
+  "cvpcb": {
+    "equivalence_files": []
+  },
+  "erc": {
+    "erc_exclusions": [],
+    "meta": {
+      "version": 0
+    },
+    "pin_map": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        1,
+        0,
+        1,
+        2
+      ],
+      [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        2,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        2,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2
+      ]
+    ],
+    "rule_severities": {
+      "bus_definition_conflict": "error",
+      "bus_entry_needed": "error",
+      "bus_to_bus_conflict": "error",
+      "bus_to_net_conflict": "error",
+      "different_unit_footprint": "error",
+      "different_unit_net": "error",
+      "duplicate_reference": "error",
+      "duplicate_sheet_names": "error",
+      "endpoint_off_grid": "warning",
+      "extra_units": "error",
+      "footprint_filter": "ignore",
+      "footprint_link_issues": "warning",
+      "four_way_junction": "ignore",
+      "global_label_dangling": "warning",
+      "hier_label_mismatch": "error",
+      "label_dangling": "error",
+      "label_multiple_wires": "warning",
+      "lib_symbol_issues": "warning",
+      "lib_symbol_mismatch": "warning",
+      "missing_bidi_pin": "warning",
+      "missing_input_pin": "warning",
+      "missing_power_pin": "error",
+      "missing_unit": "warning",
+      "multiple_net_names": "warning",
+      "net_not_bus_member": "warning",
+      "no_connect_connected": "warning",
+      "no_connect_dangling": "warning",
+      "pin_not_connected": "error",
+      "pin_not_driven": "error",
+      "pin_to_pin": "warning",
+      "power_pin_not_driven": "error",
+      "same_local_global_label": "warning",
+      "similar_label_and_power": "warning",
+      "similar_labels": "warning",
+      "similar_power": "warning",
+      "simulation_model_issue": "ignore",
+      "single_global_label": "ignore",
+      "unannotated": "error",
+      "unconnected_wire_endpoint": "warning",
+      "undefined_netclass": "error",
+      "unit_value_mismatch": "error",
+      "unresolved_variable": "error",
+      "wire_dangling": "error"
+    }
+  },
+  "libraries": {
+    "pinned_footprint_libs": [],
+    "pinned_symbol_libs": []
+  },
+  "meta": {
+    "filename": "atmega.kicad_pro",
+    "version": 3
+  },
+  "net_settings": {
+    "classes": [
+      {
+        "bus_width": 12,
+        "clearance": 0.2,
+        "diff_pair_gap": 0.25,
+        "diff_pair_via_gap": 0.25,
+        "diff_pair_width": 0.2,
+        "line_style": 0,
+        "microvia_diameter": 0.3,
+        "microvia_drill": 0.1,
+        "name": "Default",
+        "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "priority": 2147483647,
+        "schematic_color": "rgba(0, 0, 0, 0.000)",
+        "track_width": 0.2,
+        "via_diameter": 0.6,
+        "via_drill": 0.3,
+        "wire_width": 6
+      }
+    ],
+    "meta": {
+      "version": 4
+    },
+    "net_colors": null,
+    "netclass_assignments": null,
+    "netclass_patterns": []
+  },
+  "pcbnew": {
+    "last_paths": {
+      "gencad": "",
+      "idf": "",
+      "netlist": "",
+      "plot": "",
+      "pos_files": "",
+      "specctra_dsn": "",
+      "step": "",
+      "svg": "",
+      "vrml": ""
+    },
+    "page_layout_descr_file": ""
+  },
+  "schematic": {
+    "annotate_start_num": 0,
+    "bom_export_filename": "${PROJECTNAME}.csv",
+    "bom_fmt_presets": [],
+    "bom_fmt_settings": {
+      "field_delimiter": ",",
+      "keep_line_breaks": false,
+      "keep_tabs": false,
+      "name": "CSV",
+      "ref_delimiter": ",",
+      "ref_range_delimiter": "",
+      "string_delimiter": "\""
+    },
+    "bom_presets": [],
+    "bom_settings": {
+      "exclude_dnp": false,
+      "fields_ordered": [
+        {
+          "group_by": false,
+          "label": "Reference",
+          "name": "Reference",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Value",
+          "name": "Value",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Footprint",
+          "name": "Footprint",
+          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "Datasheet",
+          "name": "Datasheet",
+          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "Description",
+          "name": "Description",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Qty",
+          "name": "${QUANTITY}",
+          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "#",
+          "name": "${ITEM_NUMBER}",
+          "show": false
+        },
+        {
+          "group_by": true,
+          "label": "DNP",
+          "name": "${DNP}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Exclude from BOM",
+          "name": "${EXCLUDE_FROM_BOM}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Exclude from Board",
+          "name": "${EXCLUDE_FROM_BOARD}",
+          "show": true
+        }
+      ],
+      "filter_string": "",
+      "group_symbols": true,
+      "include_excluded_from_bom": true,
+      "name": "",
+      "sort_asc": true,
+      "sort_field": "Reference"
+    },
+    "connection_grid_size": 50.0,
+    "drawing": {
+      "dashed_lines_dash_length_ratio": 12.0,
+      "dashed_lines_gap_length_ratio": 3.0,
+      "default_line_thickness": 6.0,
+      "default_text_size": 50.0,
+      "field_names": [],
+      "intersheets_ref_own_page": false,
+      "intersheets_ref_prefix": "",
+      "intersheets_ref_short": false,
+      "intersheets_ref_show": false,
+      "intersheets_ref_suffix": "",
+      "junction_size_choice": 3,
+      "label_size_ratio": 0.375,
+      "operating_point_overlay_i_precision": 3,
+      "operating_point_overlay_i_range": "~A",
+      "operating_point_overlay_v_precision": 3,
+      "operating_point_overlay_v_range": "~V",
+      "overbar_offset_ratio": 1.23,
+      "pin_symbol_size": 25.0,
+      "text_offset_ratio": 0.15
+    },
+    "legacy_lib_dir": "",
+    "legacy_lib_list": [],
+    "meta": {
+      "version": 1
+    },
+    "net_format_name": "",
+    "ngspice": {
+      "fix_include_paths": true,
+      "meta": {
+        "version": 0
+      },
+      "model_mode": 4,
+      "workbook_filename": ""
+    },
+    "page_layout_descr_file": "sensing",
+    "plot_directory": "",
+    "space_save_all_events": true,
+    "spice_current_sheet_as_root": false,
+    "spice_external_command": "spice \"%I\"",
+    "spice_model_current_sheet_as_root": true,
+    "spice_save_all_currents": false,
+    "spice_save_all_dissipations": false,
+    "spice_save_all_voltages": false,
+    "subpart_first_id": 65,
+    "subpart_id_separator": 0
+  },
+  "sheets": [
+    [
+      "90981571-11d1-4805-a2bb-89f0c5021ff9",
+      "Root"
+    ]
+  ],
+  "text_variables": {}
+}

firmware/atmega/Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends\
+    build-essential \
+    gcc-avr \
+    avrdude \
+    arduino-core-avr \
+    make \
+    && apt-get clean
+
+WORKDIR /usr/src/
+
+COPY . .
+
+RUN make all

firmware/atmega/Makefile

@@ -0,0 +1,45 @@
+PROJECT = plant-manager
+
+MCU = atmega328p
+F_CPU = 16000000UL
+
+CC = avr-gcc
+LD = $(CC)
+OC = avr-objcopy
+RM = rm -f
+
+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 source/twi.c
+OBJS = $(addprefix $(OBJ_DIR)/, $(notdir $(SRCS_C:.c=.o)))
+
+CFLAGS = -Wall $(O_FLAG) -DF_CPU=$(F_CPU) -mmcu=$(MCU) -Iinclude
+LDFLAGS = -Wall $(O_FLAG) -mmcu=$(MCU)
+LIBS = -lm
+
+EXEC = atmega
+ELF_TARGET = $(BUILD_DIR)/$(EXEC).elf
+TARGET = $(BUILD_DIR)/$(EXEC).hex
+
+all: $(TARGET)
+
+$(shell mkdir -p $(OBJ_DIR))
+$(shell mkdir -p $(BUILD_DIR))
+
+$(ELF_TARGET): $(OBJS)
+	$(LD) $(LDFLAGS) $(OBJS) -o $@ $(LIBS)
+
+$(OBJ_DIR)/%.o: source/%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(TARGET): $(ELF_TARGET)
+	$(OC) -O ihex -R .eeprom $< $@
+
+clean:
+	$(RM) $(TARGET) $(ELF_TARGET) $(OBJS)
+	$(RM) -r $(BUILD_DIR)
+
+.PHONY: all clean

firmware/atmega/build-atmega.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -e
+
+IMAGE_NAME="vase-control-builder"
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+IMAGE_NAME="vase-control-builder"
+DOCKERFILE="$SCRIPT_DIR/Dockerfile"
+BUILD_CTX="$SCRIPT_DIR"
+DEST_HEX="$SCRIPT_DIR/build/atmega.hex"
+MCU="atmega328p"; PRG="usbasp"
+
+docker build -t "$IMAGE_NAME" -f "$DOCKERFILE" "$BUILD_CTX"
+
+mkdir -p "$(dirname "$DEST_HEX")"
+
+docker run --rm "$IMAGE_NAME" \
+  cat /usr/src/build/atmega.hex > "$DEST_HEX"
+
+command -v avrdude >/dev/null || { echo "Install avrdude"; exit 1; }
+avrdude -v -p m328p -c usbasp -U flash:w:build/atmega.hex:i

firmware/atmega/include/adc.h

@@ -0,0 +1,11 @@
+#ifndef ADC_H
+#define ADC_H
+
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+void adcInit(void);
+uint16_t adcRead(uint8_t channel);
+
+#endif

firmware/atmega/include/config.h

@@ -0,0 +1,58 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <avr/io.h>
+#include "eeprom.h"
+
+#define MOISTURE_SENSOR_A0 PC0
+//#define MOISTURE_SENSOR_A1 PC1
+//#define MOISTURE_SENSOR_A2 PC2
+//#define MOISTURE_SENSOR_A3 PC3
+//#define MOISTURE_SENSOR_A4 PC4
+//#define MOISTURE_SENSOR_A5 PC5
+//#define MOISTURE_SENSOR_A6 PC6
+//#define MOISTURE_SENSOR_A7 PC7
+
+//#define PUMP_D3 PD3
+//#define PUMP_D4 PD4
+//#define PUMP_D5 PD5
+//#define PUMP_D6 PD6
+#define PUMP_D7 PD7
+
+#define TWI_SDA (1 << PD2)
+#define TWI_SCL (1 << PD3)
+
+inline void eeprom_init() {
+    #define DICT_SIZE 4
+
+    // EEPROM addresses
+    #define TWI_ADDR        0x22
+    #define SENSOR_READINGS 0x23
+    #define MOISTURE_MIN    0x24
+    #define MOISTURE_MAX    0x25
+
+    uint8_t keys[DICT_SIZE] = {
+        TWI_ADDR,
+        SENSOR_READINGS,
+        MOISTURE_MIN,
+        MOISTURE_MAX
+    };
+
+    // actual values
+    uint16_t values[DICT_SIZE] = {
+        0x30,
+        5,
+        400,
+        200
+    };
+
+    //NOTE: values are not re-initialized if != 0 because they may
+    //      have been changed by the esp32 during previous runs
+    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/eeprom.h

@@ -0,0 +1,11 @@
+#ifndef EEPROM_H
+#define EEPROM_H
+
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+uint8_t eepromRead(uint8_t address);
+void eepromWrite(uint8_t address, uint8_t data);
+
+#endif

firmware/atmega/include/moisture.h

@@ -0,0 +1,49 @@
+#ifndef MOISTURE_H
+#define MOISTURE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "config.h"
+
+static const int8_t sensorPins[] = {
+    #ifdef MOISTURE_SENSOR_A0
+        MOISTURE_SENSOR_A0,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A1
+        MOISTURE_SENSOR_A1,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A2
+        MOISTURE_SENSOR_A2,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A3
+        MOISTURE_SENSOR_A3,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A4
+        MOISTURE_SENSOR_A4,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A5
+        MOISTURE_SENSOR_A5,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A6
+        MOISTURE_SENSOR_A6,
+    #endif
+
+    #ifdef MOISTURE_SENSOR_A7
+        MOISTURE_SENSOR_A7,
+    #endif
+    };
+
+#define SENSORS_NUM (sizeof(sensorPins) / sizeof(sensorPins[0]))
+
+extern volatile bool readSensors;
+
+void sensorsInit(void);
+uint16_t moistureRead(void);
+
+#endif

firmware/atmega/include/pump.h

@@ -0,0 +1,38 @@
+#ifndef PUMP_H
+#define PUMP_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "config.h"
+
+
+static const int8_t actuatorPins[] = {
+    #ifdef PUMP_D3
+        PUMP_D3,
+    #endif
+
+    #ifdef PUMP_D4
+        PUMP_D4,
+    #endif
+
+    #ifdef PUMP_D5
+        PUMP_D5,
+    #endif
+
+    #ifdef PUMP_D6
+        PUMP_D6,
+    #endif
+
+    #ifdef PUMP_D7
+        PUMP_D7,
+    #endif
+    };
+
+#define ACTUATORS_NUM (sizeof(actuatorPins) / sizeof(actuatorPins[0]))
+
+void pumpsInit(void);
+void waterPlant(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/adc.c

@@ -0,0 +1,27 @@
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+void adcInit(void) {
+    // Set reference voltage to AVcc (REFS0 = 1, REFS1 = 0)
+    ADMUX = (1 << REFS0);
+
+    // Enable ADC and set prescaler to 128 (for 16 MHz clock, gives 125 kHz ADC clock)
+    ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
+}
+
+uint16_t adcRead(uint8_t channel) {
+    // Select ADC pin (A0-A7) by setting MUX bits in ADMUX
+    // Pins A6 and A7 would make an 8 sensor array possible (for large vases).
+    // Achievable only when using the 328p as a DIP, through port C (PC6, PC7)
+    ADMUX = (ADMUX & 0xF8) | (channel & 0x07);
+
+    // Start conversion
+    ADCSRA |= (1 << ADSC);
+
+    // Wait for conversion to complete (ADSC becomes '0' when done)
+    while (ADCSRA & (1 << ADSC));
+
+    // Read ADC (reading order: ADCL --> ADCH)
+    return ADC;
+}

firmware/atmega/source/eeprom.c

@@ -0,0 +1,35 @@
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+uint8_t eepromRead(uint8_t address) {
+    // wait for previous write
+    while (EECR & (1 << EEPE));
+
+    //read from address
+    EEAR = address;
+    return EECR |= (1 << EERE);
+}
+
+void eepromWrite(uint8_t address, uint8_t data) {
+    // wait for previous write
+    while (EECR & (1 << EEPE));
+
+     if (eepromRead(address) != data) {
+        EEAR = address;
+        EEDR = data;
+
+        EECR |= (1 << EEMPE);
+        EECR |= (1 << EEPE);
+    }
+}
+
+void eepromFlush(uint8_t address)  {
+    if (eepromRead(address) != 0) {
+        EEAR = address;
+        EEDR = 0;
+
+        EECR |= (1 << EEMPE);
+        EECR |= (1 << EEPE);
+    }
+}

firmware/atmega/source/main.c

@@ -0,0 +1,54 @@
+#include <stdint.h>
+#include <stdbool.h>
+#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"
+
+volatile uint16_t lastMoistureVal = 0;
+volatile uint16_t *pLastMoistureVal = &lastMoistureVal;
+
+ISR(TWI_vect) {
+    twiListen();
+}
+
+static void watchdogs(void) {
+    cli();
+    MCUSR &= ~(1 << WDRF);
+    WDTCSR |= (1 << WDCE) | (1 << WDE);
+    WDTCSR = (1 << WDIE) | (1 << WDP3) | (1 << WDP0);
+    sei();
+}
+
+static inline void enterSleep(void) {
+    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+    sleep_enable();
+    sleep_cpu();
+    sleep_disable();
+}
+
+static void setup(void) {
+    adcInit();
+    twiInit();
+    sensorsInit();
+    pumpsInit();
+    watchdogs();
+}
+
+int main(void) {
+    setup();
+
+    pLastMoistureVal = &lastMoistureVal;
+
+    while(true) {
+        if ((*pLastMoistureVal = moistureRead()) < MOISTURE_MIN) waterPlant();
+        twiRespond();
+        enterSleep();
+    }
+
+    return -1;
+}

firmware/atmega/source/moisture.c

@@ -0,0 +1,40 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "moisture.h"
+#include "config.h"
+#include "adc.h"
+
+volatile bool readSensors = false;
+
+void sensorsInit(void) {
+    uint8_t sensorMask = 0;
+    for (uint8_t i = 0; i < SENSORS_NUM; i++) {
+        sensorMask |= (1 << sensorPins[i]);
+    }
+    DDRC &= ~sensorMask;
+    PORTC &= ~sensorMask;
+}
+
+static uint16_t moistureAverage(uint8_t sensorPin) {
+    uint16_t sum = 0;
+    for (uint8_t i = 0; i < SENSOR_READINGS; i++) {
+        sum += adcRead(sensorPin);
+        //TODO: implement variance check (if over a certain variance discard measurements for this cycle)
+        //TODO IMPORTANT: if value < 1 or > 1022, discard that measurement
+    }
+    return sum / SENSOR_READINGS;
+}
+
+uint16_t moistureRead(void) {
+    uint16_t overallSum = 0;
+
+    for (uint8_t i = 0; i < SENSORS_NUM; i++) {
+        uint16_t sensorAverage = moistureAverage(sensorPins[i]);
+        //TODO: if a sensor gives 1023, discard that sensor entirely (means it is disconnected or not working)
+        overallSum += sensorAverage;
+    }
+
+    return overallSum / SENSORS_NUM;
+}

firmware/atmega/source/pump.c

@@ -0,0 +1,32 @@
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include "pump.h"
+#include "config.h"
+
+void pumpsInit(void) {
+    uint8_t actuatorMask = 0;
+    for (uint8_t i = 0; i < ACTUATORS_NUM; i++) {
+        actuatorMask |= (1 << actuatorPins[i]);
+    }
+    DDRD |= actuatorMask;
+    //PORTD &= ~(1 << actuatorMask);
+}
+
+static void triggerPump(uint8_t pump_pin) {
+    // Turn on pump
+    PORTD |= (1 << pump_pin);
+
+    _delay_ms(500);
+    // Here there could be the issue of the AVR hanging when pump is on
+
+    // Turn off pump
+    PORTD &= ~(1 << pump_pin);
+}
+
+void waterPlant(void) {
+    for (uint8_t i=0; i < ACTUATORS_NUM; i++) {
+        triggerPump(actuatorPins[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

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

firmware/esp32/Dockerfile

@@ -0,0 +1,48 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    git \
+    wget \
+    flex \
+    bison \
+    gperf \
+    python3 \
+    python3-pip \
+    python3-venv \
+    cmake \
+    ninja-build \
+    ccache \
+    libffi-dev \
+    libssl-dev \
+    dfu-util \
+    libusb-1.0-0 \
+    && apt-get autoremove
+
+WORKDIR /usr/src/
+
+ENV IDF_PATH=/usr/src/esp/esp-idf
+ENV IDF_PATH_FORCE=1
+
+RUN mkdir -p /usr/src/esp/firmware
+RUN git clone --recursive https://github.com/espressif/esp-idf.git $IDF_PATH
+
+RUN cd $IDF_PATH && ./install.sh esp32c3
+
+COPY . /usr/src/esp/firmware/
+
+WORKDIR /usr/src/esp/firmware/
+
+# Create sdkconfig.defaults with correct flash settings
+RUN echo "CONFIG_ESPTOOLPY_FLASHMODE=dio" > sdkconfig.defaults && \
+    echo "CONFIG_ESPTOOLPY_FLASHFREQ=40m" >> sdkconfig.defaults && \
+    echo "CONFIG_ESPTOOLPY_FLASHSIZE=4MB" >> sdkconfig.defaults
+
+RUN rm -rf build && /bin/bash -c "source $IDF_PATH/export.sh && idf.py set-target esp32c3 && idf.py build"
+
+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-thing.bin /usr/src/build/

firmware/esp32/build-esp32.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -e
+
+IMAGE_NAME="esp32-builder"
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+DOCKERFILE="$SCRIPT_DIR/Dockerfile"
+BUILD_CTX="$SCRIPT_DIR"
+DEST_DIR="$SCRIPT_DIR/build"
+
+docker build -t "$IMAGE_NAME" -f "$DOCKERFILE" "$BUILD_CTX"
+
+mkdir -p "$DEST_DIR"
+
+docker run --rm -v "$DEST_DIR":/output "$IMAGE_NAME" cp -r /usr/src/build/. /output/
+
+#echo "Erasing flash..."
+#esptool --chip esp32c3 --port /dev/tty.usbmodem101 erase-flash
+
+esptool --chip esp32c3 --port /dev/tty.usbmodem101 --baud 115200 write-flash \
+  --flash-mode dio \
+  --flash-freq 40m \
+  --flash-size 4MB \
+  0x0000 "$DEST_DIR/bootloader.bin" \
+  0x8000 "$DEST_DIR/partition-table.bin" \
+  0x10000 "$DEST_DIR/plant-thing.bin"
+
+screen -fn /dev/tty.usbmodem101 115200

firmware/esp32/include/config.h

@@ -0,0 +1,31 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#pragma once
+
+// WI-FI
+#define SSID       "your_wifi_ssid"
+#define PASSWORD   "your_wifi_password"
+#define AUTH_MODE  WIFI_AUTH_WPA2_PSK
+
+// MQTT
+#define MQTT_ADDR  "mqtt://yourmqttserver"
+#define MQTT_PORT  1883
+#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

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

firmware/esp32/include/mqtt.hpp

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

firmware/esp32/include/wifi.hpp

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

firmware/esp32/main/CMakeLists.txt

@@ -0,0 +1,16 @@
+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/idf_component.yml

@@ -0,0 +1,2 @@
+dependencies:
+  espressif/mqtt: "*"

firmware/esp32/main/main.cpp

@@ -0,0 +1,59 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "esp_pm.h"
+#include "esp_task_wdt.h"
+#include "wifi.hpp"
+#include "i2c.hpp"
+#include "mqtt.hpp"
+
+#define WATCHDOG_KEEPALIVE_MS 8000
+
+EventGroupHandle_t connectivity_event_group;
+
+static const char* TAG = "MAIN";
+
+volatile bool criticalErrorFlag = false;
+
+static void watchdogTask(void *pvParameters) {
+    esp_task_wdt_config_t twdt_config = {
+        .timeout_ms = 12000,
+        .idle_core_mask = 0,
+        .trigger_panic = true,
+    };
+    ESP_ERROR_CHECK(esp_task_wdt_deinit());
+    ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
+
+    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
+
+    for(;;) {
+        if(criticalErrorFlag) {
+            ESP_LOGE(TAG, "Critical error flag raised. Rebooting.");
+            esp_restart();
+        }
+
+        ESP_ERROR_CHECK(esp_task_wdt_reset());
+        ESP_LOGV(TAG, "WDT reset");
+
+        vTaskDelay(pdMS_TO_TICKS(WATCHDOG_KEEPALIVE_MS));
+    }
+}
+
+extern "C" void app_main(void)
+{
+    static const esp_pm_config_t pm_cfg = {
+        .max_freq_mhz       = 160,
+        .min_freq_mhz       = 10,
+        .light_sleep_enable = true
+    };
+    esp_pm_configure(&pm_cfg);
+
+    connectivity_event_group = xEventGroupCreate();
+
+    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

@@ -0,0 +1,156 @@
+#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.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 rx_buffer[50];
+
+static void mqtt_subscribe(void) {
+    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) {
+    esp_mqtt_event_handle_t event =(esp_mqtt_event_handle_t)event_data;
+
+    switch(event->event_id) {
+        case MQTT_EVENT_CONNECTED:
+            xEventGroupSetBits(connectivity_event_group, MQTT_CONNECTED_BIT);
+            ESP_LOGV(TAG, "Connected to broker");
+            mqtt_subscribe();
+            ESP_LOGV(TAG, "Subscribed to topic");
+            break;
+
+        case MQTT_EVENT_DISCONNECTED:
+            xEventGroupClearBits(connectivity_event_group, MQTT_CONNECTED_BIT);
+            ESP_LOGW(TAG, "Disconnected from broker");
+            break;
+
+        case MQTT_EVENT_DATA:
+        {
+            ESP_LOGD(TAG, "Data received");
+
+            int len = event->data_len;
+            if(len > sizeof(rx_buffer) - 1) len = sizeof(rx_buffer) - 1;
+
+            memcpy(rx_buffer, event->data, len);
+            rx_buffer[len] = '\0';
+
+            break;
+        }
+
+        case MQTT_EVENT_ERROR:
+            ESP_LOGE(TAG, "Error event");
+            if(event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) ESP_LOGE(TAG, "Network Error: %s", strerror(event->error_handle->esp_transport_sock_errno));
+            else if(event->error_handle->error_type == MQTT_ERROR_TYPE_CONNECTION_REFUSED) ESP_LOGE(TAG, "Connection Refused! Reason code: 0x%x", event->error_handle->connect_return_code);
+            break;
+
+        default:
+            break;
+    }
+}
+
+static void mqtt_init(void) {
+    esp_mqtt_client_config_t mqtt_cfg = {};
+    mqtt_cfg.broker.address.uri = MQTT_ADDR;
+    mqtt_cfg.credentials.username = MQTT_USER;
+    mqtt_cfg.credentials.authentication.password = MQTT_PASS;
+
+    mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
+    if(mqtt_client == NULL) {
+        ESP_LOGE(TAG, "esp_mqtt_client_init returned NULL");
+        criticalErrorFlag = true;
+    }
+
+    esp_mqtt_client_register_event(mqtt_client, (esp_mqtt_event_id_t)ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
+
+    esp_mqtt_client_start(mqtt_client);
+}
+
+void mqtt_publish(void) {}
+
+void mqttTask(void *pvParameters) {
+    ESP_LOGV(TAG, "Task started");
+
+    ESP_LOGV(TAG, "Waiting for Wi-Fi before initializing server");
+    xEventGroupWaitBits(connectivity_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
+    ESP_LOGV(TAG, "Server initialized");
+
+    mqtt_init();
+    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
+
+    for(;;) {
+        ESP_LOGV(TAG, "Checking Wi-Fi connection...");
+        EventBits_t bits = xEventGroupWaitBits(connectivity_event_group, WIFI_CONNECTED_BIT | MQTT_CONNECTED_BIT, pdFALSE, pdTRUE, pdMS_TO_TICKS(MQTT_TASK_TIMEOUT_MS));
+
+        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;
+
+            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

@@ -0,0 +1,87 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "esp_task_wdt.h"
+#include "esp_wifi.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "main.hpp"
+#include "config.h"
+
+#define WIFI_TIMEOUT_MS 4500
+
+static const char* TAG = "WIFI";
+
+static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
+    if(event_base == WIFI_EVENT) {
+        switch(event_id) {
+            case WIFI_EVENT_STA_START:
+                ESP_LOGV(TAG, "Process started, connecting...");
+                esp_wifi_connect();
+                break;
+
+            case WIFI_EVENT_STA_DISCONNECTED: {
+                wifi_event_sta_disconnected_t* disconn =(wifi_event_sta_disconnected_t*) event_data;
+                ESP_LOGW(TAG, "Disconnected, reason: %d", disconn->reason);
+
+                xEventGroupClearBits(connectivity_event_group, WIFI_CONNECTED_BIT);
+
+                esp_wifi_connect();
+                vTaskDelay(pdMS_TO_TICKS(2000));
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    else if(event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
+        ip_event_got_ip_t* event =(ip_event_got_ip_t*) event_data;
+        ESP_LOGD(TAG, "Got IP: " IPSTR, IP2STR(&event->ip_info.ip));
+
+        xEventGroupSetBits(connectivity_event_group, WIFI_CONNECTED_BIT);
+    }
+}
+
+static void wifi_init_sta(void) {
+    esp_err_t nvs_err = nvs_flash_init();
+
+    if(nvs_err == ESP_ERR_NVS_NO_FREE_PAGES || nvs_err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ESP_ERROR_CHECK(nvs_flash_init());
+    }
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    esp_netif_create_default_wifi_sta();
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL, NULL));
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL, NULL));
+
+    wifi_config_t wifi_config{};
+    strncpy((char*)wifi_config.sta.ssid, SSID, sizeof(wifi_config.sta.ssid));
+    strncpy((char*)wifi_config.sta.password, PASSWORD, sizeof(wifi_config.sta.password));
+    wifi_config.sta.threshold.authmode = AUTH_MODE;
+    wifi_config.sta.pmf_cfg.capable = true;
+    wifi_config.sta.pmf_cfg.required = false;
+
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
+    ESP_ERROR_CHECK(esp_wifi_start());
+}
+
+void wifiTask(void *pvParameters) {
+    ESP_LOGV(TAG, "Task started");
+
+    wifi_init_sta();
+    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
+
+    for(;;) {
+        ESP_ERROR_CHECK(esp_task_wdt_reset());
+        ESP_LOGV(TAG, "Task reset");
+        vTaskDelay(pdMS_TO_TICKS(WIFI_TIMEOUT_MS));
+    }
+    ESP_LOGW(TAG, "Task exited");
+}

src/Makefile

@@ -1,41 +0,0 @@
-PROJECT = plant-manager
-
-# Flags
-MCU = atmega328p
-F_CPU = 16000000UL
-
-CC = avr-gcc
-OBJCOPY = avr-objcopy
-AVRDUDE = avrdude
-CFLAGS = -Wall -Os -DF_CPU=$(F_CPU) -mmcu=$(MCU)
-
-PROGRAMMER = arduino
-PORT = /dev/ttyACM0
-
-SRC = main.c
-OBJ = $(SRC:.c=.o)
-
-# Default target
-all: $(PROJECT).hex
-
-# Compiler
-%.o: %.c
-	$(CC) $(CFLAGS) -c $< -o $@
-
-# Linker
-$(PROJECT).elf: $(OBJ)
-	$(CC) $(CFLAGS) -o $@ $^
-
-# Create hex file
-$(PROJECT).hex: $(PROJECT).elf
-	$(OBJCOPY) -O ihex -R .eeprom $< $@
-
-# Uploader
-upload: $(PROJECT).hex
-	$(AVRDUDE) -p $(MCU) -c $(PROGRAMMER) -P $(PORT) -U flash:w:$<:i
-
-# Cleaner
-clean:
-	rm -f *.o *.elf *.hex
-
-.PHONY: all upload clean

src/config.h

@@ -1,7 +0,0 @@
-#ifndef CONFIG_H
-#define CONFIG_H
-
-#define MOISTURE_SENSOR_A0 A0
-#define SENSOR_READINGS 3
-
-#endif

src/main.c

@@ -1,42 +0,0 @@
-#include <stdint.h>
-#include <avr/sleep.h>
-#include <avr/wdt.h>
-#include "config.h"
-#include "moisture.h"
-
-ISR(WDT_vect) {
-    readSensors = true;
-}
-
-void watchdogs(void) {
-    cli();
-    MCUSR &= ~(1 << WDRF);
-    WDTCSR |= (1 << WDCE) | (1 << WDE);
-    WDTCSR = (1 << WDIE) | (1 << WDP3) | (1 << WDP0);
-    sei();
-}
-
-void enterSleep(void) {
-    set_sleep_mode(SLEEP_MODE_IDLE);
-    sleep_enable();
-    sleep_cpu();
-    sleep_disable();
-}
-
-void setup(void) {
-    Serial.begin(9600);
-    initMoistureSensor();
-    watchdogs();
-}
-
-void loop(void) {
-    if (readSensors) {
-        int16_t result = readMoisture();
-        if (result != -1) {
-            Serial.println(result);
-            readSensors = false;
-        }
-    }
-
-    enterSleep();
-}

src/moisture.cpp

@@ -1,36 +0,0 @@
-#include <Arduino.h>
-#include <stdint.h>
-#include "moisture.h"
-#include "config.h"
-
-static int16_t moistureReadingSum = 0;
-static int8_t moistureReadingCount = 0;
-
-volatile bool readSensors = false;
-
-void initMoistureSensor(void) {
-    pinMode(MOISTURE_SENSOR_A0, INPUT);
-}
-
-void triggerSensorRead(void) {
-    readSensors = true;
-}
-
-int16_t readMoisture(void) {
-    if (!readSensors)
-        return -1;
-
-    moistureReadingSum += analogRead(MOISTURE_SENSOR_A0);
-    moistureReadingCount++;
-
-    if (moistureReadingCount >= SENSOR_READINGS) {
-        int16_t avg = moistureReadingSum / SENSOR_READINGS;
-        //Serial.println(avg);
-        moistureReadingSum = 0;
-        moistureReadingCount = 0;
-        readSensors = false;
-        return avg;
-    } else readSensors = true;
-
-    return -1;
-}

src/moisture.h

@@ -1,13 +0,0 @@
-#ifndef MOISTURE_H
-#define MOISTURE_H
-
-#include <stdint.h>
-#include <stdbool.h>
-
-void initMoistureSensor(void);
-int16_t readMoisture(void);
-void triggerSensorRead(void);
-
-extern volatile bool readSensors;
-
-#endif