project-hermes / hermes-sensor Goto Github PK

It would be cool to have a logo

Currently the device will block the running code if it does not have wifi.

This needs to change to check if there is wifi and internet, if so then connect to the cloud, if not then move on.

https://docs.particle.io/reference/device-os/firmware/argon/#semi-automatic-mode

We need to update the OS as there are many bugs that have been fixed and the Serial Logging system is only available in this version and higher. See the link below for release info.
https://github.com/particle-iot/firmware/releases/tag/v0.6.0
Note we are upgrading to v0.6.4 as it will be the needed version to move to v0.7.0 in the future

v0.6.0 features that matter:

• Logging library for flexible system and application logging
• [Electron] Reduced data consumption connecting to the cloud with deep sleep. (See the Docs for how to gain the full data reduction.)
• [Electron] Firmware Reset now available.
• [Electron] now allows OTA bootloader updates
• Added Daylight Saving Time support

Might want to think about auto-deploy from prod but that will use a lot of data

On startup the sensor will check in EPROM if there is a version number. If there is none then we added one and hit the sensorCreate pub/sub. If there is a version number but it is not the same version than we update it and hit the snesorCreate pub/sub.

Analyze raw logs, esp LOG00029

zipped clean data instead of transformed and byte-packing.

Run some experiments re: data size

I need to set up a tool kit that will have everything to repair a sensor even on board the boat.
I should create the checklist in the wiki.

• When diving turn off cellular and GPS.
• When at the surface
• • turn on GPS and keep on until we have a good lock (need to define good)
• • turn on cellular and check for signal
• • • if we cant get cellular for more than 10 min they just turn off and try again in a half hour
• Once data has been sent wait for (some time) then shut off, requiring the user to hit the on button to begin dive again.

https://github.com/project-hermes/BlueRobotics_TSYS01_Library

https://www.arduino.cc/en/Hacking/LibraryTutorial

Wrap SerialLogHandler and clone output to optional SD card for increased storage capability.

Also allows us to work around #3 until a solution is found

I can not seem to figure out how to use the serial logger. It creates an error every-time at compilation.
'SerialLogHandler' does not name a type
Searched everywhere and I can't see a need for an import or anything. I don't want to make an account with the particle community as they are not using single sign on. I did email them about that.

https://github.com/greiman/SdFat-Particle

This will be used for logging #15 and other large longterm storage

This will keep device in automatic mode, leave wifi one and keep OTA updates one for simple development. The device will also print out the dive data over serial logging.

https://docs.particle.io/reference/device-os/firmware/argon/#ready--2

Beginning with 0.8.0 release, Particle.publish() and Particle.subscribe() methods will require event scope to be specified explicitly. Please update your apps now to include the event scope to avoid compilation errors in >=0.8.0.

We need to define a structure to the data that will be sent out. We will not has the auto transmit be done with a publish for each data value. It would take up to much of the data plan.

NOTE: this is not supported for argon ATM

https://docs.particle.io/reference/device-os/firmware/argon/#sleep-sleep-

For the two dev system, we should just create test topics and cloud functions to make testing simple

See project-hermes/hermes-firebase#15

3 topics, 3 functions on sensor for firebase responses:

1. Sensor: publish createDive(char format, int sensorDiveId, float latStart, longStart, latEnd, longEnd, int sampleCount, timestamp epochStart, epochEnd)

• Firebase generates new Dive document with ID firebaseDiveId (hash of properties to tolerate repeat? If not, on repeat we get two partial dives and retry)
• Firebase: poke sensor with readyToReceive(string firebaseDiveId, int sensorDiveId)

2. Sensor: loop publish diveAppend(char format, int sensorDiveId, timestamp firstDataTime, 41x6byte(depth,temp1,temp2))

• Firebase determines firebaseDiveId of "active" dive to which to append via one of three options:
  • stores both sensorDiveId and firebaseDiveId as "lastDiveId_sensor" and "lastDiveId_firebase" on the Sensor object, which it Gets
  • queries Dives that are children of this Sensor for most recent LastUpdatedAt or LastCreatedAt, uses that one (and still verifies sensorDiveId match); this avoids storing state on the Sensor
  • change message formate above: sensor sends full firebaseDiveId per packet (high overhead)

3. Sensor: with tuned backoff, publish diveDone(char format, int sensorDiveId, string firebaseDiveId)

• Firebase: count Data collection under active Dive: if == Dive.sampleCount, poke sensor with diveComplete(string firebaseDiveId, int sensorDiveId)
  -- non-response is "not done"

if Firebase ever errors, log error info under errorId, poke sensor with stopSending(string firebaseDiveId, int sensorDiveId, string errorId)

• if we receive enough of these or otherwise have to resend 3 times
• Sensor: emergency REST dump dive to raw-dive-dump endpoint for manual debugging and data recovery

If the batt is getting low Hermes will send any data is has and then stop operations until charges to 80%?

https://docs.particle.io/reference/device-os/firmware/argon/#off--2

https://docs.particle.io/reference/device-os/firmware/argon/#manual-mode

RAM is too small for a long dive (e.g. nitrox); when we fill it, we need to dump to block storage. To save battery and prevent write latency from blocking data recording, we don't write to SD until we have a large block of data to write at once.

Obviously depends on #16

We need the computer to read from the depth sensor. This will include the depth/pressure conversion and reading the temperature.

Resources:
https://www.bluerobotics.com/store/electronics/bar30-sensor-r1/
http://docs.bluerobotics.com/bar30/
http://docs.bluerobotics.com/bar30/#example-code
https://github.com/bluerobotics/BlueRobotics_MS5837_Library

• Flash yellow for start up and sending data (this is basically the same thing)
• Solid green for ready to dive
• Pulse green for diving
• Blink green when getting ready for next dive but not sending data
• Flashing red for error
• Solid red for FUBR

https://docs.particle.io/reference/device-os/firmware/argon/#logging

We need a name for this damn thing. Any ideas? Hermes is the name of the project but I am not sure that will be a good name long term for the individual sensor.

initiate after 5 min good cell signal

Topic per sensor, shared cloud function

1. Sensor sends dive header with dive info (ID, start/stop GPS and time, data point count)
2. Firebase creates Dive, sends ACK via REST
3. Sensor dumps data (dive ID x1 , data triplet xMany in each 255 byte packet)
4. Sensor waits expected processing time, sends next dive header or Done (final header)
5. Firebase checks if it got everything. If not, resend request via REST. If good, ACK next
6. Sensor: On ACK done, can delete data. On resend, resend all (to be improved if not rare; we have to handle repeat data points anyway because of at-least-once guarantee on cloud functions).

If we have to resend some number of times, assume we have bad connection; signal to diver to press wake-up button later when they're in a different, hopefully better cell area; also stackdriver alert us about it.

https://docs.particle.io/reference/device-os/firmware/argon/#manual-mode

Will the SD card be able to write data fast enough for a 1 second read write time?

https://github.com/particle-iot/AssetTracker/blob/aa63762d9e28a24bdd55512e5734eb66113e7a2c/src/AssetTracker.cpp#L135

https://www.seeedstudio.com/Grove---Protoshield-p-772.html
https://www.seeedstudio.com/Grove-Universal-4-pin-connector-p-789.html

https://github.com/project-hermes/BlueRobotics_MS5837_Library
https://www.mouser.com/ds/2/418/MS5837-30BA-736494.pdf
https://www.arduino.cc/en/Hacking/LibraryTutorial

Need to ready the data from the Blue Robotics Temp sensors

Resources:
https://www.bluerobotics.com/store/electronics/celsius-sensor-r1/
http://docs.bluerobotics.com/celsius/
http://docs.bluerobotics.com/celsius/#example-code
https://github.com/bluerobotics/BlueRobotics_TSYS01_Library

The device is flashing blue very fast. The serial log shows it is trying to send HELLO but fails and keeps looping in this fail. Have tried the doctor to no success. Please help as we are doing field trials soon.

Logs are:

0000002065 [system] INFO: Sim Ready
0000002065 [system] INFO: ARM_WLAN_WD 1
0000002436 [system] INFO: ARM_WLAN_WD 2
0000002436 [system] INFO: CLR_WLAN_WD 1, DHCP success
0000002441 [system] WARN: Public Server Key was blank, restoring.
0000002443 [comm] INFO: channel inited
0000002444 [system] INFO: Cloud: connecting
0000002445 [system] WARN: Public Server Address was blank, restoring.
0000002445 [system] INFO: Read Server Address = type:1,domain:$id.udp.particle.io
0000004939 [system] INFO: Resolved host 1e0034001847373130353639.udp.particle.io to 54.157.13.160
0000005029 [system] INFO: Cloud socket connected
0000005029 [system] INFO: Starting handshake: presense_announce=0
0000005030 [comm.protocol.handshake] INFO: Establish secure connection
0000005039 [comm.dtls] INFO: (CMPL,RENEG,NO_SESS,ERR) restoreStatus=2
0000010642 [comm.protocol.handshake] INFO: Sending HELLO message
0000079000 [comm.dtls] INFO: session cmd (CLS,DIS,MOV,LOD,SAV): 0
0000079000 [comm.protocol.handshake] ERROR: Could not send HELLO message: 10
0000079001 [system] INFO: Send event spark/device/key/error=5
0000079001 [system] WARN: Cloud handshake failed, code=10
0000079251 [system] INFO: Cloud: disconnecting
0000080781 [system] INFO: Cloud: disconnected
0000080781 [system] INFO: Cloud: connecting
0000080782 [system] WARN: Public Server Address was blank, restoring.
0000080783 [system] INFO: Read Server Address = type:1,domain:$id.udp.particle.io
0000083176 [system] INFO: Resolved host 1e0034001847373130353639.udp.particle.io to 54.157.249.252
0000083196 [system] INFO: Cloud socket connected
0000083197 [system] INFO: Starting handshake: presense_announce=0
0000083197 [comm.protocol.handshake] INFO: Establish secure connection
0000083206 [comm.dtls] INFO: (CMPL,RENEG,NO_SESS,ERR) restoreStatus=2
0000088791 [comm.protocol.handshake] INFO: Sending HELLO message

It will loop like this over and over.

Have talked with the support they think it is a corrupted key.

There solutions is as follows:

It is possible that you have corrupted device keys. Since it's easy to fix them, it's a good thing to start with.

Put the Electron in DFU mode by holding down both the RESET and MODE buttons, releasing RESET and continuing to hold down MODE until it blinks yellow and issue the commands below, in order.

particle keys server
particle keys doctor 1e0034001847373130353639
If you get this error under Windows:

'openssl' is not recognized as an internal or external command, operable program or batch file.
and you have used the CLI installer as described above, it may work if you do:

cd c:\OpenSSL-Win32\bin
particle keys doctor 1e0034001847373130353639
There are additional tips for a missing openssl error on this page, including tips for Mac OS X and Linux.

https://docs.particle.io/reference/device-os/firmware/argon/#system-enableupdates-

Need to fix the pressure to depth conversion
http://docs.bluerobotics.com/calc/pressure-depth/
https://www.grc.nasa.gov/www/k-12/WindTunnel/Activities/fluid_pressure.html