The Arduino Yún is an Arduino board unlike any other. While programming it is very similar to the Arduino Leonardo and uses the same processor, the Atmel ATmega32U4, it also has an additional processor, an Atheros AR9331, running Linux and the OpenWrt wireless stack. Programming the 32U4 via USB is identical to the Arduino Leonardo. Once you've configured the Yún to connect to your WiFi network, you can program the 32U4 via WiFi as well.
To connect the Arduino Yún to your computer, you'll need a Micro-B USB cable. This USB cable provides power and data to the board. When programming the Yún, you must choose Arduino Yún from the Tools > Board menu in the Arduino IDE. The Yún is only supported by Arduino IDE 1.5.4 and later.
Differences from the Arduino Leonardo
OpenWrt-Yun
Python
External storage on the Yún
Web services
Resetting the processors (AR9331, WiFi, and 32U4)
Resetting the password
Serial re-enumeration on reset.
No reset when you open the serial port.
Installing Drivers for the YúnOSX
Windows
Linux

Configuring the onboard WiFi
Programming the 32U4 over WiFi
Using the onboard Ethernet
Communicating with OpenWrt-Yun via Bridge
The Console
Process
Using Bridge to pass information between processors
Connecting to internet services with Temboo
Spacebrew
Install additional software on Linux
Next Steps

Differences from the Arduino Leonardo

The "/arduino" directory doesn't have anything pre-configured. Anything added to the URL after the end point is passed from the webserver to the sketch on the 32U4. You can define your APIs inside the sketch. See the Bridge example to see how this is done to access the pins on the board.
"/data" is used to access to the internal key/value storage. The available calls are:
/put/KEY/VALUE : stores a value inside the storage
/get/KEY : obtains the value of the requested key in JSON
/get : obtains the entire storage list in JSON.
/delete : deletes the internal storage

"mailbox" is used to add messages into a queue called Mailbox. The message queue is stored inside the Linux system and can be read by the Arduino microcontroller. The available REST call is:
"/mailbox/message"

Resetting the processors (AR9331, WiFi, and 32U4)
To restart the AR9331, which reboots OpenWrt-Yun, press the "YÚN RST" reset button that is close to the analog inputs pins and the LEDs of the board.
To restart the the 32U4 and restart the currently installed Arduino sketch, tap the button next to the Ethernet port two times.
The reset button for WiFi is located next to the USB-A connector. It is labeled "WLAN RST". When you press the button, the WLAN LED will flash.
If you move to a different network and can no longer wirelessly access the Yún through its web interface, you can reset the Yún's network configuration by pressing the WiFi reset button (WLAN RST) for longer longer than 5 seconds, but less than 30, the AR9331 processor will reboot. The WiFi configuration will be reset and the Yún will start its own wiFi network Arduino Yún-XXXXXXXXXXXX. Any other modification/configuration will be retained.
To reset the OpenWrt-Yun distribution to its default state, press the WiFi reset button (WLAN RST) for at least 30 seconds. The board reverts to the original settings: like just taken out of the box or to the latest update of the OpenWRTimage you have reflashed before. Among other things, this removes all installed files and network settings.
Resetting the password
The webpanel password can be reset and changed. Connect the Arduino Yún to your computer with an USB cable and upload the YunSerialTerminal sketch. It can be found in the Bridge examples in the Arduino IDE. When the Yún boot is complete, open the serial monitor, select New Line character in the dropdown menu and press Enter. Something like this should appear in your serial monitor:

// stops the program until Serial Monitor is opened while (!Serial) ;

[Get Code]

or
// stops the program until Console is opened while (!Console) ;

[Get Code]

Installing Drivers for the Yún
OSX
The first time you plug a Yún into a Mac, the "Keyboard Setup Assistant" will launch. There's nothing to configure with the Yún; you can close this dialogue by clicking the red button in the top left of the window.

Once you've read the license, and if you agree with it, click the "I agree" button

By default all available components are selected. These include the IDE, drivers, and shortcuts

Select the location you wish to install the IDE.

The installer will display its progress as it extracts the files to the proper locations

if you chose to install the drivers, a pop-up window will confirm your selection

When the installer has completed, you can press the "Close" button to finish.

NB: The Yún uses Bonjour services for auto-discovery on a wireless network. This service is not included with Windows by default. If you do not have Bonjour already installed, you can download the service from here. Additionally, you should make sure any anti-virus software is not blocking communication on port 5353.
Linux
There is no need to install drivers for Ubuntu 10.0.4 and later, but make sure port 5353 is not being blocked by a firewall.
Configuring the onboard WiFi
The Yún has the ability to act as an Access Point, but it can also connect to an existing network. These instructions walk you through connecting your Yún to a wireless network. The Yún can connect to unencrypted networks, as well as networks that support WEP, WPA, and WPA2 encryption.
When you first power on the Yún, it will create a WiFi network called ArduinoYun-XXXXXXXXXXXX. Connect your computer to this network.
Once you've obtained an IP address, open a web browser, and enter http://arduino.local
or 192.168.240.1 in the address bar. After a few moments, a web page will appear asking for a password. Enter "arduino
" and click the Log In button.

If you wish, you can set the timezone and country. It is recommended to set these options as it may help connecting to local WiFi networks. Setting the local timezone also selects the country's regulatory domain.
Enter the name of the wiFi network you wish to connect to.
Select the security type, and enter the password.

include <Console.h>const int ledPin = 13; // the pin that the LED is attached toint incomingByte; // a variable to read incoming serial data intovoid setup() { // initialize serial communication: Bridge.begin(); Console.begin(); while (!Console){ ; // wait for Console port to connect. } Console.println("You're connected to the Console!!!!"); // initialize the LED pin as an output: pinMode(ledPin, OUTPUT);}void loop() { // see if there's incoming serial data: if (Console.available() > 0) { // read the oldest byte in the serial buffer: incomingByte = Console.read(); // if it's a capital H (ASCII 72), turn on the LED: if (incomingByte == 'H') { digitalWrite(ledPin, HIGH); } // if it's an L (ASCII 76) turn off the LED: if (incomingByte == 'L') { digitalWrite(ledPin, LOW); } } delay(100);}

[Get Code]

To see the Console, select your Yún's name and IP address in the Port menu. The Yún will only show up in the Ports menu if your computer is on the same LAN as the Yún. If your board is on a different network, you won't see it in the Ports menu. Open the Port Monitor. You'll be prompted for the Yún's password.
You can also see the Console by opening a terminal window and typing ssh root@yourYunsName.local 'telnet localhost 6571'
then pressing enter.
NB: If you are using Windows, you must install a terminal emulator. PuTTY is a reasonable choice, but you will have to enter the two commands above separately.
Type 'H' to turn the LED on pin 13 on and type 'L' to turn it off.
Process
The Process commands allow you to run Linux processes on OpenWrt-Yun through the Arduino.
In the following example, The OpenWrt-Yun will connect to a server with curl
, and download some ASCII text. It prints the text a serial connection.

include <Process.h>void setup() { // Initialize Bridge Bridge.begin(); // Initialize Serial Serial.begin(9600); // Wait until a Serial Monitor is connected. while (!Serial); // run various example processes runCurl();}void loop() { // Do nothing here.}void runCurl() { // Launch "curl" command and get Arduino ascii art logo from the network // curl is command line program for transferring data using different internet protocols Process p; // Create a process and call it "p" p.begin("curl"); // Process that launch the "curl" command p.addParameter("http://arduino.cc/asciilogo.txt"); // Add the URL parameter to "curl" p.run(); // Run the process and wait for its termination // Print arduino logo over the Serial // A process output can be read with the stream methods while (p.available()>0) { char c = p.read(); Serial.print(c); } // Ensure the last bit of data is sent. Serial.flush();}

[Get Code]

Using Bridge to pass information between processors
Bridge allows you to pass information between the two processors using a key/value pairing.
This example shows how to use the Bridge library to access the digital and analog pins on the board through REST calls. It demonstrates how you can create your own API when using REST style calls through the browser.
When running this example, make sure your computer is on the same network as the Yun.
When you have have programmed the board, you can request the value on a pin, write a value to a pin, and configure a pin as an input or output.
When the REST password is turned off, you can use a browser with the following URL structure :
http://myArduinoYun.local/arduino/digital/13 : calls digitalRead(13);
http://myArduinoYun.local/arduino/digital/13/1 : calls digitalWrite(13,1);
http://myArduinoYun.local/arduino/analog/9/123 : analogWrite(9,123);
http://myArduinoYun.local/arduino/analog/2 : analogRead(2);
http://myArduinoYun.local/arduino/mode/13/input : pinMode(13, INPUT);
http://myArduinoYun.local/arduino/mode/13/output : pinMode(13, OUTPUT);

You can use the curl command from the command line instead of a browser if you prefer.
You need to include the Bridge, YunServer, and YunClient libraries :

include <Bridge.h>#include <YunServer.h>#include <YunClient.h>

[Get Code]

Instantiate a server enabling the the Yun to listen for connected clients.
YunServer server;

In setup()
, start serial communication for debugging purposes, and turn the built-in LED on pin 13 high while Bridge begins. Bridge.begin()
is blocking, and should take about 2 seconds to complete. Once Bridge starts up, turn the LED off.

void setup() { Serial.begin(9600); pinMode(13,OUTPUT); digitalWrite(13, LOW); Bridge.begin(); digitalWrite(13, HIGH);

[Get Code]

In the second part of setup()
, tell the instance of YunServer to listen for incoming connections only coming from localhost. Connections made to OpenWrt-Yun will be passed to the 32U4 processor for parsing and controlling the pins. This happens on port 5555. Start the server with server.begin()
.
server.listenOnLocalhost(); server.begin();}

[Get Code]

In loop()
, you'll create an instance of the YunClient for managing the connection. If the client connects, process the requests in a custom function (described below) and close the connection when finished.
Putting a delay at the end of loop()
will be helpful in keeping the processor from doing too much work.
void loop() { YunClient client = server.accept(); if (client) { process(client); client.stop(); } delay(50); }

[Get Code]

Create a function named process
that accepts the YunClient as its argument. Read the command by creating a string to hold the incoming information. Parse the REST commands by their functionality (digital, analog, and mode) and pass the information to the appropriately named function.

void process(YunClient client) { String command = client.readStringUntil('/'); if (command == "digital") { digitalCommand(client); } if (command == "analog") { analogCommand(client); } if (command == "mode") { modeCommand(client); }}

[Get Code]

Create a function to deal with digital commands. Accept the client as the argument. Create some local variables to hold the pin and value of the command.

void digitalCommand(YunClient client) { int pin, value;

[Get Code]

Parse the client's request for the pin to work with using client.parseInt()
.
If the character after the pin is a "/", it means the URL is going to have a value of 1 or 0 following. This value will assign a value to the pin, turning it HIGH or LOW. If there is no trailing "/", read the value from the specified pin.

pin = client.parseInt(); if (client.read() == '/') { value = client.parseInt(); digitalWrite(pin, value); } else { value = digitalRead(pin); }

[Get Code]

Print the value to the client and update the datastore key with the current pin value.
By wrapping the value to the client in F()
, you'll be printing form the flash memory. This helps conserve space in SRAM, which is useful when dealing with long strings like URLs.
The key will be the pin, and type. For example D2 will be saved for for digital pin 2. The value will be whatever value the pin is currently set to, or was read from the pin.
client.print(F("Pin D")); client.print(pin); client.print(F(" set to ")); client.println(value); String key = "D"; key += pin; Bridge.put(key, String(value));}

[Get Code]

Set up a function to handle analog calls in the same fashion, except setting the key to A instead of D when working with the analog input pins :
void analogCommand(YunClient client) { int pin, value; pin = client.parseInt(); if (client.read() == '/') { value = client.parseInt(); analogWrite(pin, value); // Send feedback to client client.print(F("Pin D")); client.print(pin); client.print(F(" set to analog ")); client.println(value); String key = "D"; key += pin; Bridge.put(key, String(value)); } else { value = analogRead(pin); client.print(F("Pin A")); client.print(pin); client.print(F(" reads analog ")); client.println(value); String key = "A"; key += pin; Bridge.put(key, String(value)); }}

[Get Code]

Create one more function to handle pin mode changes. Accept the YunClient as the argument, and create a local variable to hold the pin number. Read the pin value just as you did in the digital and analog functions.
void modeCommand(YunClient client) { int pin; pin = client.parseInt();

[Get Code]

Check to make sure the URL is valid
if (client.read() != '/') { client.println(F("error")); return; }

[Get Code]

If it's a valid URL, store the URL as a string. If the mode is an input
or output
, configure the pin and report it to client. If the string doesn't match those values, return an error.

String mode = client.readStringUntil('\r'); if (mode == "input") { pinMode(pin, INPUT); // Send feedback to client client.print(F("Pin D")); client.print(pin); client.print(F(" configured as INPUT!")); return; } if (mode == "output") { pinMode(pin, OUTPUT); // Send feedback to client client.print(F("Pin D")); client.print(pin); client.print(F(" configured as OUTPUT!")); return; } client.print(F("error: invalid mode ")); client.print(mode);}

[Get Code]

You can find more details on this example on the Bridge Example page.
Connecting to internet services with Temboo