Table of contents

RoadTest: Enroll to Review the Arduino GIGA R1 WiFi + Camera

Author: crisdeodates

Creation date: 16 Aug 2023

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Portenta H7, Arduino Mega / Due

What were the biggest problems encountered?: Availability of onboard off-the-shelf ports such as grove ports could have been better (solvable using shields)

Detailed Review:

Introduction

First of all, I would like to thank rscasny, the roadtest program team, and element14 for giving me this awesome chance to roadtest this amazing product Arduino Giga R1 Wifi board. Element14 was kind enough to send me a piece for road testing. I have been playing with Arduino boards ever since I started my robotics path. In fact, my first major project from college was using an Arduino Nano, dating back to the early beginning of the previous decade. So Arduino is not new to me and this beast of a thing is absolutely monstrous. Seriously? 76 GPIOs? Even Mega and Due had only 54 of them. When this board was available for the road test, I was determined to try this, not just for the kind of monster it is in the embedded space, but also to explore the endless possibilities it can provide in terms of scaling and productivity in the maker space. More interestingly, I was intrigued by the following statement from the official page: “You can for example run MicroPython and Arduino code simultaneously and communicate via an RPC”

Unboxing/Out of the box Experience

Let's have a look at the kit and its components:

The box came with the following components:

1. Arduino box
1. 1 x Arduino Giga R1 Wifi with glass bottom
2. 1 x 2.4/5Ghz flexible MOLEX antennae
3. 1 x classic Arduino thank you slip
4. 1 x classic Arduino stickers (I have like a lot of them now )
2. Arducam box
1. 1 x Arducam OV7675 VGA Color 20-pin DVP Camera Module

      (Yes, Randall was kind enough to include a camera module for the road testers)

The Arduino board in its “Giga” form really made an excellent first impression. The board was massive to hold at 101.6mm x 53.3mm (just like its older cousins Mega and Due), even dwarfing the Raspberry Pi 4 board's 56.5mm x 85.6mm footprint.

By default, the Arduino Giga board seems to come with a multicolor LED blink arduino program that seems to cycle between the Red, Green, and Blue colors of the inbuilt RGB LED that is present next to the audio jack.

Edit media

Dimensions x Small Medium Large Custom

Subject (required) Brief Description Tags (separated by comma) Video visibility in search results Visible Hidden

Parent content

Product Review - Arduino GIGA R1 WiFi + Camera - A beast in the embedded, IoT and robotics makerspace

Poster

Upload Preview

Ok

Cancel

Similar boards

There are basically 3 boards that could potentially be compared to Arduino Giga R1 Wifi.

Arduino GIGA R1 WiFi board basically inherits the STM32H7 dual-core Cortex-M7/M4 microcontroller of Portenta H7 boards while maintaining the larger Arduino Mega/Due form factor.

Performance in comparison to Portenta H7: 

Arduino GIGA R1 WiFi board could be expected to have the same high computing capacity as Portenta H7 boards since they share the same STM32H7 microcontroller.

However, in contrast to the Portenta H7, the Giga board comes with 76 GPIO, an audio jack, a USB 2.0 Type-A host port, and extra connectors for a display and a camera. At the same time, the Giga board has no support for DisplayPort over USB-C, no on-board 10/100M Ethernet PHY, no high-density connectors, and no built-in battery support which are present in the Portenta H7 board. 

Both boards feature a USB Type-C port for programming, integrating 2 MB of flash memory, 1 MB of RAM, 16 MB QSPI Flash memory, and 8 MB of SDRAM. Additionally, both boards have a Murata module for wireless connectivity (Wi-Fi and Bluetooth Low Energy BLE). Both boards can be programmed with the Arduino IDE or MicroPython. The dual-core design allows two programs to be run simultaneously with either both cores running Arduino code or one core running an Arduino sketch and the other a MicroPython script. An additional advantage of dual-core design as stated by the Arduino team is that, with this architecture, we can separate higher-level logic such as displays, interfaces, and networking from time-critical tasks such as motor control.

Features in comparison to Arduino Mega / Due:

At first look, the Giga board resembles the look of the Mega / Due form factor, although the Mega and Due can never match Giga in terms of performance. 

Image courtesy: MakerHero

The key difference is that Giga boasts a whooping 76 GPIO in contrast to the 54 GPIO in Mega / due boards. Also, Giga additionally has wireless connectivity, an audio jack, a USB 2.0 Type-A host port, a JTAG connector, and extra connectors for a display and a camera. The Giga also comes equipped with a crypto chip and an antenna. Within the generous 76 GPIO pins, 12 support PWM, 12 with analog input & 2 DACs. There are 4 UART, 3 I2C, and 2 SPI buses, plus CAN bus support (requires external transceiver). The Giga board also includes two new pins in contrast to Mega / Due. They are a VRTC pin to keep the real-time clock running when the main power is removed and an OFF pin that shuts down the board. Giga board can be powered with inputs varying from 6-24V DC while the other two only support up to a maximum of 12V. Even though all the existing shields seem compatible, Giga is a 3.3-volt logic device. Hence most of the existing shields might not work if they operate at the 5V levels. Since the microcontroller operates on a voltage of 3.3V, applying a higher voltage than that, such as 5V, to a pin might damage the microcontroller. 

Links

Here are some links to get started:

• GIGA R1 WiFi | Arduino Documentation
• Makers, get ready to step up your game with the GIGA R1 WiFi | Arduino Blog 
• GIGA R1 WiFi Network Examples | Arduino Documentation  
• GIGA R1 Camera Guide | Arduino Documentation 
• Camera for Arduino GIGA - Arducam 
• Meet the New Arduino Giga R1 WiFi
• Arduino GIGA R1 WiFi | Audio Loopback Example | Baltic Lab
• Arduino GIGA R1 WiFi — Zephyr Project Documentation
• Arduino Announces GIGA R1 WiFi, Its Most Powerful Board Yet | Tom's Hardware
• The Arduino Giga R1 WiFi, a Portenta H7 for Makers? A Review. | Elektor Magazine
• Fall Detection with Arduino Giga R1 WiFi - Edge Impulse Projects 
• Introducing the Arduino Giga R1 WiFi! - element14 Community
• Portenta H7-Like Power to the Mega & Due Form Factor - Hackster.io
• Arduino GIGA R1 WiF- Arduino US Store
• Arduino GIGA R1 WiFi board with STM32H7 MCU, up to 76 I/O pins - CNX Software
• Arduino GIGA R1 WiFi Bridges Portenta H7’s Computing Capacity on Mega Form Factor   

Board walkthrough

Let's have a look at the datasheet and some specifications of the Arduino Giga R1 Wifi board.

The Arduino GIGA R1 is one of the most feature-packed Arduino boards to date. It is supported by the same powerful, ML-capable, dual-core microcontroller found in the Arduino Pro family's Portenta H7.

Image Courtesy: DroneBotWorkshop

More detailed top view:

Image Courtesy: Arduino

More detailed bottom view:

Image Courtesy: Arduino

The reference ICs are:

Here are the main technical specifications.

• STM32H747XIH6 Microcontroller (datasheet)
  • 32-bit Arm® Cortex®-M7 core with double-precision FPU and L1 cache up to 480 MHz
  • 32-bit Arm® 32-bit Cortex®-M4 core with FPU up to 240 MHz
• Dual-core

• Full set of DSP instructions
  
  
• Memory Protection Unit (MPU)
  
  
• Murata® 1DX Wi-Fi®/Bluetooth® Module (datasheet)
• Wi-Fi® 802.11b/g/n 65 Mbps
• Bluetooth® Low Energy (version 5. X via Cordio stack, version 4.2 via Arduino Stack)
• Micro UFL connector for external antenna

• Memory
  • 2 MB Flash
  • 1 MB RAM
  • 16 MB NOR Flash
  • QSPI Interface
  • 8 MB SDRAM
    
• STM32H747XI
• AT25SF128A-MHB-T (datasheet)
• AS4C4M16SA (datasheet)
  
  
• I/O
• Digital I/O Pins: 76
• Analog input pins: 12
• PWM pins: 13
• Analog output pins (DAC0/DAC1): 2
• USB Host: USB 2.0 A
• USB Peripheral: USB-C®
• Logic level: 3.3V
• VRTC: To power the RTC while the board is off
• OFF pin: To turn off the board
  
  
• Communication
• 4x UART
• 3x I2C
• 2x SPI
• 1x CAN (an external transceiver is required)
  
  
• Secure Element ATECC608A-MAHDA-T Module (datasheet)
  
  
• USB
  • Host
  • Programming Port
  • HID
    
• USB Host USB 2.0 Type A
• USB Peripheral USB-C®
  
  
• Connectors
• Camera: 20-pin Arducam camera connector
• Display: D1N, D0N, D1P, D0P, CKN, CKP, D68-D75
• Audio jack: DAC0, DAC1, A7
• JTAG connector
  
  
• Power
• Circuit operating voltage: 3.3V
• Input voltage (VIN): 6-24V
• DC Current per I/O Pin: 8 mA
  
  
• Target areas
• 3D printing
• Signal Processing
• Maker Space
• Robotics

• Compatible Software & Development tools
  • Arduino IDE
  • Arduino CLI
  • Arduino Web Editor
  • Arduino IoT cloud
  • dfu-util
  • Arduino Lab for MicroPython
  • Thonny
• Arduino Core / MbedOS
• Micro Python

The pinout of the Arduino Giga R1 Wifi board is as follows.

Image Courtesy: Arduino

Recommended Operating Conditions of Giga are:

Note: VDD controls the logic level and is connected to the 3.3V power rail and VAREF is for the analog logic

Here is the functional block diagram:

Image Courtesy: Arduino

The power distribution is below:

Image Courtesy: Arduino

Let us also look at the Arducam module and its datasheet.

The camera is based on an OmniVision 0.3MP OV7675 image sensor. It excels in image capture with its advanced features and exceptional performance and supports RAW/RGB/YUV output format. It is fully compatible with Arduino GIGA R1 board allowing versatile image capture and processing capabilities.

• Image Sensor: OV7675
• Resolution: VGA
• Optical Size: 1/9”
• Number of effective pixels: 640(H) × 480(V)
• Pixel Size: 1.75μm × 1.75μm
• Support Platform: Arduino GIGA R1 WIFI Board
• Shutter Type: Electronic Rolling Shutter
• Color Filter Array: Quad-Bayer RGB
• Frame Rate: 15fps
• 640×480
• 320×240
• 160×120
• Output Format: RAW
• RAW RGB
• YUV422
• RGB565
• F.NO: 2.8±5%
• Focus Distance: 2.7m – ∞
• Focal Length: 1.75mm
• Field of View(FOV): 63.9°(D)
• Power Supply
• AVDD: 2.7VA ~ 3.0V
• DOVDD: 1.7V ~ 3.0V
• DVDD: 1.8V
• Operating Temperature: -30~70℃
• Camera Board Size: 30.5mm x 30.5mm

The pinout of the Arducam module is shown below.

Image Courtesy: ArduCam

Getting Started

Now, let’s get down to business and start tinkering with our new Arduino Giga R1 Wifi board. The initial setup with MbedOS is pretty straightforward like any other Arduino board.

1. Download and Install Arduino IDE from the Arduino Software page.
2. Open the IDE and install the board package.
   To install the GIGA board package, choose "Board Manager" from the left menu.
   Search for "GIGA" and install the latest version.
3. Select your board in the board selector.
4. Connect the board to your computer via the USB-C connector.

Now let us try an example blink sketch

1. Open the example from File -> Examples -> Basics -> Blink
2. Verify (Checkmark) and Upload (Right arrow) the sketch to the board
3. Now the inbuilt RGB LED near the audio port should start blinking green.
4. We have successfully set up the Giga board with the Arduino Core for mbed devices.

INFO: Normally, if the sketch fails for some reason, the board resets. On the GIGA R1, whenever the MbedOS fails, the board does not reset automatically. Instead, if it fails, the onboard red LED will start to blink in a looping pattern of 4 fast blinks and 4 slow blinks. Hence the red LED does NOT mean your board is broken or bricked. Instead, you can either press the reset button once to reset the sketch or double-tap the reset button to enter bootloader mode which allows you to re-program the board.

Testing

Here we will test the various features and capabilities of the Arduino Giga R1 Wifi board, along with the interfacing of various sensors and actuators.

GPIO access 

Let's connect a bush button to Digital pin 7 of the GigaR1 and read its value.

In the Arduino IDE, go to File -> Examples -> Basics -> DigitalReadSerial

Change the variable pushButton to 7 for Digital Pin number 7 in GigaR1.

Compile and upload the sketch.

Connect a push button to the Digital Pin 7 of the GigaR1.

I used a DFRobot Gravity Push button: https://www.dfrobot.com/product-2362.html

Connect the power pins of the pushbutton to 3.3v and the GND pins of the GigaR1.

Observe the state of Digital Pin 7 in the serial monitor output.

Wifi access

Reference: https://docs.arduino.cc/tutorials/giga-r1-wifi/cheat-sheet#wi-fi 

Let's see how the Wifi could be set up in GigaR1.

In the Arduino IDE, go to File -> Examples -> Wifi -> WifiWebClient

Change the SSID and password in the arduino_secrets.h file

Change the server variable name to google.com in WifiWebClient.ino file

Compile and Upload the program

We can see that the Giga R1 successfully connected to our local Wifi and was able to access the Google server webpage.

IoT cloud

Connecting to Arduino Cloud:

1. Login to Arduino cloud: https://create.arduino.cc/
2. Download and install the Arduino Create Agent: https://create.arduino.cc/getting-started/plugin/download 
3. Make sure the Agent is active and Giga R1 is connected to the computer
4. Come to the devices tab and click Add Device
5. Select the option Arduino board and wait for the board to be detected
6. Once the device is detected, click configure
7. Give a name for the device. Eg: GigaR1 and proceed
8. Now the cloud setup will take place and makes the device accessible to the Arduino IoT cloud

USB access

Reference: https://docs.arduino.cc/tutorials/giga-r1-wifi/giga-usb 

USB Host

Generic USB keyboards could be easily connected to the GIGA R1's USB-A connector without any additional circuitry. However, we need the USBHostGiga library.

Note: To enable the USB-A port, you will need to define it as an output (PA_15). We can also disable it inside of a sketch by writing a LOW state to it.

1. Download the USBHostGiga library as a zip file: https://github.com/arduino-libraries/USBHostGiga 
2. Go to Sketch > Include Library > Add .zip Library and select the downloaded zip to install the library.
3. Compile and upload the below code:

#include "USBHostGiga.h"

Keyboard keyb;

HostSerial ser;

void setup() {

  Serial.begin(115200);

  while (!Serial);

  pinMode(PA_15, OUTPUT);

  keyb.begin();

  ser.begin();

}

void loop() {

  if (keyb.available()) {

    auto _key = keyb.read();

    Serial.println(keyb.getAscii(_key));

  }

  while (ser.available()) {

    auto _char = ser.read();

    Serial.write(_char);

  }

  //delay(1);

}

Once the code is uploaded, connect your USB keyboard to the USB-A port of GigaR1.

Open the serial monitor and start pressing the keyboard keys.

The keys pressed will be displayed on the serial monitor.

USB HID

GIGA R1 board can also be transformed or emulated into a Human Interface Device (HID), e.g. mouse & keyboard, game controller, etc.

Let's try to emulate a keyboard. 

In the Arduino IDE, go to File -> Examples -> USBHID -> Keyboard

Open a notepad after the code is uploaded

We can see that the GigaR1 now emulates a keyboard and prints the text “Hello World” as if typed from a keyboard device.

CAUTION: The keyboard continues to print as soon as the code is uploaded as it is inside the loop. Hence make sure you are bringing up a notepad or another textual area as soon as the code upload is finished or the board is reset.

CAUTION: Once the GigaR1 is configured as an HID, it will fail to upload any more sketches. In that case, double press the RST button (to the right of the USB-C port) to enter bootloader mode. You will be able to upload new sketches now.

USB Read

Reference: https://reference.arduino.cc/reference/en/libraries/arduino_usbhostmbed5/ 

Let's try to read the contents of a USB drive connected to the USB-A port of the GigaR1.

Go to the Library Manager and install the Arduino_USBHostMbed5 library

Compile and upload the below code:

#include <DigitalOut.h>

#include <FATFileSystem.h>

#include <Arduino_USBHostMbed5.h>

USBHostMSD msd;

mbed::FATFileSystem usb("usb");

void setup()

