add thoughts

Author: g-sam

README.md

@@ -3,25 +3,57 @@
 Components:
 
 - SDS011 particulate sensor
-- Wemos D1 mini pro (ESP8266)
+- Wemos D1 mini pro (based on ESP8266)
 - Some wires
 
 Ultra simple wiring and ultra simple programming with Micropython! The SDS011 communicates over serial with a protocol detailed here http://cl.ly/ekot: 
 
-SDS011      Wemos 
+SDS011 -- Wemos 
 
-  TX   -->   RX    
-  RX   <--   TX  
-  5v   <--   5v  
-  GND  -->   GND   
+  TX   --   RX    
+  RX   --   TX  
+  5v   --   5v  
+  GND  --   GND   
 
 Wemos has only one serial-in and Micropython has no software serial library, so the device cannot be accessed when it is connected to the sensor. Luckily, the webrepl can be used to interact with the device instead.
 
-Ideally, the sensor would be put to sleep and woken periodically. While the sleep command works, I CANNOT GET THE SENSOR TO WAKE UP!
+Ideally, the sensor would be put to sleep and woken periodically. There are some issues with this:
+ - Printing anything to webrepl wakes the sensor up and it ceases to interpret sleep and wake signals properly
+ - Sending the Wemos into deep sleep also wakes up the sensor! 
 
-Entering deep sleep on the Wemos does not help as the SDS011 continues to draw power.
+As a temporary workaround, I am using the dutycycle mode on the SDS011. This helps to preserve the life of the sensor and is fine for indoor use, but is not a good solution for battery operation because:
+ - The sensor periodically wakes up, waits 60 secs, then issues a single reading before sleeping again. Since the documented initialization time of the sensor is 30 secs (and in my experience more like 10), that's a lot of wasted fan-time. 
+ - The Wemos remains fully powered, drawing 50-200mA (although light sleep might be possible for around 1mA)
 
-As a temporary workaround, I am using the dutycycle mode: the Wemos remains on and the sensor kicks in every minute or so.
+## Going outdoors
 
-TODO: investigate having the sensor wake up the Wemos from deep sleep when the dutycycle kicks in. 
+Some possible solutions for an immobile battery-operated version:
+1) Use the dutycycle mode with a sleeping Wemos, but have the sensor initialization wake up the Wemos with a low pulse to RST (may not work if deep sleep interferes with the dutycycle). Requires a flip-flop circuit (https://github.com/esp8266/Arduino/issues/1488)? 
+2) Use something (relay? MOSFET?) between the Wemos and the SDS011 to cut the connection before entering deep sleep. 
+3) Hook the whole circuit to a MOSFET controlled by an ATiny85 or similar. This would provide better efficiency (because we would be sleeping the ATiny85 instead of the Wemos, which would be completely powered down), but is more complicated. 
 
+Let's evaluate some options assuming a 10 minute wake interval, 30 sec working period (so 3 minutes / hour awake), and the following power factors:
+ - SDS011 consumes 70mA (awake) or <4mA (asleep)
+ - Wemos consumes 150mA on average when awake or 5mA in light sleep
+ - Deepsleep on Wemos consumes 2/3 times more than on esp8266 because of the USB-TTL converter: probably equates to around 0.1mA in total 
+ - At 1MHz the ATTiny85 consumes 2.5mA (awake) or 0.0005mA (asleep)
+ - 3 AA batteries providing 7200mAh total
+ - 70% efficiency 
+
+As is: (7200 * 60 * 0.7) / (3 * (70 + 150) + 57 * (150 + 4) = 32 hours 
+
+Without ATTiny but with relay: (7200 * 60 * 0.7) / (3 * (70 + 150) + 57 * 0.1) = 454 hours or 19 days 
+
+With ATTiny: (7200 * 60 * 0.7) / (3 * (70 + 150 + 2.5) + 57 * 0.0005) = 453 hours 
+
+What about using the ATTiny and turning on the Wemos only for last 7 secs of 30sec working period (say, 0.7 mins / hour @ 200mA)? (7200 * 60 * 0.7) / (3 * (70 + 2.5) + 0.7 * 200 + 57 * 0.0005) = 845 hours or 35 days.
+
+If the Wemos can request time and pass it to ATTiny85, we can sleep 6 hours at night as well, bringing us up to around 1120 hours. 
+
+## Portability
+
+Another desideratum is the ability pair with a phone and transmit on the fly, or store measurements for transmission later.
+
+Storing: by default we get 6 bytes of data every second. After 30 mins that's 11kb. The Wemos has 96 kb of data RAM so we should be fine... We could also move into the 4 mb of flash, but must be careful as it is limited to 100,000 write/erase cycles.
+
+For gps data we need the phone. It should be possible for the phone to connect to the Wemos set up as an access point. Battery life on wifi might be expected to be 7200 * 0.7 / 200 = 25 hours. But it might make more sense to move to the ESP32 (which also has bluetooth) for this. 

boot.py

@@ -6,7 +6,7 @@
 import utime as time
 gc.collect()
 
-print('\nbooting...')
+# print('\nbooting...')
 
 def do_connect():
     import network
@@ -17,19 +17,19 @@ def do_connect():
 
     ap_if = network.WLAN(network.AP_IF)
     ap_if.config(essid='Polly', password=pw)
-    print('access point Polly open')
+    # print('access point Polly open')
 
     sta_if = network.WLAN(network.STA_IF)
     if not sta_if.isconnected():
-        print('connecting to network...')
+        # print('connecting to network...')
         sta_if.active(True)
         sta_if.connect('Bam-net', pw)
         while not sta_if.isconnected():
             pass
-    print('connected at:', sta_if.ifconfig())
+    # print('connected at:', sta_if.ifconfig())
 
 do_connect()
 webrepl.start()
 time.sleep(1)
-print('Booted!')
+# print('Booted!')
 

main.py

@@ -5,9 +5,11 @@
 if machine.reset_cause() == machine.DEEPSLEEP_RESET:
     print('Woke from a deep sleep')
 
-READ_SECONDS = 55
-SLEEP_SECONDS = 5
+READ_SECONDS = 20
+SLEEP_SECONDS = 600
+DUTYCYCLE_REST_MINS = 2
 
-sds011.set_dutycycle(1)
-sds011.read();
+# sds011.set_dutycycle(DUTYCYCLE_REST_MINS)
+print('Reading from sds011 for', READ_SECONDS, 'secs')
+sds011.read(READ_SECONDS);
 # esp.deepsleep(SLEEP_SECONDS * 1000000)

sds011.py

@@ -35,38 +35,39 @@ def make_command(cmd, mode, param):
     tail = b'\xab'
     return header + cmd + mode + param + padding + bytes(checksum, 'utf8') + tail
 
-def no_response():
+def confirm_response(confirmation):
     if (uart.read(1) == b'\xaa'):
         if (uart.read(1) == b'\xc5'):
-            return False
-    time.sleep_ms(500)
-    return True
+            print(confirmation)
 
+# sensor wakes for 60 secs before issuing measurment
 def set_dutycycle(rest_mins):
     global uart
     cmd = make_command(CMDS['DUTYCYCLE'], CMDS['SET'], chr(rest_mins))
-    while no_response():
-        print('Setting sds011 to read every', rest_mins, 'minutes:', cmd)
-        uart.write(cmd)
-    print('sds011 duty cycle set!')
+    print('Setting sds011 to read every', rest_mins, 'minutes:', cmd)
+    uart.write(cmd)
+    time.sleep_ms(1000)
+    read(2)
 
 def wake():
     global uart
     cmd = make_command(CMDS['SLEEPWAKE'], CMDS['SET'], chr(1))
-    while no_response():
-        print('Sending wake command to sds011:', cmd)
-        uart.write(cmd)
-    print('sds011 woke up!')
+    print('Sending wake command to sds011:', cmd)
+    uart.write(cmd)
+    time.sleep_ms(12000)
+    read(2)
 
 def sleep():
     global uart
     cmd = make_command(CMDS['SLEEPWAKE'], CMDS['SET'], chr(0))
-    while no_response():
-        print('Sending sleep command to sds011:', cmd)
-        uart.write(cmd)
-    print('sds011 successfully put to sleep')
+    print('Sending sleep command to sds011:', cmd)
+    uart.write(cmd)
+    time.sleep_ms(2000)
 
-def process_packet(packet):
+def process_reply(packet):
+    print('Reply received:', packet)
+
+def process_measurement(packet):
     try:
         print('\nPacket:', packet)
         *data, checksum, tail = struct.unpack('<HHBBBs', packet)
@@ -88,17 +89,19 @@ def process_packet(packet):
 
 def read(allowed_time=0):
     global uart
-    print('Reading from sds011 for', (allowed_time / 1000), 'secs')
     start_time = time.ticks_ms()
     delta_time = 0
-    while (delta_time <= allowed_time):
+    while (delta_time <= allowed_time * 1000):
         try:
             header = uart.read(1)
             if header == b'\xaa':
                 command = uart.read(1)
                 if command == b'\xc0':
                     packet = uart.read(8)
-                    process_packet(packet)
+                    process_measurement(packet)
+                elif command == b'\xc5':
+                    packet = uart.read(8)
+                    process_reply(packet)
             delta_time = time.ticks_diff(time.ticks_ms(), start_time) if allowed_time else 0
         except Exception as e:
             print('Problem attempting to read:', e)