Upload files

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/.name

@@ -0,0 +1 @@
+SeeDatResistance

.idea/encodings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/test.txt" charset="UTF-8" />
+  </component>
+</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,12 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N806" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9" project-jdk-type="Python SDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/SeeDatResistance.iml" filepath="$PROJECT_DIR$/SeeDatResistance.iml" />
+    </modules>
+  </component>
+</project>

ReadAnalog/.gitignore

@@ -0,0 +1,5 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

ReadAnalog/.history/getPlatformio_20220326200316.py

@@ -0,0 +1,26 @@
+# Run this first if running everything in non-VSCode ide
+import os
+
+option = "build"  # build, upload, clean, or read
+
+if os.name == 'nt':
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'Scripts', 'platformio.exe')
+else:
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'bin', 'platformio')
+if not os.path.exists(platformio):
+    import requests, base64
+    s = requests.Session()
+    s.trust_env = None  # for anyone running on proxy
+    r = s.get('https://api.github.com/repos/platformio/platformio-core-installer/contents/get-platformio.py?ref=develop').json()
+    exec(base64.b64decode(r['content']))
+
+
+params = {
+    'build': 'run',
+    'upload': 'run --target upload',
+    'clean': 'run --target clean',
+    'read': 'device monitor'
+}
+
+
+os.system(f'{platformio} {params[option]}')  # put one of the three function from above

ReadAnalog/.history/getPlatformio_20220514231848.py

@@ -0,0 +1,26 @@
+# Run this first if running everything in non-VSCode ide
+import os
+
+option = "upload"  # build, upload, clean, or read
+
+if os.name == 'nt':
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'Scripts', 'platformio.exe')
+else:
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'bin', 'platformio')
+if not os.path.exists(platformio):
+    import requests, base64
+    s = requests.Session()
+    s.trust_env = None  # for anyone running on proxy
+    r = s.get('https://api.github.com/repos/platformio/platformio-core-installer/contents/get-platformio.py?ref=develop').json()
+    exec(base64.b64decode(r['content']))
+
+
+params = {
+    'build': 'run',
+    'upload': 'run --target upload',
+    'clean': 'run --target clean',
+    'read': 'device monitor'
+}
+
+
+os.system(f'{platformio} {params[option]}')  # put one of the three function from above

ReadAnalog/.history/getPlatformio_20220514231927.py

@@ -0,0 +1,27 @@
+# Run this first if running everything in non-VSCode ide
+import os
+
+option = "upload"  # build, upload, clean, or read
+
+if os.name == 'nt':
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'Scripts', 'platformio.exe')
+else:
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'bin', 'platformio')
+if not os.path.exists(platformio):
+    # Platformio not exist, 
+    import requests, base64
+    s = requests.Session()
+    s.trust_env = None  # for anyone running on proxy
+    r = s.get('https://api.github.com/repos/platformio/platformio-core-installer/contents/get-platformio.py?ref=develop').json()
+    exec(base64.b64decode(r['content']))
+
+
+params = {
+    'build': 'run',
+    'upload': 'run --target upload',
+    'clean': 'run --target clean',
+    'read': 'device monitor'
+}
+
+
+os.system(f'{platformio} {params[option]}')  # put one of the three function from above

ReadAnalog/.history/getPlatformio_20220514231936.py

@@ -0,0 +1,27 @@
+# Run this first if running everything in non-VSCode ide
+import os
+
+option = "upload"  # build, upload, clean, or read
+
+if os.name == 'nt':
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'Scripts', 'platformio.exe')
+else:
+    platformio = os.path.join(os.path.expanduser('~'), '.platformio', 'penv', 'bin', 'platformio')
+if not os.path.exists(platformio):
+    # Platformio not exist, run setup from web
+    import requests, base64
+    s = requests.Session()
+    s.trust_env = None  # for anyone running on proxy
+    r = s.get('https://api.github.com/repos/platformio/platformio-core-installer/contents/get-platformio.py?ref=develop').json()
+    exec(base64.b64decode(r['content']))
+
+
+params = {
+    'build': 'run',
+    'upload': 'run --target upload',
+    'clean': 'run --target clean',
+    'read': 'device monitor'
+}
+
+
+os.system(f'{platformio} {params[option]}')  # put one of the three function from above

ReadAnalog/.history/src/main_20220512085328.cpp

@@ -0,0 +1,9 @@
+#include <Arduino.h>
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085541.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085544.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085545.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[]
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085553.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {}
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085557.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2}
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085558.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4}
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085630.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A}
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085631.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5}
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085634.cpp

@@ -0,0 +1,10 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085641.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085645.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085647.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[]
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085651.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof]
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085653.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)]
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085656.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2]
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085657.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+
+void setup() {
+  // put your setup code here, to run once:
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085707.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+
+void setup() {
+  for 
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085709.cpp

@@ -0,0 +1,11 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085713.cpp

@@ -0,0 +1,12 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085715.cpp

@@ -0,0 +1,12 @@
+#include <Arduino.h>
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085721.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085726.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+#define 
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085728.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+#define WAIT
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085730.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+#define WAIT_TIME
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085732.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+#define WAIT_TIME  
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085735.cpp

@@ -0,0 +1,14 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085741.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int curr
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085747.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis()
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085750.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis();  // non
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085755.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085759.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i)
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085802.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0)
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085803.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0;)
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085808.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0;)
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085810.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0; i )
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085812.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0; i < )
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085816.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0; i < sizeof(pins)/2)
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085821.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+  for (i = 0; i < sizeof(pins)/2; i ++) {
+    
+  }
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085834.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime = millis();  // non-blocking timer
+
+void setup() {
+
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085840.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j = 0;
+int currTime;  // non-blocking timer
+
+void setup() {
+
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085841.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085849.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085851.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085852.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}

ReadAnalog/.history/src/main_20220512085900.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = )
+}

ReadAnalog/.history/src/main_20220512085902.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; )
+}

ReadAnalog/.history/src/main_20220512085904.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < )
+}

ReadAnalog/.history/src/main_20220512085908.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof)
+}

ReadAnalog/.history/src/main_20220512085912.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins))
+}

ReadAnalog/.history/src/main_20220512085915.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins))
+}

ReadAnalog/.history/src/main_20220512085917.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2)
+}

ReadAnalog/.history/src/main_20220512085920.cpp

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i)
+}

ReadAnalog/.history/src/main_20220512085923.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    
+  }
+}

ReadAnalog/.history/src/main_20220512085929.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data
+  }
+}

ReadAnalog/.history/src/main_20220512085930.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[]
+  }
+}

ReadAnalog/.history/src/main_20220512085933.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = 
+  }
+}

ReadAnalog/.history/src/main_20220512085935.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = ana
+  }
+}

ReadAnalog/.history/src/main_20220512085943.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead
+  }
+}

ReadAnalog/.history/src/main_20220512085944.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead()
+  }
+}

ReadAnalog/.history/src/main_20220512085947.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i])
+  }
+}

ReadAnalog/.history/src/main_20220512085949.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i];)
+  }
+}

ReadAnalog/.history/src/main_20220512085953.cpp

@@ -0,0 +1,17 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512085959.cpp

@@ -0,0 +1,18 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  anal
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090002.cpp

@@ -0,0 +1,18 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  analogReference
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090004.cpp

@@ -0,0 +1,18 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  analogReference(0)
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090006.cpp

@@ -0,0 +1,18 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+int currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090025.cpp

@@ -0,0 +1,18 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090028.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090032.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  if
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090038.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  if ()
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090040.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  if (currTime)
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090047.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis;
+}
+
+void loop() {
+  if (millis() - currTime)
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090052.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime)
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090055.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime )
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090059.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= )
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090100.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= W)
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090103.cpp

@@ -0,0 +1,19 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME)
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090107.cpp

@@ -0,0 +1,21 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    
+  }
+  for (i = 0; i < sizeof(pins)/2; i++) {
+    data[i] = analogRead(pins[i]);
+  }
+}

ReadAnalog/.history/src/main_20220512090110.cpp

@@ -0,0 +1,21 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090114.cpp

@@ -0,0 +1,22 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+        
+  }
+
+}

ReadAnalog/.history/src/main_20220512090117.cpp

@@ -0,0 +1,22 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090119.cpp

@@ -0,0 +1,22 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = mil    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090122.cpp

@@ -0,0 +1,22 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090127.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  Serial
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090128.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  Serial.
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090132.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  Serial.b
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090138.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  Serial.begin
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}

ReadAnalog/.history/src/main_20220512090139.cpp

@@ -0,0 +1,23 @@
+#include <Arduino.h>
+#define WAIT_TIME  1000L
+
+int pins[] = {A0, A1, A2, A3, A4, A5};
+int data[sizeof(pins)/2];
+int i, j;
+unsigned long currTime;  // non-blocking timer
+
+void setup() {
+  Serial.begin()
+  // analogReference(0);
+  currTime = millis();
+}
+
+void loop() {
+  if (millis() - currTime >= WAIT_TIME) {
+    for (i = 0; i < sizeof(pins)/2; i++) {
+      data[i] = analogRead(pins[i]);
+    }
+    currTime = millis();    
+  }
+
+}