{

    Serial.begin(115200);    

    pinMode(PA_15, OUTPUT); //enable the USB-A port

    digitalWrite(PA_15, HIGH);    

    while (!Serial)

        ;

    Serial.println("Starting USB Dir List example...");

    // if you are using a Max Carrier uncomment the following line

    // start_hub();

    while (!msd.connect()) {

        //while (!port.connected()) {

        delay(1000);

    }

    Serial.print("Mounting USB device... ");

    int err = usb.mount(&msd);

    if (err) {

        Serial.print("Error mounting USB device ");

        Serial.println(err);

        while (1);

    }

    Serial.println("done.");

    char buf[256];

    // Display the root directory

    Serial.print("Opening the root directory... ");

    DIR* d = opendir("/usb/");

    Serial.println(!d ? "Fail :(" : "Done");

    if (!d) {

        snprintf(buf, sizeof(buf), "error: %s (%d)\r\n", strerror(errno), -errno);

        Serial.print(buf);

    }

    Serial.println("done.");

    Serial.println("Root directory:");

    unsigned int count { 0 };

    while (true) {

        struct dirent* e = readdir(d);

        if (!e) {

            break;

        }

        count++;

        snprintf(buf, sizeof(buf), "    %s\r\n", e->d_name);

        Serial.print(buf);

    }

    Serial.print(count);

    Serial.println(" files found!");

    snprintf(buf, sizeof(buf), "Closing the root directory... ");

    Serial.print(buf);

    fflush(stdout);

    err = closedir(d);

    snprintf(buf, sizeof(buf), "%s\r\n", (err < 0 ? "Fail :(" : "OK"));

    Serial.print(buf);

    if (err < 0) {

        snprintf(buf, sizeof(buf), "error: %s (%d)\r\n", strerror(errno), -errno);

        Serial.print(buf);

    }

}

void loop()

{

}

Now connect a FAT-formatted USB pen drive to the USB-A port of the GigaR1.

Please note that the name of the USB drive should be “usb”.

You should be able to see the drive contents in your serial monitor output.

Note: For some strange reason, my pendrive was not mounted. I will try later with another pen drive.

Camera Access

Reference: https://docs.arduino.cc/tutorials/giga-r1-wifi/giga-camera 

The GIGA R1 has a dedicated camera connector that allows us to mount certain camera modules directly on the board. This will enable the possibility to use machine vision in our GigaR1 projects. 

The GIGA R1 currently supports the following cameras, via the Camera library that is bundled with the Arduino Mbed Core:

1. OV7670 and OV7675
2. GC2145
3. Himax HM01B0
4. Himax HM0360

We can access the Camera Library here: https://github.com/arduino/ArduinoCore-mbed/tree/master/libraries/Camera 

The 20-pin camera connector onboard the GIGA R1 is designed to be directly compatible with some breakout boards from ArduCam. This allows us to simply connect the camera module directly to the board, without making any additional circuit.

Image Courtesy: Arduino

Let's try to access the camera module using GigaR1.

We will need to install the software called Processing in order to read the serial camera buffer data sent from GigaR1.

Step 1: Configure Arduino to send camera data via Serial

Connect the camera module to the 20-pin camera connector.

In the Arduino IDE, go to File -> Examples > Camera > CameraCaptureRawBytes

Make sure the correct camera module is selected inside the code. Eg: OV7675

Compile and upload the sketch

Step 2: Configure Processing to read the camera data via Serial

Open the Processing app.

Copy the following code to the processing app:

import processing.serial.*;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

Serial myPort;

// must match resolution used in the Arduino sketch

final int cameraWidth = 320;

final int cameraHeight = 240;

// Must match the image mode in the Arduino sketch

final boolean useGrayScale = false;

// Must match the baud rate in the Arduino sketch

final int baudRate = 115200;

final int cameraBytesPerPixel = useGrayScale ? 1 : 2;

final int cameraPixelCount = cameraWidth * cameraHeight;

final int bytesPerFrame = cameraPixelCount * cameraBytesPerPixel;

final int timeout =  int((bytesPerFrame / float(baudRate / 10)) * 1000 * 2); // Twice the transfer rate

PImage myImage;

byte[] frameBuffer = new byte[bytesPerFrame];

int lastUpdate = 0;

boolean shouldRedraw = false;

void setup() {

  size(640, 480);  

  // If you have only ONE serial port active you may use this:

  //myPort = new Serial(this, Serial.list()[0], baudRate);          // if you have only ONE serial port active

  // If you know the serial port name

  //myPort = new Serial(this, "COM5", baudRate);                    // Windows

  myPort = new Serial(this, "/dev/ttyACM0", baudRate);            // Linux

  //myPort = new Serial(this, "/dev/cu.usbmodem14301", baudRate);     // Mac

  // wait for a full frame of bytes

  myPort.buffer(bytesPerFrame);  

  myImage = createImage(cameraWidth, cameraHeight, ALPHA);  

  // Let the Arduino sketch know we're ready to receive data

  myPort.write(1);

}

void draw() {

  // Time out after a few seconds and ask for new data

  if(millis() - lastUpdate > timeout) {

    println("Connection timed out.");    

    myPort.clear();

    myPort.write(1);

  }  

  if(shouldRedraw){    

    PImage img = myImage.copy();

    img.resize(640, 480);

    image(img, 0, 0);

    shouldRedraw = false;

  }

}

int[] convertRGB565ToRGB888(short pixelValue){  

  //RGB565

  int r = (pixelValue >> (6+5)) & 0x01F;

  int g = (pixelValue >> 5) & 0x03F;

  int b = (pixelValue) & 0x01F;

  //RGB888 - amplify

  r <<= 3;

  g <<= 2;

  b <<= 3; 

  return new int[]{r,g,b};

}

void serialEvent(Serial myPort) {  

  lastUpdate = millis();  

  // read the received bytes

  myPort.readBytes(frameBuffer);

  // Access raw bytes via byte buffer  

  ByteBuffer bb = ByteBuffer.wrap(frameBuffer);  

  // Ensure proper endianness of the data for > 8 bit values.

  // The 1 byte bb.get() function will always return the bytes in the correct order.

  bb.order(ByteOrder.BIG_ENDIAN);

  int i = 0;

  while (bb.hasRemaining()) {

    if(useGrayScale){

      // read 8-bit pixel data

      byte pixelValue = bb.get();

      // set pixel color

      myImage.pixels[i++] = color(Byte.toUnsignedInt(pixelValue));

    } else {

      // read 16-bit pixel data

      int[] rgbValues = convertRGB565ToRGB888(bb.getShort());

      // set pixel RGB color

      myImage.pixels[i++] = color(rgbValues[0], rgbValues[1], rgbValues[2]);

    }       

  }  

  myImage.updatePixels();  

  // Ensures that the new image data is drawn in the next draw loop

  shouldRedraw = true;  

  // Let the Arduino sketch know we received all pixels

  // and are ready for the next frame

  myPort.write(1);

}

Make sure to select the correct serial port and baud rate in the code.

Press the Play button on the app to run the code.

We can see that the processing code will display the output of the serial data sent by the GigaR1 module.

CAUTION: If the serial port says busy in the processing app, make sure that the serial monitor is not open in the Arduino IDE.

Conclusion

The Arduino Giga R1 Wifi was a very fun and interesting board to work with. The readily available out-of-the-box Arduino example sketch will allow anyone to directly jump into using and tinkering with the kit, although the advanced features such as Dual core programming, multi-channel ADC, etc require some experience. MicroPython support also allows a robotics project to be realized with little to no effort. The availability of good documentation is also a plus as it allows in-depth programming and interfacing. The peripheral interfacings are also well set and we have access to a plethora of interfacing pins and options.

The major pros and cons of the kit are summarized below.

Pros

1. Simple, robust, and easily programmable development board.
2. MicroPython programming is available.
3. Very easy module to work with, even for robotics beginners.
4. Very good first impression and out-of-the-box experience.
5. Availability of good documentation and community support.
6. Allows Python (MicroPython) and C++ (Arduino) programming.
7. A vast array of peripherals is available onboard.

Cons

1. The absence of onboard off-the-shelf ports such as grove ports could be a bit awkward, but can be solved by using shields.
2. Some features are advanced and require a deep understanding of the core concepts.

Future Prospects

I wish to do a bit more testing on the advanced capabilities such as Dual core programming, Multi-channel ADC, actuator interfacings, etc.

TRANSLATE with x

English

Arabic	Hebrew	Polish
Bulgarian	Hindi	Portuguese
Catalan	Hmong Daw	Romanian
Chinese Simplified	Hungarian	Russian
Chinese Traditional	Indonesian	Slovak
Czech	Italian	Slovenian
Danish	Japanese	Spanish
Dutch	Klingon	Swedish
English	Korean	Thai
Estonian	Latvian	Turkish
Finnish	Lithuanian	Ukrainian
French	Malay	Urdu
German	Maltese	Vietnamese
Greek	Norwegian	Welsh
Haitian Creole	Persian

TRANSLATE with

COPY THE URL BELOW

Back

EMBED THE SNIPPET BELOW IN YOUR SITE

Enable collaborative features and customize widget: Bing Webmaster Portal

Back