neulab/tldr huggingface dataset:
--bandwidth=<x> or -B <x> Set desired outbound bandwidth to <x>, default=256000.  The value is in bits per second by default. If you append "K" to the value, then the units are kilobits per sec; and if you append "M" to the value, the units are megabits per second.  The "K" and "M" suffixes represent the decimal, not binary, multiples. So 64K is 64000, not 65536.  You cannot specify both --interval and --bandwidth because they are just different ways to change the same underlying parameter.
--backoff=<f> or -b <f> Set timeout backoff factor to <f>, default=1.50.  The per-host timeout is multiplied by this factor after each timeout. So, if the number of retries is 3, the initial per-host timeout is 500ms and the backoff factor is 1.5, then the first timeout will be 500ms, the second 750ms and the third 1125ms.
--verbose or -v Display verbose progress messages.  Use more than once for greater effect:
1 - Display the network address and mask used when the --localnet option is specified, display any nonzero packet padding, display packets received from unknown hosts, and show when each pass through the list completes.
2 - Show each packet sent and received, when entries are removed from the list, the pcap filter string, and counts of MAC/Vendor mapping entries.
3 - Display the host list before scanning starts.
--version or -V Display program version and exit.
--random or -R Randomise the host list.  This option randomises the order of the hosts in the host list, so the ARP packets are sent to the hosts in a random order. It uses the Knuth shuffle algorithm.
--randomseed=<i> Use <i> to seed the pseudo random number generator.  This option seeds the PRNG with the specified number, which can be useful if you want to ensure that the random host list is reproducable. By default, the PRNG is seeded with an unpredictable value. This option is only effective in conjunction with the --random (-R) option.
--numeric or -N IP addresses only, no hostnames.  With this option, all hosts must be specified as IP addresses. Hostnames are not permitted. No DNS lookups will be performed.
--snap=<i> or -n <i> Set the pcap snap length to <i>. Default=64.  This specifies the frame capture length. This length includes the data-link header. The default is normally sufficient.
--interface=
 or -I 
 Use network interface 
.  If this option is not specified, arp- scan will search the system interface list for the lowest numbered, configured up interface (excluding loopback).  The interface specified must support ARP.
--quiet or -q Only display minimal output. No protocol decoding.  If this option is specified, then only the IP address and MAC address are displayed for each responding host.  No protocol decoding is performed and the OUI mapping files are not used.
--plain or -x Display plain output showing only responding hosts.  This option supresses the printing of the header and footer text, and only displays one line for each responding host. Useful if the output will be parsed by a script.
--ignoredups or -g Don't display duplicate packets.  By default, duplicate packets are displayed and are flagged with "(DUP: n)".
--ouifile=
 or -O 
 Use IEEE Ethernet OUI to vendor mapping file 
.  If this option is not specified, the default filename is ieee-oui.txt in the current directory. If that is not found, then the file /usr/local/share/arp-scan/ieee-oui.txt is used.
--iabfile=
 or -O 
 Use IEEE Ethernet IAB to vendor mapping file 
.  If this option is not specified, the default filename is ieee-iab.txt in the current directory. If that is not found, then the file /usr/local/share/arp-scan/ieee-iab.txt is used.
--macfile=
 or -O 
 Use custom Ethernet MAC to vendor mapping file 
.  If this option is not specified, the default filename is mac-vendor.txt in the current directory. If that is not found, then the file /usr/local/share/arp-scan/mac-vendor.txt is used.
--srcaddr=<m> or -S <m> Set the source Ethernet MAC address to <m>.  This sets the 48-bit hardware address in the Ethernet frame header for outgoing ARP packets. It does not change the hardware address in the ARP packet, see --arpsha for details on how to change that address. The default is the Ethernet address of the outgoing interface.
--destaddr=<m> or -T <m> Send the packets to Ethernet MAC address <m> This sets the 48-bit destination address in the Ethernet frame header.  The default is the broadcast address ff:ff:ff:ff:ff:ff.  Most operating systems will also respond if the ARP request is sent to their MAC address, or to a multicast address that they are listening on.
--arpsha=<m> or -u <m> Use <m> as the ARP source Ethernet address This sets the 48-bit ar$sha field in the ARP packet It does not change the hardware address in the frame header, see --srcaddr for details on how to change that address. The default is the Ethernet address of the outgoing interface.
--arptha=<m> or -w <m> Use <m> as the ARP target Ethernet address This sets the 48-bit ar$tha field in the ARP packet The default is zero, because this field is not used for ARP request packets.
--prototype=<i> or -y <i> Set the Ethernet protocol type to <i>, default=0x0806.  This sets the 16-bit protocol type field in the Ethernet frame header. Setting this to a non-default value will result in the packet being ignored by the target, or sent to the wrong protocol stack.
--arphrd=<i> or -H <i> Use <i> for the ARP hardware type, default=1.  This sets the 16-bit ar$hrd field in the ARP packet.  The normal value is 1 (ARPHRD_ETHER). Most, but not all, operating systems will also respond to 6 (ARPHRD_IEEE802). A few systems respond to any value.
--arppro=<i> or -p <i> Use <i> for the ARP protocol type, default=0x0800.  This sets the 16-bit ar$pro field in the ARP packet.  Most operating systems only respond to 0x0800 (IPv4) but some will respond to other values as well.
--arphln=<i> or -a <i> Set the hardware address length to <i>, default=6.  This sets the 8-bit ar$hln field in the ARP packet.  It sets the claimed length of the hardware address in the ARP packet. Setting it to any value other than the default will make the packet non RFC compliant. Some operating systems may still respond to it though.  Note that the actual lengths of the ar$sha and ar$tha fields in the ARP packet are not changed by this option; it only changes the ar$hln field.
--arppln=<i> or -P <i> Set the protocol address length to <i>, default=4.  This sets the 8-bit ar$pln field in the ARP packet.  It sets the claimed length of the protocol address in the ARP packet. Setting it to any value other than the default will make the packet non RFC compliant. Some operating systems may still respond to it though.  Note that the actual lengths of the ar$spa and ar$tpa fields in the ARP packet are not changed by this option; it only changes the ar$pln field.
--arpop=<i> or -o <i> Use <i> for the ARP operation, default=1.  This sets the 16-bit ar$op field in the ARP packet.  Most operating systems will only respond to the value 1 (ARPOP_REQUEST). However, some systems will respond to other values as well.
--arpspa=<a> or -s <a> Use <a> as the source IP address.  The address should be specified in dotted quad format; or the literal string "dest", which sets the source address to be the same as the target host address. This sets the 32-bit ar$spa field in the ARP packet.  Some operating systems check this, and will only respond if the source address is within the network of the receiving interface. Others don't care, and will respond to any source address.  By default, the outgoing interface address is used.
WARNING: Setting ar$spa to the destination IP address can disrupt some operating systems, as they assume there is an IP address clash if they receive an ARP request for their own address.
--padding=<h> or -A <h> Specify padding after packet data.  Set the padding data to hex value <h>. This data is appended to the end of the ARP packet, after the data.  Most, if not all, operating systems will ignore any padding. The default is no padding, although the Ethernet driver on the sending system may pad the packet to the minimum Ethernet frame length.
--llc or -L Use RFC 1042 LLC framing with SNAP.  This option causes the outgoing ARP packets to use IEEE 802.2 framing with a SNAP header as described in RFC 1042. The default is to use Ethernet-II framing.  arp-scan will decode and display received ARP packets in either Ethernet-II or IEEE 802.2 formats irrespective of this option.
--vlan=<i> or -Q <i> Use 802.1Q tagging with VLAN id <i>.  This option causes the outgoing ARP packets to use 802.1Q VLAN tagging with a VLAN ID of <i>, which should be in the range 0 to 4095 inclusive.  arp-scan will always decode and display received ARP packets in 802.1Q format irrespective of this option.
--pcapsavefile=
 or -W 
 Write received packets to pcap savefile 
.  This option causes received ARP responses to be written to the specified pcap savefile as well as being decoded and displayed. This savefile can be analysed with programs that understand the pcap file format, such as "tcpdump" and "wireshark".
--rtt or -D Display the packet round-trip time.
/usr/local/share/arp-scan/ieee-oui.txt List of IEEE OUI (Organisationally Unique Identifier) to vendor mappings.
/usr/local/share/arp-scan/ieee-iab.txt List of IEEE IAB (Individual Address Block) to vendor mappings.
/usr/local/share/arp-scan/mac-vendor.txt List of other Ethernet MAC to vendor mappings.
The example below shows arp-scan being used to scan the network 192.168.0.0/24 using the network interface eth0.
$ arp-scan --interface=eth0 192.168.0.0/24 Interface: eth0, datalink type: EN10MB (Ethernet) Starting arp-scan 1.4 with 256 hosts (http://www.nta-monitor.com/tools-resources/security-tools/arp-scan/) 192.168.0.1     00:c0:9f:09:b8:db       QUANTA COMPUTER, INC. 192.168.0.3     00:02:b3:bb:66:98       Intel Corporation 192.168.0.5     00:02:a5:90:c3:e6       Compaq Computer Corporation 192.168.0.6     00:c0:9f:0b:91:d1       QUANTA COMPUTER, INC. 192.168.0.12    00:02:b3:46:0d:4c       Intel Corporation 192.168.0.13    00:02:a5:de:c2:17       Compaq Computer Corporation 192.168.0.87    00:0b:db:b2:fa:60       Dell ESG PCBA Test 192.168.0.90    00:02:b3:06:d7:9b       Intel Corporation 192.168.0.105   00:13:72:09:ad:76       Dell Inc. 192.168.0.153   00:10:db:26:4d:52       Juniper Networks, Inc. 192.168.0.191   00:01:e6:57:8b:68       Hewlett-Packard Company 192.168.0.251   00:04:27:6a:5d:a1       Cisco Systems, Inc. 192.168.0.196   00:30:c1:5e:58:7d       HEWLETT-PACKARD
13 packets received by filter, 0 packets dropped by kernel Ending arp-scan: 256 hosts scanned in 3.386 seconds (75.61 hosts/sec).  13 responded
This next example shows arp-scan being used to scan the local network after configuring the network interface with DHCP using pump.
# pump # ifconfig eth0 eth0      Link encap:Ethernet  HWaddr 00:D0:B7:0B:DD:C7 inet addr:10.0.84.178  Bcast:10.0.84.183  Mask:255.255.255.248 UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1 RX packets:46335 errors:0 dropped:0 overruns:0 frame:0 TX packets:1542776 errors:0 dropped:0 overruns:0 carrier:0 collisions:1644 txqueuelen:1000 RX bytes:6184146 (5.8 MiB)  TX bytes:348887835 (332.7 MiB) # arp-scan --localnet Interface: eth0, datalink type: EN10MB (Ethernet) Starting arp-scan 1.4 with 8 hosts (http://www.nta-monitor.com/tools-resources/security-tools/arp-scan/) 10.0.84.179     00:02:b3:63:c7:57       Intel Corporation 10.0.84.177     00:d0:41:08:be:e8       AMIGO TECHNOLOGY CO., LTD. 10.0.84.180     00:02:b3:bd:82:9b       Intel Corporation 10.0.84.181     00:02:b3:1f:73:da       Intel Corporation
4 packets received by filter, 0 packets dropped by kernel Ending arp-scan 1.4: 8 hosts scanned in 0.820 seconds (9.76 hosts/sec).  4 responded
Roy Hills <Roy.Hills@nta-monitor.com>
get-oui(1)
get-iab(1)
arp-fingerprint(1)
RFC 826 - An Ethernet Address Resolution Protocol
http://www.nta-monitor.com/wiki/ The arp-scan wiki page.
https://github.com/royhills/arp-scan The arp-scan homepage.
NOTI(1)                            Noti Manual                           NOTI(1)
noti - monitor a process and trigger a notification
noti [flags] [utility [args...]]
Never sit and wait for some long-running process to finish.  Noti can alert you when it’s done.  You can receive messages on your computer or phone.
-t <string>, --title <string> Set notification title.  Default is utility name.
-m <string>, --message <string> Set notification message.  Default is “Done!”.  Read from stdin with “-”.
-b, --banner Trigger a banner notification.  This is enabled by default.  To disable this service, set this flag to false.  This will be either nsuser, freedesktop, or notifyicon notification, depending on the OS.
-s, --speech Trigger a speech notification.  This will be either say, espeak, or speechsynthesizer notification, depending on the OS.
-c, --bearychat Trigger a BearyChat notification.  This requires bearychat.incomingHookURI to be set.
–keybase Trigger a Keybase notification.  This requires keybase.conversation to be set.
-p, --pushbullet Trigger a Pushbullet notification.  This requires pushbullet.accessToken to be set.
-o, --pushover Trigger a Pushover notification.  This requires pushover.apiToken and pushover.userKey to be set.
-u, --pushsafer Trigger a Pushsafer notification.  This requires pushsafer.key to be set.
-l, --simplepush Trigger a Simplepush notification.  This requires simplepush.key to be set.
-k, --slack Trigger a Slack notification.  This requires slack.appurl (for Slack apps) or slack.token and slack.channel (for legacy tokens) to be set.
-w , --pwatch Monitor a process by PID and trigger a notification when the pid disappears.
-f, --file Path to noti.yaml configuration file.
--verbose Enable verbose mode.
-v, --version Print noti version and exit.
-h, --help Print noti help and exit.
• NOTI_DEFAULT
• NOTI_NSUSER_SOUNDNAME
• NOTI_NSUSER_SOUNDNAMEFAIL
• NOTI_SAY_VOICE
• NOTI_ESPEAK_VOICENAME
• NOTI_SPEECHSYNTHESIZER_VOICE
• NOTI_BEARYCHAT_INCOMINGHOOKURI
• NOTI_KEYBASE_CONVERSATION
• NOTI_KEYBASE_CHANNEL
• NOTI_KEYBASE_PUBLIC
• NOTI_KEYBASE_EXPLODINGLIFETIME
• NOTI_PUSHBULLET_ACCESSTOKEN
• NOTI_PUSHBULLET_DEVICEIDEN
• NOTI_PUSHOVER_APITOKEN
• NOTI_PUSHOVER_USERKEY
• NOTI_PUSHSAFER_KEY
• NOTI_SIMPLEPUSH_KEY
• NOTI_SIMPLEPUSH_EVENT
• NOTI_SLACK_TOKEN
• NOTI_SLACK_CHANNEL
• NOTI_SLACK_USERNAME
If not explicitly set with --file, then noti will check the following paths, in the following order.
• ./.noti.yaml
• $XDG_CONFIG_HOME/noti/noti.yaml
Display a notification when tar finishes compressing files.
noti tar -cjf music.tar.bz2 Music/
Add noti after a command, in case you forgot at the beginning.
clang foo.c -Wall -lm -L/usr/X11R6/lib -lX11 -o bizz; noti
If you already started a command, but forgot to use noti, then you can do this to get notified when that process’ PID disappears.
noti --pwatch $(pgrep docker-machine)
Receive your message from stdin with -.
rsync -az --stats ~/  server:/backups/homedir | noti -t "backup stats" -m -
Report bugs on GitHub at https://github.com/variadico/noti/issues.
noti.yaml(5)
Jaime Piña.
PLATFORMIO(1)                      PlatformIO                      PLATFORMIO(1)
platformio - PlatformIO Documentation
A place where Developers and Teams have true Freedom! No more hardware or software lock-ins!
• Open source, maximum permissive Apache 2.0 license
• Cross-platform IDE and Unified Debugger
• Static Code Analyzer and Remote Unit Testing
• Multi-platform and Multi-architecture Build System
• Firmware File Explorer and Memory Inspection.
Social: Twitter | LinkedIn | Facebook | Bintray | Community
What is PlatformIO? A place where Developers and Teams have true Freedom! No more hardware or software lock-ins!
Contents • Awards
• Philosophy
• Technologies
• Problematic
• How does it work?
PlatformIO is a cross-platform, cross-architecture, multiple framework, professional tool for embedded systems engineers and for software developers who write applications for embedded products.
Awards PlatformIO was nominated for the year's best Software and Tools in the 2015/16 IoT Awards.
A native PlatformIO IDE extension for Microsoft ide_vscode editor is the most rated/reviewed extension with over 800 five-star reviews in the whole Microsoft Marketplace. It also was installed by over 750,000 unique developers around the world.
Philosophy PlatformIO's unique philosophy in the embedded market provides developers with a modern integrated development environment (ide) that works cross-platform, supports many different software development kits (SDKs) or frameworks, and includes sophisticated debugging (piodebug), unit testing (unit_testing), automated code analysis (piocheck), and remote management (pioremote).  It is architected to maximize flexibility and choice by developers, who can use either graphical or command line editors (piocore), or both.
PlatformIO is a must-have tool for professional embedded systems engineers who develop solutions on more than one specific platform. In addition, by having a decentralized architecture, PlatformIO offers both new and existing developers a quick integration path for developing commercial-ready products, and reduces the overall time-to-market.
And it runs on any one of your favorite modern operating systems (macOS, MS Windows, Linux, FreeBSD).
Technologies PlatformIO applies the latest scalable and flexible software technology to the embedded market – an area traditionally served by complex software tools that experienced hardware engineers have learned over time (often painfully so). Instead, with PlatformIO, users can be hobbyists or professionals. They can import the classic Arduino "Blink" sketch or develop  a sophisticated low-level embedded C program for a commercial product. Example code for any supported framework can be compiled and uploaded to a target platform in minutes.
The build system structure automatically tags software dependencies and applies them using a modular hierarchy that takes away the usual complexity and pain. Developers no longer have to manually find and assemble an environment of toolchains, compilers, and library dependencies to develop applications for a specific target. With PlatformIO, clicking the compile button will bring in all necessary dependencies automatically. It's analogous to if you were a furniture designer, and your CAD program had a "build" button that caused a robot to fetch all the necessary pieces and fasteners and correctly assemble them.
piocore is a unique, developed-from-scratch build system that removes the usual pain of software integration, packaging, and library dependencies that developers encounter when they move beyond the bounds of a specific SDK or example embedded application. It can be used with a variety of code development environments and allows easy integration with numerous cloud platforms and web services feeds. The user experiences no barriers to getting started quickly: no license fees, no legal contracts.  The user maintains full flexibility of the build environment because the tools are open source and permissively licensed (no permission needed to modify them, and no requirement to share changes.)
Problematic • The main problem which repulses people from the embedded world is a complicated process to setup development software for a specific MCU/board: toolchains, proprietary vendor's IDE (which sometimes isn't free) and what is more, to get a computer with OS where that software is supported.
• Multiple hardware platforms (MCUs, boards) require different toolchains, IDEs, etc, and, respectively, spending time on learning new development environments.
• Finding proper libraries and code samples showing how to use popular sensors, actuators, etc.
• Sharing embedded projects between team members, regardless of an operating system they prefer to work with.
How does it work? Without going too deep into PlatformIO implementation details, work cycle of the project developed using PlatformIO is as follows:
• Users choose board(s) interested in projectconf
• Based on this list of boards, PlatformIO downloads required toolchains and installs them automatically.
• Users develop code and PlatformIO makes sure that it is compiled, prepared and uploaded to all the boards of interest.
PlatformIO IDE PlatformIO IDE is the next-generation integrated development environment for IoT.
• Cross-platform build system without external dependencies to the OS software:
• 800+ boards
• 35+ platforms
• 20+ frameworks
• piodebug
• pioremote
• unit_testing
• C/C++ Intelligent Code Completion
• C/C++ Smart Code Linter for rapid professional development
• Library Manager for the hundreds popular libraries
• Multi-projects workflow with multiple panes
• Themes support with dark and light colors
• Serial Port Monitor
• Built-in Terminal with piocore and CLI tool (pio, platformio)
• Built-in piohome.
We provide official packages (plugins, extensions) for the most popular IDEs and text editors.
NOTE: In our experience, ide_vscode offers better system performance, and users have found it easier to get started
PlatformIO for VSCode Visual Studio Code is a lightweight but powerful source code editor which runs on your desktop and is available for Windows, macOS and Linux. It comes with built-in support for JavaScript, TypeScript and Node.js and has a rich ecosystem of extensions for other languages (such as C++, C#, Python, PHP, Go) and runtimes (such as .NET and Unity).
Install PlatformIO for VSCode / Get started .SS PlatformIO for CLion
The CLion is a cross-platform C/C++ IDE for Linux, OS X, and Windows. CLion includes such features as a smart editor, code generation, code quality assurance, automated refactorings, on-the-fly code analysis, project manager, integrated version control systems and debugger.
Install PlatformIO for CLion / Get started .SS PlatformIO Core (CLI)
PlatformIO Core (CLI tool) is a heart of whole PlatformIO ecosystem and consists of
• Multi-platform Build System
• Development platform and package managers
• librarymanager
• ldf
• Integration components (ide and ci).
PlatformIO Core is written in Python and works on Windows, macOS, Linux, FreeBSD and ARM-based credit-card sized computers (Raspberry Pi, BeagleBone, CubieBoard, Samsung ARTIK, etc.).
PlatformIO Core provides a rich and documented Command Line Interface (CLI).  The other PlatformIO-based software and IDEs are based on PlatformIO Core CLI, such as pioide. In other words, they wrap PlatformIO Core with own GUI.
NOTE: Please note that you do not need to install PlatformIO Core if you are going to use pioide. PlatformIO Core is built into PlatformIO IDE and you will be able to use it within PlatformIO IDE Terminal.
If you need PlatformIO Core commands outside PlatformIO IDE, please piocore_install_shell_commands.
Demo Contents • "Blink Project"
• Used in demo
• Platform Manager
• Library Manager
• Over-the-Air update for ESP8266
Blink Project [image]
Used in demo 1. Source code of Wiring Blink Example
2. cmd_run command
3. platformio run -t upload command.
Platform Manager [image]
Used in demo 1. userguide_platform
2. cmd_platform_list command
3. platformio platform search avr command
4. platformio platform show teensy command
5. cmd_platform_update command.
Library Manager [image]
Used in demo 1. cmd_lib
2. platformio lib search 1-wire command
3. platformio lib install 54 command
4. platformio lib search -f mbed command
5. platformio lib search -k rf command
6. platformio lib search radiohead command
7. platformio lib install 124 --version "1.40" command
8. platformio lib show 124 command
9. cmd_lib_update command.
Over-the-Air update for ESP8266 .SS Used in demo
1. cmd_run command
2. platformio run -t upload command.
Installation NOTE: Please note that you do not need to install piocore if you are going to use pioide. piocore is built into PlatformIO IDE and you will be able to use it within PlatformIO IDE Terminal.
If you need piocore outside PlatformIO IDE, please Install Shell Commands.
• System requirements
• Installation Methods
• Installer Script
• Super-Quick (Mac / Linux)
• Local Download (Mac / Linux / Windows)
• Python Package Manager
• macOS Homebrew
• Virtual Environment
• Prerequisites
• Creating
• Development Version
• Install Shell Commands
• Unix and Unix-like
• Method 1
• Method 2
• Uninstall PIO Core and dependent packages
• Integration with custom applications (extensions, plugins)
• Prerequisite
• Python Interpreter
• Workflow
• Step 1. Where is PlatformIO Core installed?
• Step 2. Install PlatformIO Core
• Troubleshooting
System requirements Operating System Windows, macOS, Linux, FreeBSD, Linux ARMv6+
Python Interpreter Python 3.5+ (Python 2.7 is not recommended, support for it will be removed in the next releases).  See detailed instruction on how to faq_install_python for Windows.
Terminal Application All commands below should be executed in Command-line application (Terminal). For macOS and Linux OS - Terminal application, for Windows OS – cmd.exe application.
Access to Serial Ports (USB/UART) Windows Users: Please check that you have correctly installed USB driver from board manufacturer
Linux Users:
• Please install faq_udev_rules
• Raspberry Pi users, please read this article Enable serial port on Raspberry Pi.
Installation Methods Please choose ONE of the following methods:
Installer Script WARNING: PlatformIO DOES NOT require administrative/sudo permissions. Please install using default user account WITHOUT EXTRA PERMISSIONS.
Super-Quick (Mac / Linux) To install or upgrade PlatformIO Core paste that at a Terminal prompt:
python3 -c "$(curl -fsSL https://raw.githubusercontent.com/platformio/platformio/develop/scripts/get-platformio.py)"
# or using `curl`
curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py -o get-platformio.py python3 get-platformio.py
# or using `wget`
wget https://raw.githubusercontent.com/platformio/platformio-core-installer/master/get-platformio.py -O get-platformio.py python3 get-platformio.py
Local Download (Mac / Linux / Windows) To install or upgrade PlatformIO Core, download (save as...) get-platformio.py script. Then run the following:
# change directory to folder where is located downloaded "get-platformio.py" cd /path/to/dir/where/is/located/get-platformio.py/script
# run it python get-platformio.py
On Windows OS it may look like:
# change directory to folder where is located downloaded "get-platformio.py" cd C:\path\to\dir\where\is\located\script\get-platformio.py
# run it python.exe get-platformio.py
NOTE: If you need to have access to platformio or platformio.exe commands from other applications or terminal in your OS, please Install Shell Commands.
Python Package Manager WARNING: We recommend using this method ONLY FOR ci use cases or where your have full permissions to install PlatformIO Core into the global scope of your OS.
For personal using, and avoiding maintenance and upgrade issues, we HIGHLY RECOMMEND using Installer Script which installs PlatformIO Core into an isolated virtual environment and does not affect your OS.
The latest stable version of PlatformIO Core may be installed or upgraded via Python Package Manager (pip) as follows:
pip install -U platformio
macOS Homebrew The latest stable version of PlatformIO may be installed or upgraded via macOS Homebrew Packages Manager (brew) as follows:
brew install platformio
Virtual Environment PlatformIO Core may be installed into isolated Python environment. This method is very good if you don't want to install PlatformIO Core Python's dependencies (packages) into your global system scope. pioide uses this method to install PlatformIO Core.
Default and recommended environment folder is "projectconf_pio_core_dir/penv".  You can print environment folder path using the next command in your system terminal:
python -c "import os; print(os.path.join(os.getenv('PLATFORMIO_CORE_DIR', os.path.join(os.path.expanduser('~'), '.platformio')), 'penv'))"
######################## Examples # Windows # C:\Users\UserName\.platformio\penv
# Linux # ~/.platformio/penv # /home/username/.platformio/penv
# macOS # ~/.platformio/penv # /Users/username/.platformio/penv
Prerequisites 1. Please remove existing PlatformIO Core environment folder if exists. See above command how to get path to environment folder.
2. Please check that you have a valid Python interpreter running a next command in system terminal. Python 2.7.9+ or Python 3.5+ is recommended.
python --version
# or, for Unix (Linux, Mac), you can use `python2` or `python3` aliases python2 --version python3 --version
WARNING: Windows Users: If you already tried to install pioide and did not get success, please open system's Control Panel > Installed Programs, and check if PlatformIO IDE tried to install an own isolated Python 2.7 version. Please uninstall it. Also is good to uninstall all Python interpreters from a system and install manually the latest Python using faq_install_python guide.
3. Make sure virtualenv --help command exists in a system, otherwise, please install it manually using pip install virtualenv or pip2 install virtualenv command.
If pip (Python Package Manager) does not exists, you have to install it manually. See https://pip.pypa.io/en/stable/installing/
Creating 1. Create a folder which contains all the necessary executables to use the packages that PIO Core would need using virtualenv command:
virtualenv /path/to/.platformio/penv
# If you want to use a custom Python interpreter virtualenv --python=/path/to/custom/python /path/to/.platformio/penv
# EXAMPLES # Windows virtualenv C:\Users\UserName\.platformio\penv virtualenv --python=C:\Python27\python.exe  C:\Users\UserName\.platformio\penv
# Unix (Linux, Mac) virtualenv ~/.platformio/penv virtualenv -p python3 ~/.platformio/penv
2. Activate virtual environment
# Windows C:\Users\UserName\.platformio\penv\Scripts\activate
# Unix (Linux, Mac) source /path/to/.platformio/penv/bin/activate # or . /path/to/.platformio/penv/bin/activate
3. Install PIO Core into virtual environment
If you plan to use PIO Core commands outside virtual environment, please Install Shell Commands.
Development Version WARNING: If you use pioide, please enable development version:
• ide_atom: "Menu PlatformIO: Settings > PlatformIO IDE > Use development version of PlatformIO Core"
• ide_vscode: Set platformio-ide.useDevelopmentPIOCore to true in ide_vscode_settings.
Install the latest PlatformIO from the develop branch:
# uninstall existing version pip uninstall platformio
# install the latest development version of PlatformIO pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
If you want to be up-to-date with the latest develop version of PlatformIO, then you need to re-install PlatformIO each time you see a new commits in PlatformIO GitHub repository (branch: develop) like so:
pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
pio upgrade --dev
To revert to the latest stable version:
pip uninstall platformio pip install -U platformio
Install Shell Commands piocore consists of 2 standalone tools in a system:
• platformio or pio (short alias) - piocore_userguide
• piodebuggdb - alias of cmd_debug
If you have pioide already installed, you do not need to install piocore separately. Just link these tools with your shell:
Unix and Unix-like In Unix and Unix-like systems, there are multiple ways to achieve this.
Method 1 You can export PlatformIO executables' directory to the PATH environmental variable. This method will allow you to execute platformio commands from any terminal emulator as long as you're logged in as the user PlatformIO is installed and configured for.
If you use Bash as your default shell, you can do it by editing either ~/.profile or ~/.bash_profile and adding the following line:
export PATH=$PATH:~/.platformio/penv/bin
If you use Zsh, you can either edit ~/.zprofile and add the code above, or for supporting both, Bash and Zsh, you can first edit ~/.profile and add the code above, then edit ~/.zprofile and add the following line:
emulate sh -c '. ~/.profile'
After everything's done, just restart your session (log out and log back in) and you're good to go.
If you don't know the difference between the two, check out this page.
Method 2 You can create system-wide symlinks. This method is not recommended if you have multiple users on your computer because the symlinks will be broken for other users and they will get errors while executing PlatformIO commands. If that's not a problem, open your system terminal app and paste these commands (MAY require administrator access sudo):
ln -s ~/.platformio/penv/bin/platformio /usr/local/bin/platformio ln -s ~/.platformio/penv/bin/pio /usr/local/bin/pio ln -s ~/.platformio/penv/bin/piodebuggdb /usr/local/bin/piodebuggdb
After that, you should be able to run PlatformIO from terminal. No restart is required.
Windows Please read one of these instructions How do I set or change the PATH system variable?
You need to edit system environment variable called Path and append C:\Users\UserName\.platformio\penv\Scripts; path in the beginning of a list (please replace UserName with your account name).
Uninstall PIO Core and dependent packages • Uninstall PIO Core tool
# uninstall standalone PIO Core installed via `pip` pip uninstall platformio
# uninstall Homebrew's PIO Core (only macOS users if you installed it via Homebrew before) brew uninstall platformio
• Dependent packages, global libraries are installed to projectconf_pio_core_dir folder (in user's HOME directory). Just remove it.
Integration with custom applications (extensions, plugins) We recommend using PlatformIO Core Installer Script when you integrate PlatformIO Core into an application, such as extension or plugin for IDE. Examples that use this installer are:
• platformio-node-helpers, is used by PlatformIO IDE for VSCode and PlatformIO IDE for Atom
Prerequisite Python Interpreter PlatformIO Core Installer Script is written in Python and is compatible with Python 2.7+ and Python 3.5+. We highly recommend using Python 3.
Python is installed by default on the most popular Unix OS (macOS, Linux, FreeBSD).  If there is no Python on a user machine (you can check running python --version), we have 2 options:
1. Ask the user to install Python 3 using our guide faq_install_python
2. You can automatically Download Portable Python 3 and unpack it in a cache folder of your application. Later, you can use unpacked_protable_python_dir/python.exe  for the installer script.
Installer Script There are 2 options on how to work with PlatformIO Core Installer Script:
1. Bundle get-platformio.py file into your application
2. Download get-platformio.py file on demand.
In both cases, you will need to have get-platformio.py script on the end-user machine.  You can copy or download it to a cache/temporary folder.
A list of arguments and options for the installer script is available via
python get-platformio.py --help
Workflow We will describe a simple workflow on how to automatically install piocore for end-user of your application/extension. We assume that get-platformio.py script is already copied/downloaded and exists on the end-user machine. See above how to get it.
Step 1. Where is PlatformIO Core installed? You should check the PlatformIO Core installation state each time when the user starts your application. You need to call the Installer Script with check core arguments:
python get-platformio.py check core
This command returns 0 "exit code" when PlatformIO Core is already installed and is ready for use, otherwise, the non-zero code of subprocess will be returned and you need to install PlatformIO Core (see Step #2 below).
If you need to have full information about PlatformIO Core installation state, please run with --dump-state option and specify a folder or a full path where to save data in JSON format:
get-platformio.py check core --dump-state tmpdir/pioinstaller-state.json
Now, read JSON file and use platformio_exe binary to call PlatforIO Core using CLI (see piocore_userguide). You can also export penv_bin_dir into system environment PATH variable and platformio command will be available without a full path.
Example of pioinstaller-state.json run on macOS:
{ "cache_dir": "/Users/Freedom/.platformio/.cache", "core_dir": "/Users/Freedom/.platformio", "core_version": "4.3.1", "installer_version": "0.2.0", "is_develop_core": false, "penv_bin_dir": "/Users/Freedom/.platformio/penv/bin", "penv_dir": "/Users/Freedom/.platformio/penv", "platformio_exe": "/Users/Freedom/.platformio/penv/bin/platformio", "python_exe": "/Users/Freedom/.platformio/penv/bin/python", "system": "darwin_x86_64" }
Step 2. Install PlatformIO Core To install PlatformIO Core into the virtual environment in an automatic mode, please call installer script without any arguments:
python get-platformio.py
• --verbose, verbose output
• --dev, install the latest development version of PlatformIO Core
• --ignore-python, a path to Python to be ignored (multiple options and unix wildcards are allowed)
More options are available at python get-platformio.py --help.
Installer Script will return exit code 0 on success, otherwise non-zero code and error explanation.
Next time just use again python get-platformio.py check core as described in Step #1 (see above).
Troubleshooting NOTE: Linux OS: Don't forget to install "udev" rules file 99-platformio-udev.rules (an instruction is located in the file).
Windows OS: Please check that you have correctly installed USB driver from board manufacturer
For further details, frequently questions, known issues, please refer to faq.
If you find any issues with PlatformIO Core Installer Script, please report to https://github.com/platformio/platformio-core-installer/issues
Quick Start This tutorial introduces you to the basics of piocore Command Line Interface (CLI) workflow and shows you a creation process of a simple cross-platform “Blink” Project. After finishing you will have a general understanding of how to work with the multiple development platforms and embedded boards.
Setting Up the Project piocore provides special cmd_project_init command for configuring your projects.  It allows one to initialize new empty project or update existing with the new data.
What is more, cmd_project_init can be used for ide. It means that you will be able to import pre-generated PlatformIO project using favorite IDE and extend it with the professional instruments for IoT development.
This tutorial is based on the next popular embedded boards and development platforms using framework_arduino:
┌───────────────────────┬───────────────────────────────┬───────────────────┐ │Platform               │ Board                         │ Framework         │ ├───────────────────────┼───────────────────────────────┼───────────────────┤ │platform_atmelavr      │ board_atmelavr_uno            │ framework_arduino │ ├───────────────────────┼───────────────────────────────┼───────────────────┤ │platform_espressif8266 │ board_espressif8266_nodemcuv2 │ framework_arduino │ ├───────────────────────┼───────────────────────────────┼───────────────────┤ │platform_teensy        │ board_teensy_teensy31         │ framework_arduino │ └───────────────────────┴───────────────────────────────┴───────────────────┘
Board Identifier cmd_project_init command requires to specify board identifier ID. It can be found using boards catalog, Boards Explorer or cmd_boards command. For example, using cmd_boards let's try to find Teensy boards:
> platformio boards teensy
Platform: teensy --------------------------------------------------------------------------- ID                    MCU            Frequency  Flash   RAM    Name --------------------------------------------------------------------------- teensy20              atmega32u4     16MHz     31K    2.5K  Teensy 2.0 teensy30              mk20dx128      48MHz     128K   16K   Teensy 3.0 teensy31              mk20dx256      72MHz     256K   64K   Teensy 3.1 / 3.2 teensylc              mkl26z64       48MHz     62K    8K    Teensy LC teensy20pp            at90usb1286    16MHz     127K   8K    Teensy++ 2.0
According to the table above the ID for board_teensy_teensy31 is teensy31. Also, the ID for board_atmelavr_uno is uno and for board_espressif8266_nodemcuv2 is nodemcuv2.
Initialize Project PlatformIO ecosystem contains big database with pre-configured settings for the most popular embedded boards. It helps you to forget about installing toolchains, writing build scripts or configuring uploading process. Just tell PlatformIO the Board ID and you will receive full working project with pre-installed instruments for the professional development.
1. Create empty folder where you are going to initialize new PlatformIO project. Then open system Terminal and change directory to it:
# create new directory > mkdir path_to_the_new_directory
# go to it > cd path_to_the_new_directory
2. Initialize project for the boards mentioned above (you can specify more than one board at time):
> platformio project init --board uno --board nodemcuv2 --board teensy31
The current working directory *** will be used for the new project. You can specify another project directory via `platformio project init -d %PATH_TO_THE_PROJECT_DIR%` command.
The next files/directories will be created in *** platformio.ini - Project Configuration File. |-> PLEASE EDIT ME <-| src - Put your source files here lib - Put here project specific (private) libraries Do you want to continue? [y/N]: y Project has been successfully initialized! Useful commands: `platformio run` - process/build project from the current directory `platformio run --target upload` or `platformio run -t upload` - upload firmware to embedded board `platformio run --target clean` - clean project (remove compiled files)
Congrats! You have just created the first PlatformIO based Project with the next structure:
• projectconf
• src directory where you should place source code (*.h, *.c, *.cpp, *.S, *.ino, etc.)
• lib directory can be used for the project specific (private) libraries. More details are located in lib/README file.
• Miscellaneous files for VCS and ci support.
NOTE: If you need to add new board to the existing project please use cmd_project_init again.
The result of just generated platformio.ini:
; PlatformIO Project Configuration File ; ;   Build options: build flags, source filter, extra scripting ;   Upload options: custom port, speed and extra flags ;   Library options: dependencies, extra library storages ; ; Please visit documentation for the other options and examples ; https://docs.platformio.org/page/projectconf.html
[env:uno] platform = atmelavr framework = arduino board = uno
[env:nodemcuv2] platform = espressif8266 framework = arduino board = nodemcuv2
[env:teensy31] platform = teensy framework = arduino board = teensy31
Now, we need to create main.cpp file and place it to src folder of our newly created project. The contents of src/main.cpp:
/** * Blink * * Turns on an LED on for one second, * then off for one second, repeatedly. */ #include "Arduino.h"
#ifndef LED_BUILTIN #define LED_BUILTIN 13 #endif
void setup() { // initialize LED digital pin as an output. pinMode(LED_BUILTIN, OUTPUT); }
void loop() { // turn the LED on (HIGH is the voltage level) digitalWrite(LED_BUILTIN, HIGH);
// wait for a second delay(1000);
// turn the LED off by making the voltage LOW digitalWrite(LED_BUILTIN, LOW);
// wait for a second delay(1000); }
The final Project structure:
project_dir ├── lib │   └── README ├── platformio.ini └── src └── main.cpp
Process Project piocore provides special cmd_run command to process project. If you call it without any arguments, PlatformIO Build System will process all project environments (which were created per each board specified above). Here are a few useful commands:
• platformio run. Process (build) all environments specified in projectconf
• platformio run --target upload. Build project and upload firmware to the all devices specified in projectconf
• platformio run --target clean. Clean project (delete compiled objects)
• platformio run -e uno. Process only uno environment
• platformio run -e uno -t upload. Build project only for uno and upload firmware.
Please follow to platformio run --target documentation for the other targets.
Finally, demo which demonstrates building project and uploading firmware to Arduino Uno: [image]
Further Reading • Project examples
• piocore_userguide for piocore commands
CLI Guide Contents • CLI Guide
• Usage
• Options
• Commands
Usage pio [OPTIONS] COMMAND platformio [OPTIONS] COMMAND
# "pio" is the alias of "platformio" command
Options --no-ansi
Do not print ANSI control characters.
See also PLATFORMIO_NO_ANSI and PLATFORMIO_FORCE_ANSI environment variables.
Show the version of PlatformIO
--help, -h
Show help for the available options and commands
$ platformio --help $ platformio COMMAND --help
Commands platformio account CLI helper command for pioaccount.
To print all available commands and options use:
pio account --help platformio account --help platformio account COMMAND --help
platformio account forgot Contents • platformio account forgot
• Description
Usage platformio account forgot [OPTIONS] pio account forgot [OPTIONS]
Description Allows you to reset password for pioaccount using username or email which were specified for registration.
Options --username, -u
Username or email. You can omit this option and enter username or email in Forgot Wizard later.
platformio account login Contents • platformio account login
Usage platformio account login [OPTIONS] pio account login [OPTIONS]
Description Log in to pioaccount. If you are not able to provide authentication credentials manually you can use PLATFORMIO_AUTH_TOKEN. This is very useful for ci systems and pioremote operations.
Username or email. You can omit this option and enter username or email in Login Wizard later.
--password, -p
You can omit this option and enter securely password in Login Wizard later.
platformio account logout Contents • platformio account logout
Usage platformio account logout pio account logout
Description Log out of pioaccount.
platformio account password Contents • platformio account password
Usage platformio account password pio account password
Description Change password for pioaccount.
platformio account register Contents • platformio account register
Usage platformio account register [OPTIONS] pio account register [OPTIONS]
Description Create a new pioaccount.
Options You can omit these options and enter them later in Register Wizard.
--username, -u
A username. You can use it later for cmd_account_login, cmd_account_update, and cmd_account_forgot commands.
The username must contain at least 4 characters including single hyphens, and cannot begin or end with a hyphen.
--email, -e
An email. Please enter existing email, you will receive a confirmation letter.
A password. You will need it for cmd_account_login, cmd_account_password, cmd_account_token, and cmd_account_update commands.
--firstname
A first name.
--lastname
A last name.
platformio account show Contents • platformio account show
Usage platformio account show pio account show
Description Show detailed information about pioaccount:
• Active subscriptions
• Available packages and services
Options --json-output
Return the output in JSON format
platformio account token Contents • platformio account token
Usage platformio account token pio account token
Description Get or regenerate Personal Authentication Token. It is very useful for ci systems, pioremote operations where you are not able to authorize manually.
PlatformIO handles Personal Authentication Token from environment variable PLATFORMIO_AUTH_TOKEN.
Options --regenerate If this option is specified a new authentication token will be generated.
--json-output
platformio account update Contents • platformio account update
Usage platformio account update [OPTIONS] pio account update [OPTIONS]
Description Update pioaccount profile.
Options You can omit these options and enter them later in update Wizard.
A username that must contain at least 4 characters including single hyphens, and cannot begin or end with a hyphen.
--current-password
A current password to confirm this operation.
platformio boards Contents • platformio boards
• Examples
Usage platformio boards [OPTIONS] [FILTER] pio boards [OPTIONS] [FILTER]
Description List pre-configured Embedded Boards
Options --installed
List boards only from the installed platforms
Examples 1. Show all available pre-configured embedded boards
$ platformio boards