arduino

now browsing by tag

 
 

Arduino Intel Galileo

logo
Traducción de : http://arduino.cc/en/ArduinoCertified/IntelGalileo

Intel Galileo

Intel Galileo delantero Intel Galileo Volver


Galileo es una placa electronica basada en el Quark Intel ® 
SoC procesador X1000 de aplicaciones, un sistema de 32 bits Intel Pentium en un chip ( ficha técnica ). Es la primera placa basada en la arquitectura Intel ® diseñada para estar con escudos Arduino diseñados para el Uno R3 hardware y software compatible pin-. Pines digitales 0 a 13 (y el Aref adyacente y pines GND), entradas analógicas de 0 a 5, el jefe de la energía, la cabecera ICSP, y los pines del puerto UART (0 y 1), están todos en los mismos lugares que en la Arduino Uno R3. Esto también se conoce como el 1,0 pinout Arduino.Visión de conjunto

Galileo está diseñado para apoyar a los escudos que operan a 3,3 V o 5 V, ya sea. La tensión de funcionamiento básico de Galileo es 3.3V. Sin embargo, un puente en la placa permite la traducción de voltaje a 5V en los pines de E / S. Esto proporciona soporte para escudos 5V Uno y es el comportamiento predeterminado. Al cambiar la posición del puente, la traducción de tensión se puede desactivar para proporcionar un funcionamiento de 3,3 V en los pines de E / S.

Por supuesto, el consejo Galileo es también software compatible con el Arduino Software Development Environment (IDE), que hace que la usabilidad y la introducción de un broche de presión. Además del hardware Arduino y la compatibilidad del software, la junta Galileo tiene varios estándar PC puertos I / O y características para ampliar el uso y las capacidades nativas más allá del escudo ecosistema Arduino. Una ranura de tamaño completo mini-PCI Express, puerto Ethernet de 100 Mb, ranura Micro-SD, RS-232 puerto serial, puerto Host USB, puerto USB Client y 8MByte flash NOR vienen de serie en el tablero.

Visite el FAQ página para más informaciones.

Primeros pasos

Para empezar, basta con conectar la placa de alimentación con el adaptador de CA a CC 5V y luego conectarse a la computadora con el cable micro-USB. Por defecto se miden desde el suelo a 5 voltios.

  • I2C bus, TWI : SDA y SCL pins que se encuentran cerca del pin AREF.
    • TWI: A4 o A5 pin SDA y SCL o pin. Soporte comunicación TWI utilizando la librería Wire.
  • SPI :
    • El valor predeterminado es 4 MHz para apoyar escudos Arduino UNO. cantar el tablero.

