安装 mbed os 开发环境yotta

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 Yotta shortcut 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.
1. 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.
2. 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).
3. Add the directory you installed Ninja in to your path.
4. Install the arm-none-eabi-gcc cross-compiler in order to build software to run on embedded devices.
5. Finally, open cmd.exe and run pip install -U yotta to 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 Advanced tab
Click the Environment Variables button
Find the Path variable, edit it, and append the path you want to add, preceded by a semicolon, for example: ;C:\Path\to\wherever

NOTE: 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 virtualenv
```
Check 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/yotta instead of simply yotta.
```
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: