PlatormIO: ..Python 2.7 interpreter error

pio lib uninstall xxx would mean “uninstall the library named xxx”.  You’d replace the “xxx” with the name of whatever library you’re trying to uninstall.  All of the documentation and examples use “xxx” meaning “replace this part with your own text”.

I put up screen shots with the locations of buttons to open a new terminal.

Copying only an h file into your directory is *not* the proper way to install a library.  You should list the library in the “lib_deps” section of your platformio.ini and run the command pio lib install which should install the libraries listed in that section and their dependencies or you can install a single library with the command pio lib install xxx replacing xxx with either the name of the library or the location of a git repository.

The most recent version of PlatformIO also has a point-and-click style (gui) library manager available through the platformio home menu.  See this for more information on that:  https://docs.platformio.org/en/latest/librarymanager/

I added screen shots of how you get to the home in Atom and VSCode.

As a beginner, I would suggest you pick either Atom OR VS Code – whichever one feels most intuitive to you – and use that one exclusively rather than attempting to flip back and forth between them.  Both editors will give you exactly the same tools for PlatformIO, but the menus and drop-downs and styling are different.  Rather than try to to remember how each is different, just pick one.

You didn’t post the screenshot of the pio lib install so I’m not sure what’s happening there.

Try installing the libraries one after the other using these commands:

pio lib install EnviroDIY_ModularSensors

pio lib install https://github.com/PaulStroffregen/AltSoftSerial.git

pio lib install https://github.com/SRGDamia1/NeoSWSerial.git

pio lib install https://github.com/EnviroDIY/SoftwareSerial_ExternalInts.git

pio lib install https://github.com/switchdoclabs/SDL_Arduino_SSD1306.git

I’m not sure if you need all of them, but it shouldn’t hurt to have them installed.

The platformio.ini file is just a text file.  If you can open it and view it, it’s not corrupted.

The commands I gave you should accomplish getting the libraries installed.  Sometimes when installing a lot of libraries the installer gets ahead of itself and trips and crashes.  Most of the time, running the command a second time will be successful.  Make sure that all installs are completely finished before you attempt to build anything.

Since you’ve mentioned moving things around in the lib and other folders from what you downloaded, I don’t think it would be a bad idea to delete it and start again if the library install doesn’t fix your issues.

Did you try just running the same command a second time like I’d suggested?  Did it install any libraries?

Could it be DropBox syncing?  If you have that folder set to automatically synchronize with anything, make sure you exclude the entire .pio folder and all of its subfolders from your synchronization.  PlatformIO expects to have full control of that folder and will be very, very unhappy if other processes try to lock onto those files.  Every time you build/compile your program there are a bunch of new files created and others modified or deleted in sub-directories of that .pio file.  Those files are not useful to archive, but are needed to successfully convert your code from what you see into assembly that your board can use.

You have git installed, right?  I don’t think you’d even get this far without it.  I think either VSCode or Atom (both) include it.

Otherwise, try running the same install command a few times.  As long as it gets a little farther each time, it’s fine.  I think this crashing happens when the background processes for the linter and compiler are trying to read your libraries while you’re installing them in the foreground.

Ctrl+S will save the file.  That keyboard shortcut works on almost all Windows programs, including VS Code, Atom, MS Word, Excel, etc.

You can make the normal “file” menu visible in Atom in the settings.  I’ve attached a screenshot.  PlatformIO is just a command line tool and an extension for an editor.  The editing program is either VS Code or Atom and basic functions like saving are part of the editor and not of PlatformIO.  Have you decided to stick with Atom?  I’m only asking so I can give you screenshots of the right editor.

That’s the folder for the library itself.  You want to create your own separate folder for your logger deployment and its code.  Follow the steps from the tutorial, episode 9, in the section “Managing your sketches in your own deployments repo.”  In that, you’re copying the folder for a single example (simple_logging) into your own deployment project.  Within that folder is the platformio.ini needed for that example.

In episode 9, copy and paste from the folder that you already saved on your computer from when you cloned the whole library not from GitHub.

You should generally create a whole new project for each logger/program – just like in the Arduino IDE.  The platformio.ini file must be in the top level directory for the project – not in a sub-directory.  If you really want to have multiple loggers/programs in your project, each program must be in its own sub-folder and you must use the src_dir option within the platformio section of the platformio.ini file to specify which directory you wish to build from.  The structure of the ini file is well documented:  https://docs.platformio.org/en/latest/projectconf/section_platformio.html#src-dir

I was under the impression you already knew there was 2G available before buying the units.  I don’t think it’s worth writing up a separate program just to check signal strength unless you’re planning to make multiple trips to the site, one to check signal and another to actually deploy the Mayfly.  You’ll see within the first few minutes of running your logging program if you have signal based on the blink pattern of the modem and whether data appears online.  If you find out at the last minute that you don’t have signal, just yank the modem off and deploy without it.  Your logger board will be powered up ~5-10s extra every logging cycle trying to communicate with a modem that’s not there, but unless you’re in a really shady spot or not using solar, it’s not worth stressing over.

You need to include the Arduino library – add #include <Arduino.h> to the top of your program.  The Arduino IDE adds that automatically and does some other “massaging” of files when it converts an ino to a real cpp file that gcc then compiles; PlatformIO doesn’t.  Depending on how you’ve structured your program, that may cause a few more snags.  The two things your most likely to hit are:

• pre-processor defines within a file (ie #define) which the Arduino IDE applies as global build flags rather than single-compile-unit defines
  • the defines you have for pin numbers and headers are probably ok
• the basic cpp requirement that a function be declared or defined before it is used, which the Arduino IDE does some squirrlyness to get around.
  • If you have any functions in your program other than setup(){..} and loop(){...} make sure they’re above the setup and loop functions.  You may also have to re-order your functions depending on the order in which you’ve created/used them.

Like most things, PlatformIO has some documentation on this:  https://docs.platformio.org/en/latest/faq.html#convert-arduino-file-to-c-manually

I don’t know what all you’re doing in your program, but I’m it might be easier to start with the ModularSensors examples and use the already existing support for Atlas sensors.  And, of course, documentation for that:  https://github.com/EnviroDIY/ModularSensors/wiki/Atlas-Sensors

If you need the SD library in your program, you need to include it in your platformio.ini file in the lib_dep section.  Add RTCTimer and Sodaq_DS3231 there while you’re at it since it looks like you use them.

Other answers:

• ModularSensors uses I2C, not Serial, for Atlas sensors.  Please read the documentation I linked earlier.  It has links to further Atlas documentation on how to set up I2C.
• A raw RTD like you’re using isn’t directly supported.  I would recommend attaching the RTD to the auxiliary ADC (TI ADS1115 – pins AA0-AA3 on the Mayfly) which is higher resolution anyway, and then using that:  https://github.com/EnviroDIY/ModularSensors/wiki/TI-ADS1115-Voltage
  • To calculate temperature and to correct conductivity for temperature you should use a calculated variable in ModularSensors.  I’m embarrassed that I actually don’t have documentation on that, just examples.
  • There’s a very generic example of a calculated variable in the menu a la carte example:  https://github.com/EnviroDIY/ModularSensors/blob/f607ff9ac5b22c87962802e5e5b348b3612d75a4/examples/menu_a_la_carte/menu_a_la_carte.ino#L1169.
  • There are several calculated variables in the barometric pressure correction examples:  https://github.com/EnviroDIY/ModularSensors/blob/f607ff9ac5b22c87962802e5e5b348b3612d75a4/examples/baro_rho_correction/baro_rho_correction.ino#L175
• Yes, the ModularSensors library should take care of all of the configuration for the GPRSBee
• Yes.  The values should be visible immediately, the plots may take up to an hour to update.

Hi Jim: I haven’t been following this thread but I’m excited that you are pushing through this to get your data streaming to MonitorMyWatershed! I’m glad Sara has been providing help. It occurred to me that you might reach out to Adam Gold (@adamgold) because he was using both Atlas Sci hardware and PlatformIO. He published a blog detailing his project and also maintains his own website that details what he’s designed. Perhaps there are some solutions there?

Thanks Jim!

Scott

It’s very, very intentional that ModularSensors uses that Atlas sensors only in I2C mode and I do not intend to change this.  When using Atlas sensors in UART mode, each sensor must have an individually dedicated UART port.  The Mayfly has exactly two hardware (processor implemented) UART’s – one dedicated to the computer/programming and the other dedicated to modem communication.  It is possible to replicate UART functionality with “bit banging” libraries like AltSoftwareSerial or SoftwareSerial, but both of these have serious limitations.  AltSoftwareSerial has acceptable quality communication but it is strictly limited to being used on pins 5 and 6 – which are spread on two different Grove ports on the Mayfly – and even then, monopolizes both of those pins.  SoftwareSerial has poor communication quality, conflicts with every other library using interrupts including those absolutely required to wake the logger from deep sleep, and besides requires two dedicated pins.  If the Atlas sensors are used as I2C devices, they can be connected to hardware already dedicated only to processor implemented I2C communication.  This gives them the best quality communication, allows up to 126 devices on the same connection, and does not waste other data pins on the Mayfly.  ModularSensors will continue to use I2C to support Atlas sensors.