Arduino Shield Apoyado Características Galileo es compatible con escudos Arduino UNO y está diseñado para apoyar a 3,3 V o 5V escudos, a raíz de la revisión Arduino Uno 3, incluyendo:

  • 14 entradas / salidas digitales , de las cuales 6 se pueden utilizar como salidas de pulso modulación de ancho (PWM);
    • Cada uno de los 14 pines digitales de Galileo se puede utilizar como una entrada o salida, el uso (funciones) pinMode (), digitalWrite (), y digitalRead.
    • Operan en 3,3 o 5 voltios. Cada pin puede proporcionar un máximo de 10 mA o recibir un máximo de 25 mA y tiene una resistencia de pull-up (desconectado por defecto) de 5,6 K a 10 kOhm.
  • A0 – A5 : 6 entradas analógicas, a través de un AD7298 convertidor de A a D
    • Cada una de las entradas analógicas 6, etiquetados A0 a A5, ofrece 12 bits de resolución (es decir, 4.096 valores diferentes).Por defecto se miden desde el suelo a 5 voltios.
  • I2C bus, TWI : SDA y SCL pins que se encuentran cerca del pin AREF.
    • TWI: A4 o A5 pin SDA y SCL o pin. Soporte comunicación TWI utilizando la librería Wire.
  • SPI :
    • El valor predeterminado es 4 MHz para apoyar escudos Arduino UNO. Programable hasta 25 MHz .
    • Nota: Mientras que Galileo tiene un controlador nativo SPI, actuará como maestro y no como un esclavo SPI. Por lo tanto, Galileo no puede ser esclavo SPI a otro maestro SPI. Puede actuar, sin embargo, como un dispositivo esclavo a través del conector de cliente USB.
  • UART (puerto serie): puerto UART velocidad programable (pines digitales 0 (RX) y 1 (TX))
  • ICSP (SPI): un pasador de programación en serie 6 en circuito (ICSP) cabecea, situada apropiadamente para conectar a los escudos existentes. Estos pines soportan comunicación SPI usando la librería SPI.
  • VIN : La tensión de entrada a la tarjeta de Galileo, cuando se trata de utilizar una fuente de alimentación externa (en contraposición a 5 voltios de la fuente de alimentación regulada conectada a la toma de alimentación). Usted puede suministrar tensión a través de este pin, o, si el suministro de tensión a través de la toma de poder, acceder a ella a través de este pin.
    • Advertencia : El voltaje aplicado a este pin debe ser una alimentación de 5V regulado de lo contrario podría dañar la placa Galileo o provocar un funcionamiento incorrecto.
  • 5V pin de salida : Este pin salidas 5V de la fuente externa o el conector USB. Consumo de corriente máxima al escudo es: 800 mA
  • Pin de salida de 3,3 V : Un suministro de 3,3 voltios generados por el regulador a bordo. Consumo de corriente máxima al escudo es: 800 mA
  • GND : Tierra pins.
  • IOREF : El pasador IOREF sobre Galileo permite un escudo adjunto con la configuración adecuada para adaptarse a la tensión proporcionada por la junta. La tensión pin IOREF es controlado por un puente en la placa, es decir, un conector de selección en la placa se utiliza para seleccionar entre 3,3 V y 5V operación escudo.
  • Botón RESET / pin : Traiga esta línea BAJO para restablecer el boceto. Normalmente se utiliza para agregar un botón de reinicio para escudos que bloquean el uno en el tablero.
  • AREF es utilizada en Galileo. Proporcionar una tensión de referencia externa para las entradas analógicas no es compatible.
    • Para Galileo no es posible cambiar el extremo superior del rango de entrada analógica usando el pin AREF y laanalogReference () la función.

Echa un vistazo a la muestra de audio Secuenciador tutorial del proyecto que Arduino Verkstad trajo a la Maker Faire Roma a Intel Galileo Booth.

Los detalles de la arquitectura Intel compatibles Características

El procesador Intel genuina y que rodean las capacidades de E / S nativas del Clanton SoC ofrece como ofrenda con todas las funciones, tanto para la comunidad cafetera y estudiantes por igual. También será útil para los desarrolladores profesionales que buscan un entorno sencillo y rentable el desarrollo a lo más complejo procesador Intel ® Atom e Intel ® diseños basados ​​en el procesador Core.

  • 400 MHz 32-bit Intel ® arquitectura del conjunto de instrucciones Pentium-compatible (ISA) o 16 KBytes on-die caché L1
    • 512 KBytes de SRAM en el chip incrustado
    • Fácil de programar: hilo simple, de un solo núcleo, velocidad constante
    • ACPI compatible estados de sueño CPU soportadas
    • Un reloj de tiempo real integrado (RTC), con un 3V batería opcional “célula de la moneda” para la operación entre su vez en ciclos.
  • Conector Ethernet 10/100
  • Completa PCI Express * ranura mini-tarjeta, con PCIe 2.0 características compatibles
    • Funciona con media mini- PCIe tarjetas con la placa del convertidor opcional
    • Proporciona USB 2.0 Host Port en mini- PCIe conector
  • Conector USB 2.0 Host
    • Soporta hasta 128 dispositivos de punto final USB
  • Conector de dispositivos USB, que se utiliza para la programación
    • Más allá de una interface de programación – un controlador de dispositivo USB 2.0 totalmente compatible
  • 10-pin header estándar JTAG para depuración
  • Botón Reiniciar para reiniciar el procesador
  • Botón Restablecer para restablecer el boceto y cualquier escudo adjuntos
  • Las opciones de almacenamiento:
    • Defecto – 8 MByte propósito principal legado SPI Flash es para almacenar el firmware (o gestor de arranque) y el último boceto. Entre 256KByte y 512KByte se dedica al almacenamiento de boceto. La descarga se realizará automáticamente desde el PC de desarrollo, por lo que no se requiere ninguna acción a menos que haya una actualización que se va a agregar al firmware.
    • Por defecto 512 KByte incrustado SRAM, habilitado por el firmware por defecto. No se requiere para utilizar esta característica acción.
    • Por defecto 256 Mbytes DRAM, habilitado por el firmware por defecto.
    • Opcional tarjeta micro SD ofrece hasta 32GByte de almacenamiento
    • Almacenamiento USB funciona con cualquier unidad compatible USB 2.0
    • 11 Kbyte EEPROM se puede programar a través de la EEPROM biblioteca .

Esquema, Diseño y Pin Referencia Mapping

Potencia

Galileo es alimentado a través de un adaptador de CA a CC, conectada al conectar un centro positivo enchufe de 2.1mm en el conector de alimentación del tablero. La capacidad nominal de salida recomendada del adaptador de corriente es de 5V de hasta 3A.

Resumen Eléctrico

Voltaje de entrada (recomendado) 5V
Voltaje de entrada (límites) 5V
Digital I / O Pins 14 (de los cuales 6 proporcionan PWM)
Pines de entrada analógica 6
Total Corriente de salida DC en todas las líneas de E / S 80 mA
Corriente de la CC para Pin 3.3V 800 mA
Corriente de la CC 5V para el Pin 800 mA

Comunicación

Galileo tiene una serie de instalaciones para la comunicación con un ordenador, otro Arduino, u otros microcontroladores. Galileo ofrece UART TTL (5V/3.3V) de comunicación en serie, que está disponible en el pin digital 0 (RX) y 1 (TX). Además, un segundo UART proporciona RS-232 de soporte y está conectado a través de un conector de 3,5 mm. Los dispositivos USB de los puertos permite (CDC) de comunicaciones serie a través de USB. Esto proporciona una conexión serie con el Serial Monitor u otras aplicaciones de su ordenador. También permite a Galileo para que actúe como un ratón o teclado USB a un ordenador conectado. Para utilizar estas funciones, consulte el Mouse y páginas de referencia de la biblioteca de teclado. El Host USB puerto permite Galileo actuar como un host USB para periféricos conectados, tales como ratones, teclados y teléfonos inteligentes. Para utilizar estas funciones, consulte los usbhostpáginas de referencia. Galileo es la primera placa Arduino para ofrecer un mini PCI Express (mPCIe) ranura. Esta ranura permite a los módulos mPCIe tamaño completo y medio tamaño (con adaptador) que se conectan a la tarjeta y también proporciona un puerto adicional USB Host a través de la ranura. Cualquier módulo mPCIe estándar puede ser conectado y utilizado para proporcionar aplicaciones tales como WiFi , Bluetooth o conectividad celular. Inicialmente, la ranura de Galileo mPCie proporciona soporte para el WiFi Biblioteca. Para obtener información adicional, consulte el Intel ® Galileo Guía de introducción . Un Ethernet RJ45 conector se proporciona para permitir que Galileo para conectarse a las redes de cable. Cuando se conecta a una red, debe proporcionar una dirección IP y una dirección MAC. Soporte completo de la interfaz Ethernet incorporada es totalmente compatible y no requiere el uso de la interfaz SPI como escudos Arduino existentes. El CODEC microSD lector de tarjetas es accesible a través de la Biblioteca SD. La comunicación entre Galileo y la tarjeta SD es proporcionada por un controlador integrado SD y no requiere el uso de la interfaz SPI como otras placas Arduino. El software de Arduino incluye una biblioteca de alambre para simplificar el uso de la TWI/I2C autobús;consulte la documentación para más detalles. Para SPI comunicación utilizar la biblioteca de SPI .

Programación

Galileo se puede programar con el software de Arduino ( descarga ). Cuando esté listo para enviar el dibujo a la junta, el programa Galileo a través del puerto USB Client seleccionando “Intel Galileo” que su tablero en el Arduino IDE. Conecte el puerto USB de la etiqueta del cliente Galileo (el más cercano a la Ethernet) a la computadora. Para obtener más detalles, consulte la referencia , tutoriales y Intel ® Galileo Guía de introducción . En lugar de exigir una prensa físico del botón de reinicio antes de que una carga, Galileo está diseñado para poner a cero por software que se ejecuta en un ordenador conectado.

Cuando son posibles las botas de mesa de hasta dos escenarios:

  • Si un bosquejo está presente en almacenamiento persistente, que se ejecuta.
  • Si no hay presentes boceto, el consejo espera órdenes de subida desde el IDE.

Si un dibujo se está ejecutando, puede cargar desde el IDE sin necesidad de pulsar el botón de reinicio en el tablero. El boceto se detiene; el IDE espera a que el estado de carga, y luego comienza el boceto recién cargado.

Al pulsar el botón de reinicio de la placa se reinicia un boceto si se está ejecutando y restablece cualquier escudo adjuntos.

Propiedades de pines configurada como salida

Pines configurados como salida con pinMode () se dice que están en un estado de baja impedancia. En Galileo, cuando un pin se configura como la producción, la funcionalidad se proporciona a través de una I2C Cypress E / S de expansión basado en la hoja de datos ). Pines digitales 0 a 13 y las clavijas analógicas A0 a A5 se pueden configurar como pines de salida de Galileo.

Pins del expansor de E / S, cuando se configura como OUTPUT, puede fuente (proporcionan corriente positiva) hasta 10 mA (miliamperios) y pueden hundirse (proporcionar corriente negativa) hasta 25 mA de corriente a otros dispositivos / circuitos. El individuo por pin capacidad de generación de corriente de 10 mA está sujeta a un límite global de 80 mA combinado entre todos los pines de salida. La capacidad de absorción de corriente por la capacidad de pin está sujeta a un límite global de 200 mA. En la siguiente tabla se presenta un desglose de las capacidades de salida global de los pines.

Fuente de corriente (mA) Corriente absorbida (mA)
Per Pin Capability 10 25
Digital Clavijas 3,5,9,10,12, 13 Combinada 40 100
Digital Clavijas 0,1,2,4,6,7,8,11 y Analogicas A0, A1, A2, A3, A4, A5 Combinada 40 100
Digital pernos 0-13 y prendedores analógico A0-A5 Combinada 80 200

Puente de configuración Galileo

Hay tres puentes de Galileo que se utilizan para modificar la configuración de la tarjeta. IOREF Jumper Para permitir el apoyo Galileo tanto 3.3V y 5V escudos, la tensión de funcionamiento externo se controla a través de un puente. Cuando el puente está conectado a 5V, Galileo está configurado para ser compatible con escudos 5V y IOREF se establece a 5V.Cuando el puente está conectado 3.3V, Galileo está configurado para ser compatible con pantallas de 3,3 V y IOREF se establece en 3,3. El rango de entrada de los pines analógicos también es controlado por el puente IOREF y no debe exceder la tensión de funcionamiento elegido. Sin embargo, la resolución de analogRead () se mantiene en 5 V/1024 unidades para la resolución de 10 bits por defecto o, 0.0049V (4.9mV) por unidad, independientemente de la configuración del puente IOREF.

Advertencia : El puente IOREF se debe utilizar para que coincida con la junta directiva y los voltajes de funcionamiento de escudo. Una configuración incorrecta del voltaje podría dañar la tarjeta o el protector. I2C Dirección Jumper Para evitar un enfrentamiento entre el I2C Dirección del esclavo del a bordo de expansión de E / S y EEPROM con cualquier externas I2C , el puente J2 se puede utilizar dispositivos esclavos para variar el I2C dirección de los dispositivos de a bordo. Con J2 conectada al pin 1 (marcado con el triángulo blanco), el O Expander dirección de 7 bits de E / es 0100001 y la dirección de la EEPROM de 7 bits es 1010001. Cambiando la posición del puente cambia la / O Expander dirección de E a 0.100.000 y la EEPROM frente a 1.010.000. VIN Jumper En Galileo, el pasador de VIN se puede utilizar para suministrar 5V de la fuente de alimentación regulada conectada a la toma de poder de los escudos o los dispositivos conectados. Si hay una necesidad de suministrar más de 5V a un escudo usando VIN entonces el puente VIN debe ser retirado de Galileo para romper la conexión entre la red de a bordo 5V y la conexión VIN en el cabezal de la placa.

Advertencia: Si el puente VIN no se quita y más de 5V está conectado a VIN, puede dañar la placa o provocar un funcionamiento poco fiable.

Automática (Software) Restablecer

En lugar de exigir una prensa físico del botón de reinicio antes de que una carga, Galileo está diseñado de una manera que permite que pueda ser restablecido por el software que se ejecuta en un ordenador conectado. Señales de control CDC-ACM USB se utilizan para hacer la transición desde Galileo en tiempo de ejecución a modo de gestor de arranque. El software de Arduino utiliza esta capacidad que le permite cargar código con sólo pulsar el botón de subida en el entorno Arduino. Para obtener más detalles, consulte el Intel ® Galileo Guía de introducción .

Características físicas

Galileo es de 4,2 pulgadas de largo y 2.8 pulgadas de ancho, respectivamente, con los conectores USB, conector UART, conector Ethernet y conector de alimentación que se extiende más allá de la primera dimensión. Cuatro orificios de los tornillos que la Junta pueda fijarse a una superficie o caja. Tenga en cuenta que la distancia entre los pines digitales 7 y 8 es de 160 milésimas de pulgada (0,16 “), no es un múltiplo par de la separación de 100 milésimas de pulgada de los otros pasadores.

Intel ® Documento Galileo Design

Este documento de diseño de Intel ® Galileo es licenciado por Intel en los términos de la licencia Creative Commons de Atribución Compartir-Igual (ver. 3), sujeto a los siguientes términos y condiciones. El documento de diseño de Intel ® Galileo SE PROPORCIONA “TAL CUAL” Y “CON TODOS SUS DEFECTOS”. Intel RECHAZA CUALQUIER OTRA GARANTÍA, YA SEA EXPRESA O IMPLÍCITA RESPECTO AL DISEÑO GALILEO O ESTE DOCUMENTO DE DISEÑO DE GALILEO INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS IMPLÍCITAS DE COMERCIALIZACIÓN O IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Intel ® puede realizar cambios en las especificaciones, esquemas y descripciones de productos en cualquier momento, sin previo aviso. El Cliente no debe basarse en la ausencia o las características de ninguna función o instrucción marcada como “reservada” o “no definida”. Intel ® las reserva para su definición futura y no asume ninguna responsabilidad por conflictos o incompatibilidades que surjan de cambios en el futuro para ellos. Disfrutar!

 

 

 

 

Traducido de : http://blog.arduino.cc/2014/02/27/websocketclient-for-intel-galileo-spacebrew/

WEBSOCKETCLIENT PARA INTEL GALILEO + SPACEBREW

Zoe Romano - 27 de febrero 2014

intel galileo

El equipo SmartUp presentó el Intel Comunidad un proyecto desarrollado en su nuevo laboratorio de fabricación digital, retoques con  Intel Galileo  juntas y Spacebrew.Spacebrew   es “un proceso abierto, conjunto de herramientas de software de forma dinámica volver a enrutar para coreografiar espacios interactivos”, básicamente una manera de conectar objetos inteligentes de todo tipo utilizando el protocolo WebSocket.Básicamente, modificaron la biblioteca Arduino WebsocketClient usarlo con Intel Galileo y específicamente con Spacebrew:

La situación fue recibido de una versión de la biblioteca de Arduino WebsocketClient: https://github.com/labatrockwell/ArduinoWebsocketClient(orientado a Spacebrew) adaptado de:https://github.com/krohling/ArduinoWebsocketClient (la implementación del protocolo websocket línea) ninguno de ellos el apoyo a Galileo, un consejo basado en Pentium Intel SoC. Se ha revisado, modificado e integrado, por lo que esta versión funciona con Galileo y trabaja tanto para la conexión a un servidor, como echo.websocket.org y Spacebrew. Esta versión incluye las instalaciones de seguimiento extendido para la depuración (ver WebSocketClient.h). Los principales cambios con respecto a las versiones anteriores están marcados por una barra-barra-estrella-barra-barra. 

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Poppy Tu humaniode Open Source

Poppy tu robot humaniode open source !

 

nos encanta este proyecto y te dejamos los enlaces necesarios par que tengas a tu nuevo amigo Poppy en casa pronto .

Open Source Humanoid

 

Poppy GitHub Project

Poppy Web

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Arduino Yun Guia paso a paso ( Inglés )

Arduino_Yun

Guide to the Arduino Yún

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.

1

Differences from the Arduino Leonardo

In addition to the 32U4 chip, the Yún has an additional processor, an Atheros AR9331, which runs a distribution of Linux for embedded systems named Linino, based on OpenWrt. A full install of Python 2.7 is included as well.

The Yún has a number of different physical characteristics and connectors than the Leonardo. There is an on-board SD slot, Ethernet jack, and a USB-A Host connector. There is no power barrel connector on the Yún; it can be powered from the micro-USB connector.

There is no built in 5V regulator. If you power your Yún with more than 5V, you will likely damage it. If you are not powering the Yún from the micro-USB connection, you can apply power to the Vin and 5V pins on the board. It is recommended to power the Yún from the USB connection whenever possible.

The SD, Ethernet, and USB-A connectors are not physically connected to the 32U4 processor, they are connected to the AR9331.

The Yún’s 32U4 functions in the same way as the Leonardo, except you cannot use Serial1. It is reserved for communication with the AR9331 processor.

The Yún also has a WiFi module built on board, allowing it to connect to a wireless router, or act as an access point. The 32u4, WiFi, and AR9331 processors all have their own reset buttons.

2

There are several status LEDs on the Yún, indicating power, WLAN connection, WAN connection and USB. Additionally pin 13 is connected to one of the status lights.

3

Linino

The Yún runs a distribution of Linux called Linino, based on OpenWrt. While it’s possible to configure the system

from the command line, there is a web page that allows you to configure many of the different options available. The interface (called LuCi) gives you access to most any setting you would need for maintaining the WiFi interface.

Accessing the web interface is described below.

To install additional software on Linino, you need to use the the Linux package manager opkg. For more information

on the manager and some common commands, see the Yún package manager page.

When interfacing with the Linino system, you have to use a command line, either accessing it through the Arduino’s Bridge library, or via SSH. If you are unfamiliar with the command line, you may want to read about some basics about it and some of the programs that are frequently used.

Python

An installation of Python 2.7 is included with Linino, with which you can write applications or scripts. For more on Python, visit the Python 2.7 documentation pages.

If you’re getting started with Python for the first time, there are a number of excellent resources on-line. “Learn Python the Hard Way” will cover everything you need to know to get up and running with your own scripts.

External storage on the Yún

You’re discouraged from using the Yún’s built-in non-volatile memory, because it has a limited number of writes.

You can use external memory like a microSD card or thumb drive for saving data, or your own scripts, web pages, etc. For the Yún to access and store information on these drives through the 32U4, they need to have a directory named arduino in the root of the volume.

Web services

Linino uses REST for clients and servers. REST is an acronym for “Representational State Transfer”. It is a software architecture that exposes various parts of the Arduino hardware through URLs.

By default, the REST API access is password protected. It is possible to change this to access the services without a password. To change this setting, enter the Yún configuration panel. At the bottom of the page, you will see toggles for changing the access.

4

A nice introduction to the concepts behind REST can be found here. The there are two REST end points recognized by the Yún are:

/arduino /data

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

Resetting the processors (AR9331, WiFi, and 32U4)

To restart the AR9331, which reboots Linino, 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. 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 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 Linino distribution to its default state, press the WiFi reset button for at least 30 seconds. The board reverts to the original settings as if it had been reflashed or taken out of the box. Among other things, this removes all installed files and network settings.

Serial re-enumeration on reset.

Since the Yún does not have a dedicated chip to handle serial communication, it means that the serial port is virtual – it’s a software routine, both on your operating system, and on the board itself. Just as your computer creates an instance of the serial port driver when you plug in any Arduino, the 32u4 creates a serial instance whenever it runs its bootloader. The board is an instance of USB’s Connected Device Class (CDC) driver.

This means that every time you reset the 32U4 processor, the USB serial connection will be broken and re-established. The board will disappear from the list of serial ports, and the list will re-enumerate. Any program that has an open serial connection to the Yún will lose its connection. This is in contrast to the Arduino Uno, with which you can reset the main processor (the ATmega328P) without closing the USB connection (which is maintained by the secondary ATmega8U2 or ATmega16U2 processor). This difference has implications for driver installation, uploading, and communication.

No reset when you open the serial port.

The Yún won’t restart your sketch when you open a serial port on the computer. That means you won’t see serial data that’s already been sent to the computer by the board, including, for example, most data sent in setup().

This also applies to the Console, described below.

This means that if you’re using any Serial or Console print(), println() or write() statements in setup(), they won’t show up when you open the serial monitor or Console connection. To work around this, you can check to see if the port is open like so:

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

or

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

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.

5

Windows

Windows now comes with an installer for the IDE and drivers.

Download Arduino IDE 1.5.4 installer or later, and double click the installer icon.

Once you’ve read the license, and if you agree with it, click the “I agree” button

6

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

7

Select the location you wish to install the IDE.

8

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

9

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

10

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

Linux

There is no need to install drivers for Ubuntu 10.0.4 and later.

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.

11

You will find a page with some diagnostic information about the current network connections. The first is your WiFi interface, the second is your ethernet connection. Press the Configuration button to proceed.

12

On the new page, you will configure your Yún, giving it a unique name and identifying what network you want to connect to.

In the Yún NAME field, give your Arduino a unique name. You’ll use this to refer to it in the future.

Choose a password of 8 or more characters for your Arduino. If you leave this field blank, the system retains the

default password of arduino

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.

13

When you press the Configure & Restart button, the Arduino will reset itself and join the specified network. The Arduino network will shut down after a few moments.

14

You can now join the network you assigned to the Yún.

Programming the 32U4 over WiFi

When your Yún is on the same network as your computer, you can connect to it wirelessly to program it.

After configuring your Yún, connect to the network you specified in the configuration settings. Open the Arduino IDE.

Under the Tools > Port menu, you should see an entry that lists your Yún’s name and its IP address. Under the Board menu, select Arduino Yún.

Open the Blink example (File > Examples > 01Basics > Blink) and upload the sketch to the board. You will be prompted for the administrator password. Use the one you entered in the configuration screen.

Once the program is uploaded, the 32U4 processor will restart. You should see the LED connected to pin 13 blinking.

Using the onboard Ethernet

When you connect the Yun to a wired network with an ethernet cable, it will try to connect automatically via DHCP. The board will show up on the ports menu just as it would over WiFi.

If you want to connect the Yun directly to your computer, either configure the computer’s interfaces to have a static IP address, or act as a DHCP server.

NB: the ethernet interface is eth1, not eth0

Communicating with Linino via Bridge

The Bridge library enables communication between Arduino and Linino. There are several different utility classes that facilitate different kinds of communication between the two, described below, and more in depth on the Bridge library reference pages.

15

The WiFi and Ethernet interfaces, USB host, and SD card are all connected to the AR9331. The Bridge library allows you to work with these devices, as well as run scripts and communicate with web services.

The Console

The Console, based on Bridge, enables you to send information from the Yún to a computer just as you would with the serial monitor, but wirelessly. It creates a secure connection between the Yún and your computer via SSH.

Load the following onto your Yún :

#include <Console.h>

const int ledPin = 13; // the pin that the LED is attached to

int incomingByte; // a variable to read incoming serial data into

void 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);

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 Linino through the Arduino.

In the following example, The Linino 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();

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);

In the second part of setup(), tell the instance of YunServer to listen for incoming connections only coming from localhost. Connections made to Linino 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();

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);

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);

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;

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);

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));

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));

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();

Check to make sure the URL is valid

if (client.read() != ‘/’) { client.println(F(“error”));

}return;

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);

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

16

The Yún has a number of built-in capabilities for networking, but some of the most exciting aspects are working with other online platforms. Arduino has partnered with Temboo to make connecting to your favorite services easy as possible. Temboo provides normalized access to 100+ APIs from a single point of contact allowing you to mix and match data coming from multiple platforms (for example Twitter, Facebook, Foursquare but even FedEx or PayPal).

There are a number of examples in the File > Examples > Bridge > Temboo folder, these are a great place to get started working with your Yún in the cloud. you can learn more about the integration of Temboo and Arduino on the Temboo getting started pages.

Spacebrew

Spacebrew is “a simple way to connect interactive things to one another.” It relies on a client/server model and uses WebSockets to communicate between the two. It runs a custom webserver on the Yún in python that allows for easy communication.

There are a number of examples for Spacebrew on the Yún included in the software. For more on Spacebrew, see the project documentation pages.

Install additional software on the Linux

The Yún comes with several software pre-installed on the Linux system, such as “curl” or “python”. Like you normally

do on your computer you may want to install other software on the Yún. On Linux systems additional software can be installed using a tool called “package management system”. You can read the page that describe more about the package manager to learn how to use it.

Next Steps

Now that you’ve gotten the basics down, you can dig in deeper with the Bridge library and examples. You can also check out the Yún hardware page for additional technical information.

