What is Reddit's opinion of
PlatformIO?
From 3.5 billion Reddit comments
71 reviews of this app found across Reddit:
Sure, I work in a team project which uses Platformio. Admittedly it does have a VS Code extension, but firstly I couldn't get it to work when I tried, secondly Platformio kinda takes over your whole editor putting buttons everywhere even when you don't have a project open, and thirdly, when I asked the "team leader" guy about using VS Code, he told me to just use Atom. So, yeah, I'm not "forced" to use Atom but it's pretty much required.
Also I originally used Sublime Text 3 but decided to switch to VS Code, I use IntelliJ a lot and I like it's feature where when you type method names or start typing after an object, it will bring up similar sounding methods or the list of methods the object has. VS Code has this but I never found anything for Sublime Text that did, if there was an extension for Sublime that did that I'd probably switch back.
Oh no apologies needed! I drew things exactly the same way until I learned about labels.
I too am primarily a Python programmer (it's what I do for a living), and I can mostly get around in C++. The concept of pointers in C++ just doesn't exist at all in Python (or most other high level languages), so that and header files will probably give you the most trouble at first. I think you'll find the rest of it relatively easy to understand.
You'll probably want to move to either KiCad or FreeCad (I think those are the two main free ones), to do your schematic generation to give your poor hand a break.
https://fritzing.org/ (the one I mentioned in my first comment) is really good for beginners, but it's utterly useless for anything other than a complete beginner...if that makes sense at all.
For the coding side of it, I recommend https://platformio.org/ - It's Visual Studio Code with an Arduino "mod" (for lack of a better word). It's what I use, and really love it.
https://platformio.org/lib/show/10785/esp32-camera
.pixel_format = PIXFORMAT_JPEG, //YUV422,GRAYSCALE,RGB565,JPEG
Set that to anything but PIXFORMAT_JPEG and you've got "raw" data coming out.
To be honest, we don't promote any IDE. It is up to the developer which IDE or OS to use. Our goal is to give developers freedom.
Nevertheless, to reduce "bounce rate" (when people never heard about any IDE or embedded, and do not which to choose), we propose default solution which is very simple and easy for using. This is PlatformIO IDE.
Previously we created an extension for Atom editor and later for VSCode. VSCode provides better support for C/C++ projects.
In any case, you can use your favorite OS and IDE in pair with PlatformIO. See supported list https://docs.platformio.org/en/latest/ide.html
Arduino is so bad.
- The IDE - but that's manageable with https://platformio.org/
- The libraries that all wanna use the same timer and have no resource management.
- The language. Polluting global namespace with global functions instead of using C++ namespaces and can't mock it for unit testing.
Umm.. see date October 18th, 2019.
Honestly this level of development is sad from Arduino. The original IDE is a great learning tool but this "Pro" tool doesn't really do much better they rejigged the boards and Libraries but STILL no debugging tools or code aids like intellisense.
IDE like platformio.org is so significantly better for bigger projects.
Keep in mind that Arduino IDE and API are 2 orthogonal things. You can use another IDE and still code using the Arduino API.
PlatformIO uses VSCode or Atom: https://platformio.org/platformio-ide
I see one in this example:
https://platformio.org/lib/show/5538/WiFiNINA/examples
You could still use the format the data to a buffer and do ONE println(). This will speed it up some cutting out a lot of call overhead done to just one.
I got seriously burned by their PyGate debacle and as a result am very reluctant to purchase from them again.
I ordered in the March directly from their website, and at no point was it made clear that the gateways hadn't even been developed yet.
Over a year of emails and social media posts complaining later, and I finally got my PyGate.
It only talks over UDP to a network server, and the PoE modules that were originally shipped with it had pins soldered incorrectly so it didn't even work on arrival.
The coding environment is, at best, a web-based Arduino IDE and pales into insignificance when compared with a proper development platform such as PlatformIO.org, and as it's all online, you can't update the device code unless your laptop is connected to the internet, which isn't always possible when you're in the middle of a farm!
In short, I'd avoid them due to both the product and the customer experience.
If you want a decent IoT development system, checkout the RAK WisBlock range, it's far easier to use, clicks together, and has an excellent company behind it!
Non platform io c'est là: https://platformio.org/
Reddit a pris le nom pour un lien :')
C'est un système basé sur VScode (gratuit & mutliplateforme) qui gère énormément de cartes de dev, et c'est assez intuitif. Je te conseille d'y jeter un œil !
I know this post is about TinyGo, but I'd like to answer on many comments about coding on embedded platforms. I've been using platform.io and I can only tell good thing about it.
It's an extension for vscode which can bootstrap platforms, frameworks, libraries & upload sketches.
I've been interested in using TinyGO for a while but it lacks support for esp8266 and esp32 boards. Also, since I'm working with LEDs, I'm really not sure the current support LEDs is as mature the library /r/fastled.
Yes you can code it in c++. The arduino language is c++. If you check the arduino librairy, you'll see the main function. You can use any ide or text editor you want. Go checkout https://platformio.org/
It's a bit work to setup, but once you do it's really easy to flash firmware. I use a Windows PC, so your setup me might be different. I originally followed TH3D's instructions (it's very close to their easy board light, same thing just a different processor).
First, you need to install an IDE. TH3D suggested "Atom", but I had issues getting everything working. I found that using Microsoft Visual Studio Code was easier to get going. I suggest installing that.
Next you need to install PlatformIO (PIO) for Visual Studio Code (or Atom). Check out https://platformio.org/install/ide?install=vscode
Then just grab Marlin 2.0, either the vanilla or you can grab the SKR 1.3 version from BigtreeTech. They are pretty much the same thing, only the latter is preconfigured for the SKR.
I used vanilla for mine, because at the time the SKR firmware was a few revs back. I used the SKR version to modify the stock. But once you slog through the firmware a few times it's not too complex (unless you start messing with confirmation_adv.h or, like I did, pins.)
Then you just build the firmware (Ctrl+alt+B in vscode) and grab the firmware.bin file that's generated. Copy to your SD card and pop in you printer and turn it on. The printer will automatically apply the firmware file on boot (and rename it to .CUR).
I find that manufacturer's IDEs and their frameworks are the worst part of developing embedded software and especially when you're trying to spec a part for a project that you don't have any experience with. I typically only seem to find out too far into the development that you can't get enough control over the bit of hardware you want without replacing some part of the manufacturer's framework or middleware which is a nightmare akin to pulling at a thread on a sweater.
We too had a crack at using the CC3200 and dropped it because their stack never allowed you to use it to the potential that the datasheet claimed you could. I've had the same experience with Atmel's ASF; the hardware potential was great but the released framework was missing the components that took advantage of it although to be fair that was at the time of the Microchip takeover and so it could have been due to that.
I'm keen to try out https://platformio.org on a project to avoid having to suffer another Eclipse but it would have to be a personal project before I selected it for work.
After years of using the default Arduino IDE, I now use platformIO (VSCode extension) with Visual Studio Code IDE (so, Arduino / C++). It has intellisense, dark theme etc... much richer IDE.
If you are new to embedded programming, I recommend to take a look at https://PlatformIO.Org. There is support for Sipeed MAIX. See examples https://github.com/sipeed/platform-kendryte210/tree/master/examples
You might want to take a look at https://platformio.org/
It won't work for everything. It is not something supported by all vendors. It won't solve all issues. But when it works, it is a quite nice we to being able to focus more on the coding and less on the tooling.
I'm writing code for an Arduino Nano to control some giant motors.
It's not actually for work (yet), but because I work in IOT, it is likely to become relevant someday.
Background story:
I play with embedded a lot (have even done so professionally off and on). I never considered the Arduino IDE to be "industrial strength", so I avoid using it. I found "PlatformIO" to be a reasonable platform for a professional. It is written in Python and straps together 1000's of open-source projects. You can pick different frameworks, OSes and boards. It was "good enough" but in the back of my mind, it still always felt "fragmented". It presented lots of "choice", but many of those choices were bad. At least they encouraged and supported testing.
But then I met TinyGo.
I realized I really don't need something that tries to strap together many disparate projects. I want an ecosystem that "just works". I want my language and all my libraries to understand concurrency. I want my libraries to easily understand resources and locking (despite the lack of an OS). I want my language to make it obvious when my line of code is a single instruction vs millions of instructions. I want my language to prevent dynamic allocations where possible, and tell me when not. (TinyGo can point out any dynamic allocations as it compiles.)
I'm a veteran, and have used Arduino professionally, but see why it gets a bad rap. That said all embedded gets more abstracted every day with HAL and libraries. Anything with Wifi, BLE, or USB can be pretty complicated. Let's get real. You don't write anything yourself from scratch, you live on the shoulders of giants. Learn to love abstraction. The question is too broad. Find something useful you want to do and try to go do it. Then choose the best tool to do that job.
If you don't need wireless, and want to do something time critical like a motor controller I like the STM32 Cube. Their HAL and device libs are some of the best.
If you need Wifi, the ESP32 is the best entry point for a hobbyist.
Nordic is the king, if BLE is your thing, but not the easiest.
Cypress, Atmel have some great parts, but the tools are in a funk.
Check out https://platformio.org/ which supports many platforms, and can show you examples of doing the same thing in Arduino or Native.
FYI, you can actually mix and match Arduino with native, so it's not really a choice you have to make. Learn to use all the tools in the toolbox.
C++ if you want to look at small devices such as the esp8266 or esp33, python for pretty much anything else.
The beauty of python is that you can run it embedded, on a server, create web services, or even use it in serverless environments.
One of my current projects uses c++ on the sensors and actuators, python for the data crunching and web interface, and mqtt to pass the messages around.
Best thing I can recommend is to get hold of a couple of wemos D1 minis, some temperature sensors and a few servos, fire up https://platformio.org/ and one step at a time (read temperature, move servo, use temperature to set servo angle) build a self-contained setup.
Once you've got something simple like that working, branch out into things like LoRaWAN with The Things Network using the ttgo tbeam or similar.
Just be aware that this is quite the rabbit hole and can rapidly become an unhealthy obsession! 😂🙈🙊
I have found your question interesting.
I have also wondered why RTOS SDK is so limited in libraries, unlike the Arduino.
I think that using PlatformIO (in VSC editor) can handle the Arduino libraries in RTOS SDK.
I found this to answer your question, I have not tried this yet.
In general, you're looking for a "protocol" that both the sensor and the MCU support. I2C and SPI are both very popular communication protocols for hobbyist sensors/modules and all ESP SoCs that I am aware of support both.
The DHT11 uses a special protocol that you'd have to write custom code for, but that has already been done for the DHT11 because it is so popular.
So basically, to figure out if component X is compatible with board Y, you need to look at the component's datasheet, figure out what protocol it uses to communicate, then determine if that protocol is supported natively by your board or failing that, if someone has written a library that handles the details for you.
I actually read the same thing few days ago on the platformio.org site. So thank you for mentioning that. But the concept and in fact even the API is the same. Just the underlying storage structure is different from what I gathered. So you can simply tell your code to use LittleFS instead of SPIFFS (including whatever uploads/creates the file system) and it will work. But if you have an existing file system which you don't want to overwrite, then it will cause issues. That last part probably not being an issue for people flashing their own boards, but for devices out in the wild (especially consumer products) over-the-air updates where the file system doesn't change would probably cause some issues.
So yes LittleFS is the preferred going forward, but seems like support (mostly documentation/examples) will take a while to catch up.
For a full list of supported Dev boards, see here. Filter by Espressif 32 platform.
There's also many more dev boards, chips and modules listed here, though they may not necessarily have platformio IDs.
If your board uses the same ESP-WROOM-32 module, then it will probably also work with esp32dev, though as another person pointed out, you can override board settings.
I also vote for PlatformIO. It may have a bit of a learning curve to get going (compared to the Arduino IDE), but it improves efficiency with features such as IntelliSense and real-time error detection. And it allows for setting up more complex projects
It also makes inline debugging possible, should you need that (at some point in future).
See this video of Andreas Spiess on inline debugging the ESP32.
I’m in a very similar position to you: I’m an experienced non-embedded programmer who usually turns to Arduino/teensy for quick, easy embedded projects but wants something more.
I definitely agree with another commenter here that for small-medium projects where performance isn’t vital, the biggest issues with Arduino are the poor IDE and lack of debugging possibilities. Sure, it makes compiling and flashing easy, but at a huge cost. Once you’ve experienced in-circuit debugging, trying to get by spamming Serial.println() feels excruciatingly cludgy.
I’d recommend looking into continuing to use Arduino libraries (at least to begin with) but in a different IDE with better debugging support. Check out https://platformio.org/ or the Visual Studio Code arduino extension
(Disclaimer: I’m actually learning rust for future embedded development, so I haven’t tried these out, but they’re what I’d be looking into if I wanted to continue using C++/Arduino as a jumping-off point. I do personally use VSC with relevant extensions for embedded development and ICD, and like it.)
If you made the same mistake that I did initially, it was not installing Platformio IDE in Visual Studio Code and using that to open up the folder with the Marlin source files.
Since the CR-6 pull request isn't yet merged to the main Marlin repo, I'd start with checking out the community firmware Marlin fork, downloading and installing Visual Studio Code, installing the Platform.io plugin and building the community FW.
That should pretty much Just Work™, and once it does, you can dive into the meat and potatoes of setting up Marlin, which is editing Configuration.h and Configuration_adv.h to suit your tastes and needs.
YES! I actually had a similar issue when I was watching the video and just kinda forgot. I think something similar happened to TT because you only need to install the platformio extension once.
This will help: https://platformio.org/install/ide?install=vscode
Once you install the platform.io IDE stuff in VS Code, You can go to File -> Open Folder and select the "Marlin-bugfix-2.0.x" folder. From there, you will find a platformio.ini and also all of the other configuration files (configuration.h and configuration_adv.h)
Not really; just Google as you go. Here is how to install Platformio (https://platformio.org/install/ide?install=vscode) after you installed VSCode and the important thing to know is the buttons/keys to actually compile and upload are at the bottom on the blue bottom bar. I'm hardly tech savvy and I got it after an hour of ramming my face on the proverbal wall so I believe in you! Lol :p Got real Marlin installed on my CR10S with BL Touch
December 1, 2020, PlatformIO Labs, the corporate sponsor of the beloved PlatformIO.Org next-generation, professional collaborative platform for embedded development, today announces joining the Eclipse Foundation as a contributing member to introduce a tighter integration with the Eclipse ecosystem.
Which is probably why most beginners and hobbyists stick to the (overpriced) Arduino ecosystem. It's not a great IDE but it does work and it gets you up and running quickly and easily just by selecting your board in a GUI.
PlatformIO is changing that, makes it just as simple to get started with STM, PIC, ESP, and even RISC-V. I've recently been playing with the Sipeed Longan Nano, which is a very nice £5 RISC-V board, and vscode + platformio is a nice environment to develop in (although do be warned that Mac support is non-existent at the moment for many RISC-V platforms, I ended up building riscv-gnu-toolchain and riscv-openocd myself and then modifying the platform to use them instead of the official Windows/Linux toolchains. So it's certainly not perfect).
Why not just use a PlatformIO: https://platformio.org/ that also have built-in debugger, linting, support for downloading libraries, and also suppory for many other platforms and environments.
I would recommend taking a look in Platformio (https://platformio.org/platformio-ide), its a arduino compatible framework and available as an extension for vscode and really easy to install (one click install the extension) The best part of it is the management of your dependencies (librarys and manufacturer frameworks for your hardware).
Check out Platform.IO, which is an extension for VsCode and should cover your first two bullet points
“Arduino language” is just a precompiler in front of C - you can code in pure C/C++ if you want and still use the Arduino libs for things like digitalRead and digitalWrite, as well as the existing libs for various modules as they are all just C++ in the end. You can also look at the existing libs to see how they do things as well if you wanted to refactor them for efficiency (some stuff is a bit bloated if you don’t need all the extra edge cases they account for)
I mean these. In the platformio.ini file there's a framework option, which selects which of those you want to use. For the Atmel ATMega328p there's the Arduino and Simba frameworks, but you can also just leave that option out and not have any framework.
>coding user interface
Do you mean the coding experience, the IDE, coding a user interface or what?
If it's the IDE and/or experience, how about you start using PlatformIO on VSCode?
You could go with platform.io, a bunch of the bigger projects that started off on Arduino have ended up migrating from Arduino to platform.io - Marlin used to be Arduino, now they're using platform.io
And it does still support the Arduino framework, if that's needed.
Here's my latest project, BootInfo.
It's a tiny library, available to download as-is or from the PlatformIO library registry, that displays at boot time (or whenever you want) many informations about your ESP, such as its specs, memory chip size, partitions, WiFi informations...
It's compatible with all ESP32/8266.
I'm using the same version of MacOS and I don't recall having that problem (other problems, yes). But it doesn't matter anymore, since I recently switched to Visual Studio Code (VS Code) with the PlatformIO extension configured for the Arduino framework. It's a little confusing getting started, but it's WAY worth it, in terms of improved productivity.
What is your hardware/MCU? Please take a look at https://platformio.org. It has support for over 800 dev-kits, 10 IDEs, including VSCode and official plugin for CLion.
PlatformIO works on Windows, Linux, macOS, and evening card-sized PC, such as RaspberryPi. You can easily migrate between OS and IDE without any changes to project configuration.
PlatformIO is the way to go, It's easy to set up and you can get into your project as quickly.
I use it with Visual Studio Code, And the setup on my Mac was just too easy.
You can follow the official installation guide to get started.
For a better programming experience, I would recommend to use PlatformIOinstead of the original Arduino IDE. It is a Visual Studio Code extension with the target of embedded software development. So it has all the good stuff like code highlighting etc, supports many boards and has a build in library search.
The original Arduino IDE has a very unfriendly user interaction and makes it unnecessary hard for new programmer.
Everything is a trade-off.
- If you are just doing a one-off of a few plants and already have a few PIs laying around, just use them.
- If you are thinking of making lots of these, want each one cheaper, invest the time in microcontrollers.
- If you still like the PI, but want to save a few bucks, you can get the $5/$10 Zero/ZeroW version. But they are hard to get in quantity.
- You can't beat the PI for rapid prototyping, since there is very little to learn if you know Linux and a random programming language. But with new devices, there are many ways to program it (Arduino, Lua, MicroPython), many ways to flash it (Arduino, PlatformIO.org, UF2, etc), and many RTOS choices.
So it depends if you want to make plant stuff (and spend more money), or play with microcontrollers (and save per plant). If start down the first route, you can always come back and make it cheaper.
I enjoy using PlatformIO for anything other than small tests as it has all the nice features of a most IDEs such as tab completion and nice management of multiple files. This one can also be used with a lot of microcontrollers like the Arduino one can.
The main reason its frowned upon is due to its lack of features you see in other IDEs or text editor. When you venture even further out with something like STM32CudeIDE with a ST-Link then you have access to the breakpoints and individual registers that make debugging so much faster.
Comparing the Arduino IDE and other IDE can feel like comparing Notepad to Word, both get the job done but one just gives you more to work with.
Please take a look at https://platformio.org. It supports over 30 different dev-platforms and architectures. You can personally decide which IDE or OS to use for programming AVR, SAM or ST, etc. products. There are other professional features such as 1-click unified debugger, unit testing engine, static code analysis, firmware inspection.
PlatformIO is fully free and open source.
What is your MCU? We work on giving true Freedom to embedded developers and teams at https://platformio.org where they can personally decide which IDE, OS, hardware and software tools to use. Everything is free and open source.
The only problem is limited support for dev-kits and devices. Currently, we support over 750 dev-kits and 30 architectures/dev-platforms.
We also have native/official extension for JetBrains CLion and Microsoft VSCode. However, you can also generate project for other IDEs, including Eclipse.
PlatformIO supports hybrid configuration which works on any machine: macOS, Windows , Linux. Developers in team can use their favorite tools while working on the same project.
We would be thankful for any feedback!
It's an add on for various development environments that makes it easy to manage and flash various microcontrollers. Many people use it with VSCode, which is an awesome code editor.
Look at the example here: https://platformio.org/lib/show/416/TinyGPS
In the example,it feeds a buffer for one second and parses it, then if new data is found it displays updated information.
I don't see any of that in your code.
Instead of starting with Arduino, I would actually recommend PlatformIO which runs on a much better code editor and has tons of support for ESP8266 boards.
I just started using VSCode for Arduino stuff and https://platformio.org/ solved a ton of config stuff for me. Highly recommended to get up and going more quickly. They have a VSCode extension (600k installs).
Try platformio for a development tool chain/environment for ESP8266. You can do it command line or full blown IDE.
https://platformio.org/platforms/espressif8266
https://docs.platformio.org/en/latest/platforms/espressif8266.html
The common way to access files in flash is via SPIFFS. (Yes, you can use Arduino libraries in platformio)
https://github.com/esp8266/Arduino/tree/master/cores/esp8266/spiffs
Please take a look at PlatformIO , it supports over 10 popular IDEs and all famous operating system. You can switch between IDE/OS without any problems. PlatformIO is fully independent from OS and IDE and only provides integration tools/plugins with them. You can even use different combination of IDE/OS with your Team.
I worked with arduino before and I like it. Still, they're both a little to basic and too expensive for what I have in mind.
>It has an audio library which has a lot of basic building blocks which allows you to graphically configure it and use things like filters, oscillators, mixers and more.
That sounds awesome! This is probably what I going to go with, as long as they can also be programmed directly (meaning with 'actual' code and not visual programming). I'd probably even program it directly in C instead of an arduino sketch, just for good practice.
>Another option would be using something like an STM32 perhaps in combination with using mbed ( https://www.mbed.com/en/ ) and platformio ( https://platformio.org/ ).
I'll look into that once I'm at home.
Thank you!
You're mixing up two things, the development environment and the software libraries.
ESP-IDF is a library. It's just a bunch of C-files that help you write programs for the ESP devices. It's the official SDK by the company that creates the ESP and so supports all features that the ESP itself supports (officially at least).
Arduino IDE is a glorified text editor that hasn't improved in a decade and is horrible to work with. Nobody should ever touch it.
There's also the Arduino library, which is a bunch of C/C++-files that help you write programs for a wide variety of microcontrollers, including the ESP devices. Its main goal is to sacrifice versatility for easy of use, so it's very well suited for beginners.
However, the Arduino library for ESP32 is compatible with ESP-IDF. For example, what I've done is use platform.io with Visual Studio Code as the text editor running ESP-IDF with the Arduino library integrated. This is quite easy to accomplish and brings you the best of both worlds: you get a good integrated development solution and the ease of use of the Arduino library. If you need anything specific to the ESP that the Arduino libraries can't do, you can always use ESP-IDF directly.
Arduino IDE works just fine if you're used to that, though no real debugging. I'd recommend VS Code with PlatformIO which is pretty easy to get going with, and has great autocompletion, debugging, etc.
First of all: You shouldn't modify anything in c_cpp_properties.json. This file gets generated by PlatformIO, so as soon as PlatformIO rebuilds the IntelliSense, your changes are gone.
Also, this issue is known. It was discussed here.
As it seems, the Arduino framework does not support the c++ std lib. Because vector is a part of it, it also is not supported.
If you need the Vector lib, then there are some custom made ones by the community like this one.
I think I'll have to do some more research to understand what this actually means to be honest.
ESP-IDF is listed as a "platform": https://platformio.org/platforms/espressif32/installation as well as a "framework": https://platformio.org/frameworks/espidf
Both of those words mean something to me in my line of work, but honestly in this context they don't.
Agree w/ u/zephell
​
Give PIO (w/ vscode, atom, sublime, emacs, micro, ~~vim~~, whatever) a shot, see if that doesn't work better for you. Plus the added benefit of using a proper editor. Arduino IDE gets a little annoying. And those path's don't look right.
​
Personally, I've really fallen in love with vscode, but to each their own (except for vi/vim users; those people are backwoods savages ;)
Also, life is easier using Linux for this kind of development.
If you write to bare metal, you will have to re-implement all the WiFi functions. Don't do that.
You want to use FreeRTOS. It does take time to learn, but you can skip that by downloading other people's projects and building on them. Sure, there are lots of terrible examples (i.e. people putting "sleep()" after every HTTP response), but you can find better examples if you try.
If you are more of a command-line person, you can use PlatformIO instead of the Arduino stuff. This lets you write code that is portable to 100's of boards, and abstracts the management of all these SDKs.
Aha! Lookup PlatformIO, then you can use almost any editor you want to and store things how you want to.
Visual Studio is generally my choice since 199x, so Ill be moving to that this weekend. Possibly VS*C*ode, but most likely VS.
Ok, so that's a limitation of the Keil IDE (Or more specifically the compiler), not the Nordic MCU you were programming for. The fee you mention is not a fee to Nordic, but to ARM (the company, which owns Keil). This license fee will apply when you want to use Keil, no matter which MCU you choose.
If you are looking for an environment that is easy to get going you could take a look at mbed, which is browser-based, or PlatformIO, which is based on VS Code. Both support Nordic chips, but you'll have to check if your particular board is supported.
No, VS Code, it's different to visual studio. If you've used Atom it's similar but way better.
PlatformIO is an extension for it, yes. It's also available for Atom, but I don't recommend Atom.
> I’ve got a beefy machine and have never noticed issues with any IntelliJ software.
I think I experienced them in 2014 desktop with 16GB RAM and an i5-2500? So bit of an old machine, no SSD back then either.
> It doesn’t feel like an IDE to me at all. Maybe I just didn’t configure it properly?
It wasn't ever really one in the past, you got a text editor and would extend it via many packages to tailor it to your dev needs, that was one of the appeals to me, as well as being html/js which let me add my own packages or modify existing ones. I think when I moved to Linux it might not have looked well/integrated at the time due to UI toolkit?(I don't think that's an issue anymore).
I used PlatformIO back in 2016 for embedded dev, it transformed Atom(and later VSCode), which gave me nice IDE like setup for doing embedded dev without having to use a different app(some which were proprietary iirc), so no sacrifice of features or re-learning stuff. There was also some niche packages that were useful for whatever else I was doing at the time, but as they were for improving DX with small open-source projects/libs, their editor support was limited, Atom would benefit in those cases from it's ecosystem and lack of paywall I guess.
Like PlatformIO, there were some similar packages that'd convert Atom into a more featured IDE, Facebook had Nuclide for React dev and there was something like tomahawk as a similar package for Rust dev... problem though was they would conflict with one another and iirc activating one would affect all open Atom windows which wasn't a good experience if you had a need for more than one. In past year or so Atom pushed out the official package for building IDEs off(atom-ide, which should provide a more unified integration layer, I haven't tried out any of it, but maybe if those packages updated, you don't get the same issues.
As a sidenote: I suggest taking a look at https://platformio.org/ It is a lot nicer to work with, and you can use it with your editor of choice, or by "default", code, which is much nicer than the arduino ide.
You can buy Lora boards for quite cheap (~$15). I use the Heltec-LoRa-32. Out of the box, they are just 'plain radios' that go tens of miles. If that's enough, just hook one up to your computer to send/receive messages as USB serial. (I recommend the open source PlatformIO for managing your code.)
Alternately, you can use it with LoRaWAN which gives you encryption, triangulation, power management, multi-tenant, and sometimes country-wide coverage (depending on the network). Setting up a LoRaWAN network is very complex (I would not recommend it), but you can pay to get on existing ones.
Easiest place to start would be with Arduino. Download the Arduino IDE. Blink some LEDs and read some sensors. (Print results to serial console if you lack any output devices at the moment.)
After that, try doing some of the same stuff with AVR Studio using the native AVR "platform" rather than Ardunio.
For ARM the other suggestions are good.
You might eventually want to check out https://platformio.org/ which supports multiple targets, multiple platforms for each target, easy install for new hardware-platform targets.
Probably an attiny85 can do that, but obviously it'll need some work..
https://ernstsite.wordpress.com/page2-2/attiny85-and-rpi/
Edit: Also, I'm not into this stuff, but https://platformio.org/ has been on my "to play with" list for a while. I can be used for programming the atmel microcontrollers iirc.
Yeah if you have multiple boards in the platformio.ini for the project, the build and upload menus will show them as options.
>I was going to git init my whole arduino folder containing all projects. Not good idea?
Well, what if you want to share your project with someone else? Or make it public so that others can fork it and work with your code? I create git repos as I imagine I would like to find someone else's: able to be cloned and built immediately, without too much unnecessary stuff.
>In the lib/readme.txt file there is no mention of global library folder, how to associate it?
It's the --global option as described here:
http://docs.platformio.org/en/latest/userguide/lib/
So for example if I want to install the i2cdevlib-mpu6050 library, I can type this:
pio lib install "I2Cdevlib-MPU6050"
or
pio lib --global install "I2Cdevlib-MPU6050"
I read this here:
https://diyprojects.io/start-platformio-the-alternative-arduino-esp8266-esp32/
>"For example, it is not possible to make more than 50 remote updates (OTAs) per month"
But maybe it is a misunderstanding?
For getting away from the ArduinoIDE, try PlatformIO. It lets you compile/flash/run any board from the command-line. In fact, you can easily support multiple boards at once.
The modules are all 'very similar', so don't worry about which one you want to use right now. When you run into a limitation ("hey, I need more memory"), you can upgrade to a better one. 99% of your code will be the same, maybe a few changes to pinout at best.