diff --git a/greenhouse.ino b/greenhouse.ino
new file mode 100644
index 0000000..e5bcaa4
--- /dev/null
+++ b/greenhouse.ino
@@ -0,0 +1,226 @@
+#include <LowPower.h>
+#include <SPI.h>
+#include <LoRa.h>
+#include <EEPROM.h>
+
+int motor_in_1 = 5;
+int motor_in_2 = 6;
+int motor_sleep_pin = 4;
+#define SAMPLES 5
+int sample_idx = 0;
+int voltage_reads[SAMPLES];
+int moisture_reads[SAMPLES];
+
+#define NODEBUG
+ 
+#ifdef DEBUG
+#define DPRINTLN(str)    Serial.println(str)
+#define DPRINT(str)      Serial.print(str)
+#define DPRINTHEX(b)     Serial.print(b, HEX)
+#define DFLUSH           Serial.flush()
+#else
+#define DPRINTLN(str)
+#define DPRINT(str)
+#define DPRINTHEX(b)
+#define DFLUSH
+#endif
+
+/*
+ * voltage: 161 fully charged, 1.37V each cell
+ * voltage: 162 fully charged + bit of sun.
+ * voltage: 155 after running quite a bit
+ * moisture: 880 dry / 600 wet
+ */
+
+#define WAIT_FOR_DELAY_OR_DRY   0
+#define WATER_TILL_WET_MAX_TIME 1
+#define WAIT_FOR_MAX_TIME       2
+#define DRY 690
+#define WET 660
+#define DELAY 8 // hours
+#define MAX_TIME 20 // mins
+#define PUMP_SPEED 128
+#define STATION_ID 2
+#define HOME_ID 1
+#define INTERVAL 10 // seconds
+
+struct Header {
+  uint8_t to;
+  uint8_t from;
+  uint8_t seq;
+  uint8_t flags;
+};
+
+struct State {
+  unsigned int voltage, moisture, intervals;
+  unsigned int dry, wet;
+  byte state, delay_hours, max_time_mins, pumpSpeed;
+  bool pumpRunning;
+  byte errors;
+};
+
+struct Payload {
+  Header header;
+  State state;
+};
+
+State state;
+Header my_header = {
+  HOME_ID, STATION_ID, 0, 0
+};
+
+void setup() {
+#ifdef DEBUG
+  Serial.begin(9600);
+#endif
+  state.state = WAIT_FOR_DELAY_OR_DRY;
+  state.intervals = 0;
+  state.pumpRunning = false;
+  state.pumpSpeed = PUMP_SPEED;
+  state.dry = DRY;
+  state.wet = WET;
+  state.delay_hours = DELAY;
+  state.max_time_mins = MAX_TIME;
+  state.errors = 0;
+//  DPRINTLN("Setting one time state to EEPROM");
+//  EEPROM.put(0, state);
+
+  analogReference(DEFAULT);
+  LoRa.setPins(10, 9, 2);
+  LoRa.enableCrc();
+  LoRa.begin(868E6);
+  LoRa.onReceive(onReceive);
+  pumpOff();
+  for (int i=0; i<SAMPLES; i++) {
+    voltage_reads[i] = analogRead(A0);
+    moisture_reads[i] = analogRead(A1);
+    delay(50);
+  }
+  LoRa.receive();
+}
+
+void pumpOn(int speed) {
+  pinMode(motor_in_1, OUTPUT);
+  pinMode(motor_in_2, OUTPUT);
+  pinMode(motor_sleep_pin, OUTPUT);
+  digitalWrite(motor_sleep_pin, HIGH);
+  digitalWrite(motor_in_1, LOW);
+  analogWrite(motor_in_2, speed);
+  state.pumpRunning = true;  
+}
+
+void pumpOff() {
+  pinMode(motor_in_1, OUTPUT);
+  pinMode(motor_in_2, OUTPUT);
+  pinMode(motor_sleep_pin, OUTPUT);
+  digitalWrite(motor_in_1, LOW);
+  digitalWrite(motor_in_2, LOW);
+  digitalWrite(motor_sleep_pin, LOW);
+  state.pumpRunning = false;  
+}
+
+void loop() {
+  voltage_reads[sample_idx] = analogRead(A0);
+  moisture_reads[sample_idx] = analogRead(A1);
+  sample_idx = (sample_idx + 1) % SAMPLES;
+  
+  int voltage = voltage_reads[0];
+  int moisture = moisture_reads[0];
+  for (int i = 1; i < SAMPLES; i++) {
+    voltage = voltage + voltage_reads[i];
+    moisture = moisture + moisture_reads[i];
+  }
+  state.voltage = voltage / SAMPLES;
+  state.moisture = moisture / SAMPLES;
+  DPRINT("voltage = ");
+  DPRINTLN(state.voltage);
+  DPRINT("moisture = ");
+  DPRINTLN(state.moisture);
+  DPRINT("state = ");
+  DPRINTLN(state.state);
+  DPRINT("intervals = ");
+  DPRINTLN(state.intervals);
+  DFLUSH;
+  switch(state.state) {
+    case WAIT_FOR_DELAY_OR_DRY:
+      if ((state.moisture >= state.dry) || (state.intervals > (state.delay_hours * 60 * 60 / INTERVAL))) {
+        state.state = WATER_TILL_WET_MAX_TIME;
+        pumpOn(state.pumpSpeed);
+        state.intervals = 0;
+      }
+      break;
+    case WATER_TILL_WET_MAX_TIME:
+      if (state.intervals > (state.max_time_mins * 60 / INTERVAL)) {
+        // not yet wet enough, so leave for another MAX_TIME before watering
+        state.state = WAIT_FOR_MAX_TIME;
+        pumpOff();
+        state.intervals = 0;
+      } else if (state.moisture <= state.wet) {
+        state.state = WAIT_FOR_DELAY_OR_DRY;
+        pumpOff();
+        state.intervals = 0;
+      }
+      break;
+    case WAIT_FOR_MAX_TIME:
+      if (state.intervals > (state.max_time_mins * 60 / INTERVAL)) {
+        state.state = WATER_TILL_WET_MAX_TIME;
+        pumpOn(PUMP_SPEED);
+        state.intervals = 0;
+      }
+      break;
+    default:
+      state.state = WAIT_FOR_DELAY_OR_DRY;
+      pumpOff();
+      state.intervals = 0;
+      state.errors++;
+  }
+  sendState();
+  if (state.pumpRunning) {
+    delay(INTERVAL * 1000);
+//    LowPower.idle(SLEEP_8S, ADC_OFF, TIMER2_ON, TIMER1_ON, TIMER0_ON, 
+//        SPI_OFF, USART0_OFF, TWI_OFF);
+  } else {
+//    LowPower.powerDown(SLEEP_2S, ADC_OFF, BOD_OFF);
+    delay(2000);
+    LoRa.sleep();
+    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
+//    delay(8000);
+  }
+  state.intervals++;
+}
+
+void sendState() {
+  LoRa.beginPacket();
+  LoRa.write((byte *)&(my_header), sizeof(Header));
+  LoRa.write((byte *)&(state), sizeof(State));
+  LoRa.endPacket();
+  LoRa.receive();
+}
+
+void onReceive(int packetSize) {
+  DPRINT("Received packet, size=");
+  DPRINTLN(packetSize);
+  if (packetSize == (sizeof(Header) + sizeof(State))) {
+    DPRINT("Reading: ");
+    Header their_header;
+    for (int i=0; i<sizeof(Header); i++) {
+      byte b = LoRa.read();
+      DPRINTHEX(b);
+      ((byte *)&their_header)[i] = b;
+    }
+    bool for_me = ((their_header.to == STATION_ID) && (their_header.from == HOME_ID));
+    DPRINTLN("");
+    DPRINT("For me: ");
+    DPRINTLN(for_me);
+    for (int i=0; i<sizeof(State); i++) {
+      byte b = LoRa.read();
+      if (for_me) {
+        ((byte *)&state)[i] = b;
+      }
+      DPRINTHEX(b);
+    }
+  }
+  DPRINTLN("");
+  DPRINTLN("Finished onReceive()");
+  LoRa.sleep();
+}