The text of the Arduino getting started guide is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the guide are released into the public domain.

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

TEMBO : Arduino Internet of things Api Conection

tembo

Arduino YUN + TEMBO = 2a Revolución Industrial ?

El Arduino Yun viene cargado con el poder de Temboo, por lo que es fácil de conectar con una amplia gama de recursos y servicios basados ​​en la Web.

Temboo es una interface de desarrollo, que provee, una serie de apis, para conectar nuestro arduino YUN a casi cualquier cosa que os imaginéis.

Desde Proyectosarduino.com os recomendamos que no perdáis de vista esta solución, ya que creemos que este es el punto que faltaba para que Internet of Things Arranque de verdad!

Temboo, integrado con el poder de otros frameworks para hardware como “COSA” puede generar proyectos muy interesantes, que os iremos contando y explicando ;D

Os dejamos los enlaces de interés de la plataforma TEMBOO

Web Oficial

Blog Temboo

Las principales Api que pueden integrarse con Arduino Yun mediante Temboo son :

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Cosa – Programación orientada a objetos para Arduino

2013-04-28 16.39.10

COSA : Comunicación de protocolos en Arduino

by: Mikael Patel

Cosa es una plataforma orientada a objetos para Arduino que apoya un paradigma de programación orientado a eventos con máquinas de estados finitos simples. Contiene un amplio conjunto de clases para apoyar la rápida creación de prototipos de dispositivos de Internet – de – cosas . Cosa es compatible con los siguientes módulos AVR / ATmega / ATtiny hardware interno ; todos los modos de actuador , Pins digitales y analógicos, variables de salidas y entradas , comparador analógico , PWM , Watchdog , Timer0 (RTC ) , Timer1 ( Servo ) , UART , USI , SPI, TWI y EEPROM.

Varias plataformas muy potentes están uniendo a arduino ” nuestro pequeño cerebrito digital ” a los objetos que nos rodean, si TEMBOO ha marcado un hito, en la conexión de la placa Arduino con casi todas las APIs Software que necesitamos para convertir nuestro mundo en digital, ahora mezclado con Cosa, tiene una proyección brutal.

Estamos seguros de que esté tipo de soluciones van a desembocar en una pequeña revolución, tanto industrial, como en la forma de entender los servicios y la vida en general.

Os dejamos los enlaces al Blog, al repositorio, y a la wiki del autor de COSA,

contienen proyectos interesantes, que seguro os van a gustar!..

Blog “Cosa”

Wiki

Github

Pronto colgaremos los más relevantes explicados paso a paso como solemos hacer en www.proyectosarduino.com

Un saludo!

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Interaction Factory ( Empresa de productos interactivos y multitouch )

anuncio_fb5

INTERACTION FACTORY.ES

Mucho ojo a estos chicos, que están revolucionando la manera de entender el Digital Signage,

La unión del mundo online y offline, esta cada vez más cerca…

Pantallas multitouch, desarrollos con Kinect, projectos de Arduino, processing, video mapping..

Muchos directores de Marketing, los tendrán en el punto de mira.

No os olvideis de darle al Me Gusta, en Facebook, y visitar su nueva página :

http://www.facebook.com/interactionfactory.es

http://www.interactionfactory.es

Suerte con este gran proyecto de Laboratorio Creativo !

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Pinokio LAMP ( Pixar ! )

Los chicos de Pixar crearon este corto dando vida a una lampara, que la verdad emociona ;)

 

Muy bueno! , cada vez que lo veo me gusta más! no os perdais el making off !! tiene sorpresita!

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Hackea un peluche con Arduino !

Aquí os dejamos un interesante enlace para hackear un peluche y accionarlo mediante un tweet por ejemplo  ;P

 

tweet arduino  el archivo para descargar.

By Rob Millington and Stuart Dearnaley

 

 

 

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Arduino Yun Datasheet

Arduino_Yun

arduino-Yun-schematic

51b5b290e34e243665000003Arduino_Yun

 

aquí os queda el datasheet electrónico del Arduino YUN

Cortesía de Dog Hunter

dog hunter LLC

same license. www.doghunter.org

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Esquema ” Reference Design ” de Arudino UNO

 

El esquema de diseño de Arduino UNO.

 

ARDUINO UNO SCHEMATIC

ARDUINO UNO LAYOUT

 

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter