feature:
- 采用Python编写，
- Pip 包管理
- CMake, the build system that yotta usesa
- compiler, to actually compile the code into working programs
- compiling with different compilers by specifying different targets for the compilation
Note:
If you have a complex python setup on your system, you may want to consider installing yotta in a virtualenv, in order to separate its dependencies from other python programs on your system.
To upgrade an existing installation to a new version, see upgrading (the same for all systems).
If you have a restrictive firewall setup, then for yotta to be fully functional you may also need to ensure that it can access the required domains.
# Installing on Windows
To install yotta on windows you can either use the one shot windows installer or install all the dependencies and yotta manually.
# yotta Windows Installer
- Download the latest yotta windows installer.
- Run the installer.
- Click on
Run Yottashortcut on desktop or in start menu to run session with yotta path temporarily pre-pended to system path.
# Manual Installation
-
Install python. You must install python 2.7.9 or later for yotta to work on windows. Select either the x86-64 installer if you use 64-bit windows, or the x86 installer if you use 32-bit windows.
During installation, be sure to select the "add to path" option. This will let you run python easily from a command prompt.
- Install CMake. yotta uses CMake to generate makefiles that control the build. Select the latest available version, currently 3.2.1 The 32-bit version will work on all versions of windows. Be sure to check the "add cmake to the path for current user" option during installation.
-
Install Ninja, the small and extremely fast build system that yotta uses. Download the release archive from the releases page, and extract it to a directory (for example
C:\ninja). - Add the directory you installed Ninja in to your path.
- Install the arm-none-eabi-gcc cross-compiler in order to build software to run on embedded devices.
- Finally, open cmd.exe and run
pip install -U yottato install yotta itself.
# Cross-compiling from Windows
To use yotta to cross-compile binaries to run on embedded hardware, you need to first install the arm-none-eabi-gcc compiler. At the time of writing this, the latest version used for cross-compiling with yotta is gcc 4.9. Download and install it, then add the bin/ subdirectory of the installation directory to your path. After you do that, you should be able to open cmd.exe and run arm-none-eabi-gcc from the command prompt. If that doesn't work, make sure that your path is properly set.
To use this compiler, you'll need to select a supported cross-compilation target, such as frdm-k64f-gcc, by running yotta target frdm-k64f-gcc before building.
# Building programs natively to run on windows
yotta does not yet allow compiling programs to run on windows. If you are adventurous and get it working, submit a pull request to update these docs.
# Solving Common Windows Installation Problems
error: command ['ninja'] failed
If you get an error when running yotta build which looks something like this:
':' is not recognized as an internal or external command,
operable program or batch file.
...
ninja: build stopped: subcommand failed.
error: command ['ninja'] failed
This is caused by re-trying a yotta build after fixing a missing cross-compiler installation. After completing the installation of the compiler, you'll need to run yotta clean before running build again.
# Adding things to your PATH in windows
Your PATH environment variable holds the location of programs that can be easily executed by other programs. If yotta fails to find one of its dependencies (such as cmake.exe) the first thing to check is that you have added the directory that contains the dependencies executable to the PATH. To add things to your path:
- Right click on Computer, select
Properties - Select
Advanced System Settings - Select the
Advancedtab - Click the
Environment Variablesbutton -
Find the
Pathvariable, edit it, and append the path you want to add, preceded by a semicolon, for example:;C:\Path\to\whereverNOTE: be careful not to add any spaces before or after the semicolon, this can cause commands to fail later.
-
finally, close then re-open any open cmd.exe windows
# Installing in a Virtualenv
Virtualenv is a way of separating different python programs installed on the same system from each other. If you have a complex python environment on your system it's recommended that you install yotta inside a virtualenv. To do this, first install the non-python dependencies following the normal instructions for your platform, then:
-
Ensure you have virtualenv itself installed. It can be installed with:
pip install virtualenvCheck that your installation is succesful by running
virtualenv --version. -
Create a directory to use for the yotta virtualenv:
mkdir yotta-venv virtualenv ./yotta-venv -
activate the new virtualenv:
source ./yotta-venv/bin/activate -
install yotta in the virtualenv:
pip install yotta -
(optional) add the binary directory of your virtualenv to your PATH: (if you omit this step, you will need to run yotta as
../path/to/yotta-venv/bin/yottainstead of simplyyotta.export PATH="/path/to/yotta-venv/bin:$PATH"
Now yotta should work as normal. You will need to activate the virtualenv any time you want to run yotta commands (you can deactivate it afterwards, by simply running deactivate).
# Upgrading yotta (all platforms)
To update yotta itself, run:
pip install -U --no-deps yotta
pip install yotta
This will update yotta to the latest available version, and then install any missing dependencies required by the new version.
You can also run:
pip install -U yotta
This will also attempt to update all of yotta's dependencies to their latest versions.
On Linux and OS X you may have to run these commands as sudo pip ...., if permission is denied.
- 安装依赖（Dependencies）
- Python 2.7. Python 3 support is experimental.
-
pip.
2. Manual installation instructions
- 安装虚拟环境，virtualenv。
mkdir yotta-venv
virtualenv ./yotta-venv
- 激活activate the new virtualenv:
source ./yotta-venv/bin/activate
- install yotta in the virtualenv: