**Arduino** é unha plataforma de hardware e software libre, baseada nunha placa cun microcontrolador e un contorno de desenvolvemento (IDE), deseñada para facilitar o uso da electrónica en proxectos multidisciplinares.

O hardware consiste nunha placa cun microcontrolador Atmel AVR e portos de entrada/saída. Os microcontroladores máis usados son o Atmega168, Atmega328, Atmega1280, ATmega8 pola súa sinxeleza e baixo custo que permiten o desenvolvemento de múltiples deseños. Doutra banda o software consiste nun contorno de desenvolvemento que pon en funcionamento a linguaxe de programación con Processing e Wiring e o cargador de arranque (*boot loader*) que corre na placa.

Arduino pódese utilizar para desenvolver obxectos interactivos autónomos ou pode ser conectado a software do computador (por exemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). As placas pódense montar a man ou adquirirse. O contorno de desenvolvemento integrado libre pódese descargar gratuitamente.

Ao ser open-hardware, tanto o seu deseño como a súa distribución é libre. É dicir, pode utilizarse libremente para o desenvolvemento de calquera tipo de proxecto sen adquirir ningunha licenza.

O proxecto Arduino recibiu unha mención honorífica na categoría de Comunidades Dixital no Prix Ars Electronica de 2006.

Historia
--------

En 2005, en Ivrea (Italia), no *Interaction Design Institute* (fundado por Olivetti e Telecom Italia), iniciouse o proxecto para facer un dispositivo controlador programable construído por estudantes de deseño para proxectos interactivos de baixo custo para sistemas de prototipado. Os fundadores Massimo Banzi e David Cuartielles chamaron ao proxecto despois *Arduin de Ivrea*, tomando o nome dun bar que o tomara a súa vez de Arduino de Ivrea, primeiro rei de Italia en 1002. "Arduino" é tamén un nome de home, que en italiano significa "amigo valente".

O proxecto Arduino é unha plataforma de código aberto (IDE) para plataformas (Linux, Mac e Windows). O artista colombiano e programador Hernando Barragán creouno como tese no Interaction Design Institute Ivrea baixo a supervisión de Massimo Banzi e Casey Reas. Wiring baséase en Processing e a súa contorna de desenvolvemento integrado, que fora creado por Casey Reas e Ben Fry.

Grazas á base de software común, dos creadores do proxecto para a comunidade Arduino foi posible desenvolver programas para conectar con este hardware máis ou menos calquera obxecto electrónico, ordenador, sensores, pantallas e actuadores. Despois de anos de experimentación, agora é posible beneficiarse dunha ampla base de datos e información.

Hardware
--------

### Placas Arduino

Unha placa Arduino consta dun microcontrolador de 8-bit Atmel AVR con compoñentes complementarios para facilitar a programación e a incorporación noutros deseños. Un aspecto importante de Arduino é a forma estándar na que dispóñense os conectores, permitindo que a placa da CPU poida ser conectada a unha variedade de módulos intercambiables adicionais coñecidos como **shields**. Algúns comunícanse cos *shields* da placa Arduino directamente cos diferentes pins, pero moitos *shields* son individualmente direccionables a través dun bus I²C de serie, o que permite que moitos *shields* poidan apílarse e empregarse en paralelo. As placas Arduino oficias empregan a serie de circuítos integrados megaAVR, especificamente o ATmega8, ATmega168, ATmega328, ATMEGA1280 e Atmega2560. Un feixe doutros procesadores compatibles foron empregados por Arduino. A maioría das placas inclúen un regulador lineal de 5 voltios e un oscilador de 16 MHz de reloxo (ou oscilador de cuarzo nalgunhas variantes), aínda que algúns deseños, tales como o LilyPad son a 8 MHz e prescinde do regulador de tensión integrado na placa, debido a restricións determinadas polo deseño. Un microcontrolador Arduino está tamén pre-programado cun xestor de arranque que simplifica a carga de programas na memoria flash do chip, en comparación con outros dispositivos que normalmente necesitan un programador externo ou hardware adicional.

A nivel conceptual, cando utilízase a pila de software de Arduino, todas as placas prográmanse a través dunha conexión RS-232, pero a forma en que isto faise varía segundo a versión do hardware. As placas serie Arduino conteñen un circuíto inversor simple para converter entre o nivel RS-232 e os sinais de nivel TTL. As actuais placas Arduino prográmanse a través de portos USB, posto en funcionamento a través do USB circuítos FT232 FTDI. Algunhas variantes, como o Mini Arduino e o non oficial Boarduino, empregan un cable de datos USB, Bluetooth ou outros métodos. (Cando emprégase con ferramentas para microcontroladores tradicionais en vez do IDE Arduino, emprégase o estándar de programación AVR ISP).

A maioría das placa Arduino conectan os pins do microcontrolador como Entradas/Saídas para o seu uso por outros circuítos. O Diecimila, Duemilanove, e o actual Uno proporcionan 14 pins E/S dixitais, seis dos cales poden producir pulsos de ancho variable, e seis entradas analóxicas (PWM). Estes pins atópanse na parte superior do taboleiro, a través de conectores femia de 0,1 polgadas. Varias aplicacións shields Plug-in tamén están dispoñibles comercialmente.

O Arduino Nano, e Arduino son compatibles coa unión Bare Bones e placas Boarduino podendo proporcionar pins macho na parte inferior da placa para colocarse en placas universais sen soldadura.

* Arduino LilyPad ten un deseño flexible, doado de levar na roupa.Arduino LilyPad ten un deseño flexible, doado de levar na roupa.
* Arduino Uno co porto USB e microcontrolador ATmega 328Arduino Uno co porto USB e microcontrolador ATmega 328
* Placa oficial Arduino Duemilanove (rev 2009b).Placa oficial Arduino Duemilanove (rev 2009b).
* Shield para prototipos ArduinoShield para prototipos Arduino

Especificacións técnicas
------------------------

Existen varias placas e deseños baseados en Arduino:

| Arduinoplaca | Procesador | Frecuencia | Voltaxe | FlashkB | EEPROMkB | SRAMkB | DixitalI/O pins | ...conPWM | Input analóxpins | USBtipo deInterface | OutrasI/O | Dimensiónspolgadasmm |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|   ADK  | ATmega2560 | 16 MHz | 5 V | 256 | 4 | 8 | 54 | 14 | 16 | 8U2 | MAX3421EUSB Host | 4 in × 2.1 in101.6 mm × 53.3 mm |
|   BT (Bluetooth) | ATmega328 | 16 MHz | 5 V | 32 | 1 | 2 | 14 | 4 | 6 | Non | Bluegiga WT11 Bluetooth |  |
|   Diecimila  | ATmega168 Arquivado 17 de xaneiro de 2012 en Wayback Machine. | 16 MHz | 5 V | 16 | 0.5 | 1 | 14 | 6 | 6 | FTDI |  | 2.7 in × 2.1 in68.6 mm × 53.3 mm |
| Due | ATMEL SAM3U Arquivado 16 de outubro de 2019 en Wayback Machine. | 96 MHz |  | 256 | 0 | 50 | 54 | 16 | 16 | AT91SAM3U4E |  |  |
|   Duemilanove | ATmega168/328P Arquivado 17 de xaneiro de 2012 en Wayback Machine. | 16 MHz | 5 V | 16/32 | 0.5/1 | 1/2 | 14 | 6 | 6 | FTDI |  | 2.7 in × 2.1 in68.6 mm × 53.3 mm |
|   Ethernet  | ATmega328 | 16 MHz | 5 V | 32 | 1 | 2 | 14 | 4 | 6 | Non | Wiznet Ethernet |  |
|   Fio Arquivado 26 de maio de 2011 en Wayback Machine. | ATmega328P | 8 MHz | 3.3 V | 32 | 1 | 2 | 14 | 6 | 8 | Non |  | 1.6 in × 1.1 in40.6 mm × 27.9 mm |
|   Leonardo | Atmega32u4 | 16 MHz | 5 V | 32 | 1 | 2 | 14 | 6 | 12 | 32u4 |  | 2.7 in × 2.1 in68.6 mm × 53.3 mm |
|   LilyPad | ATmega168V ou ATmega328V | 8 MHz | 2.7-5.5 V | 16 | 0.5 | 1 | 14 | 6 | 6 | Non |  | 2 in ⌀50 mm ⌀ |
| Mega | ATmega1280 | 16 MHz | 5 V | 128 | 4 | 8 | 54 | 14 | 16 | FTDI |  | 4 in × 2.1 in101.6 mm × 53.3 mm |
|   Mega2560 | ATmega2560 | 16 MHz | 5 V | 256 | 4 | 8 | 54 | 14 | 16 | 8U2/16U2 |  | 4 in × 2.1 in101.6 mm × 53.3 mm |
|   Nano | ATmega168 Arquivado 17 de xaneiro de 2012 en Wayback Machine. ou ATmega328 | 16 MHz | 5 V | 16/32 | 0.5/1 | 1/2 | 14 | 6 | 8 | FTDI |  | 1.70 in × 0.73 in43 mm × 18 mm |
|   Uno | ATmega328P | 16 MHz | 5 V | 32 | 1 | 2 | 14 | 6 | 6 | 8U2/16U2 |  | 2.7 in × 2.1 in68.6 mm × 53.3 mm |
| Micro | ATmega32u4 | 16 MHz | 5 V | 32 | 1 | 2.5 | 20 | 7 | 12 |  |  |  |

Ademais das placas e hardware oficial hai outros deseños fabricados por empresas e usuarios que son empregados en proxectos variados.

Linguaxe de programación Arduino
--------------------------------

A plataforma Arduino prográmase mediante o uso dunha linguaxe propia baseada na popular linguaxe de programación de alto nivel Processing. Con todo, é posible utilizar outras linguaxes de programación e aplicacións populares en Arduino. Algúns exemplos son:

* Java
* Flash (mediante ActionScript)
* Processing
* Pure Data
* MaxMSP (contorna gráfica de programación para aplicacións musicais, de son e multimedia)
* VVVV (síntese de vídeo en tempo real)
* Adobe Director
* Python
* Ruby
* C
* C++ (mediante libSerial ou en Windows)
* C#
* Cocoa/Objective-C (para Mac OS X)
* Linux TTY (terminais de Linux)
* 3DVIA Virtools (aplicacións interactivas e de tempo real)
* SuperCollider (síntese de son en tempo real)
* Instant Reality (X3D)
* Liberlab (software de medición e experimentación)
* BlitzMax (con acceso restrinxido)
* Squeak (posta en funcionamento libre de Smalltalk)
* Mathematica
* MATLAB
* Minibloq (Contorna gráfica de programación, corre tamén en OLPC)
* Isadora (Interactividade audiovisual en tempo real)
* Perl
* Visual Basic .NET
* VBScript
* Gambas

Isto é posible debido a que Arduino comunícase mediante a transmisión de datos en formato serie que é algo que a maioría das linguaxes anteriormente citadas soportan. Para os que non soportan o formato serie de forma nativa, é posible utilizar software intermediario que traduza as mensaxes enviadas por ambas as partes para permitir unha comunicación fluída. É bastante interesante ter a posibilidade de interactuar Arduino mediante esta gran variedade de sistemas e linguaxes posto que dependendo de cales sexan as necesidades do problema que imos resolver poderemos aproveitarnos da gran compatibilidade de comunicación que ofrece.

### Funcións básicas e operadores

Arduino esta baseado en C e soporta todas as funcións do estándar C e algunhas de C++. A continuación móstrase un resumo con tódalas estruturas da linguaxe Arduino:

#### Sintaxe básica

* Delimitadores: ;, {}
* Comentarios: //, /\* \*/
* Cabeceiras: #define, #include
* Operadores aritméticos: +, -, \*, /, %
* Asignación: =
* Operadores de comparación: ==, !=, <, >, <=, >=
* Operadores Booleanos: &&, ||, !
* Operadores de acceso a punteiros: \*, &
* Operadores de bits: &, |, ^, <<, >>
* Operadores compostos:
	+ Incremento/decremento de variables: ++, --
	+ Asignación e operación: +=, -=, \*=, /=, &=, |=

#### Estruturas de control

* Condicionais: if, if...else, switch case
* Bucles: for, while, do... while
* Bifurcaciones e saltos: break, continue, return, goto

#### Variables

En canto ao tratamento das variables tamén comparte un gran parecido coa linguaxe C.

##### Constantes

* HIGH / LOW: niveis alto e baixo en pines. Os niveis altos son aqueles de 3 voltios ou máis (ata 5 voltios, tecnoloxía TTL).
* INPUT / OUTPUT: entrada ou saída
* true / false (verdadeiro/falso)

##### Tipos de datos

* void, boolean, char, unsigned char, byte, int, unsigned int, word, long, unsigned long, float, double, string, array

##### Conversión entre tipos

Estas funcións reciben como argumento unha variable de calquera tipo e devolven unha variable convertida no tipo desexado.

* char(), byte(), int(), word(), long(), float()

##### Cualificadores e ámbito das variables

* static, volatile, const

##### Utilidades

* sizeof()

#### Funcións Básicas

En canto ás funcións básicas da linguaxe atopámonos coas seguintes:

##### E/S dixital

* pinMode(pin, modo)
* digitalWrite(pin, valor)
* int digitalRead(pin)

##### E/S analóxica

* analogReference(tipo)
* int analogRead(pin)
* analogWrite(pin, valor)

##### E/S avanzada

* shiftOut(dataPin, clockPin, bitOrder, valor)
* unsigned long pulseIn(pin, valor)

##### Tempo

* unsigned long millis()
* unsigned long micros()
* delay(ms)
* delayMicroseconds(microsegundos)

##### Matemáticas

* min(x, e), max(x, e), abs(x), constrain(x, a, b), map(valor, fromLow, fromHigh, toLow, toHigh), pow(base, expoñente), sqrt(x)

##### Trigonometría

* sin(rad), cos(rad), tan(rad)

##### Números aleatorios

* randomSeed(semente), long random(máx), long random(mín, máx)

##### Bits e bytes

* lowByte(), highByte(), bitRead(), bitWrite(), bitSet(), bitClear(), bit()

##### Interrupcións externas

* attachInterrupt(interrupción, función, modo)
* detachInterrupt(interrupción)

##### Interrupcións

* interrupts(), noInterrupts()

##### Comunicación por porto serie

As funcións de manexo do porto serie deben ir precedidas de "Serial." aínda que non necesitan ningunha declaración na cabeceira do programa. Por isto considéranse funcións basee da linguaxe.

* begin(), available(), read(), flush(), print(), println(), write()

#### Manipulación de portos

Os rexistros de portos permiten a manipulación a máis baixo nivel e de forma mais rápida dos pines de E/S do microcontrolador das placas Arduino. Os pines das placas Arduino están repartidos entre os rexistros B(0-7), C (analóxicos) e D(8-13). Mediante as seguintes variables podemos ver e modificar o seu estado:

* DDR[B/C/D]: Data Direction Register (ou dirección do rexistro de datos) do porto B, C ó D. Serve para especificar que pines queremos usar como de entrada e cales de saída. Variable de Lectura/Escritura.
* PORT[B/C/D]: Data Register (ou rexistro de datos) do porto B, C ó D. Variable de Lectura/Escritura.
* PIN[B/C/D]: Input Pins Register (ou rexistro de pines de entrada) do porto B, C ó D. Variable de só lectura.

Por exemplo, para especificar que queremos utilizar os pines 1 a 7 como saídas e o 0 como entrada, bastaría utilizar a seguinte asignación:

```
 DDRD = B11111110;
```

Como se puido comprobar, se coñecemos a linguaxe C, non teremos dificultades para programar en Arduino posto que se parecen enormemente. Tan só debemos aprender algunhas funcións específicas de que dispón a linguaxe para manexar os diferentes parámetros de Arduino. Pódense construír aplicacións de certa complexidade sen necesidade de moitos conceptos previos.

### AVR Libc

Os programas compilados con Arduino enlázanse contra AVR Libc polo que teñen acceso a algunhas das súas funcións. AVR Libc é un proxecto de software libre co obxectivo de proporcionar unha biblioteca C de alta calidade para utilizarse co compilador GCC sobre microcontroladores Atmel AVR. Componse de 3 partes:

* avr-binutils
* avr-gcc
* avr-libc

A maioría da linguaxe de programación Arduino está escrita con constantes e funcións de AVR e certas funcionalidades só se poden obter facendo uso de AVR.

#### Interrupcións

Para desactivar as interrupcións:

cli(); // desactiva as interrupcións globais

Para activalas:

sei(); // activa as interrupcións

Isto afectará ao temporizador e á comunicación serie. A función delayMicroseconds() desactiva as interrupcións cando se executa.

#### Temporizadores

A función delayMicroseconds() crea o menor retardo posible da linguaxe Arduino que rolda os 2μs.

Para retardos mais pequenos débese utilizar a chamada de ensamblador 'nop' (non operación). Cada sentenza 'nop' executarase nun ciclo de máquina (16 Mhz): uns 62.5ns. Faríase da seguinte maneira:

\_\_asm\_\_("nop\n\t");

#### Manipulación de portos

A manipulación de portos con código AVR é mais rápida que utilizar a función digitalWrite() de Arduino.

#### Establecer bits en variables

cbi e sbi son mecanismos estándar (AVR) para establecer ou limpar bits en PORT e outras variables.

Será necesario utilizar as seguintes cabeceiras para poder utilizalos:

```
# ifndef cbi
# define cbi(sfr, bit) (\_SFR\_BYTE(sfr) &= \_BV(bit))
# endif
# ifndef sbi
# define sbi(sfr, bit) (\_SFR\_BYTE(sfr) |= \_BV(bit))
# endif

```

Para utilizalas hai que pasarlles como argumento a variable PORT e un pin para establecelo ou limpalo.

Grazas a estes pequenos hacks teremos a posibilidade de mellorar os tempos de execución de certas tarefas críticas ou daquelas que se repitan moitas veces obtendo mellores resultados. Non obstante o código fonte que escribamos resultará probablemente menos legible se os utilizamos polo que haberá que sopesalo en función das nosas necesidades.

### Diferenzas con Processing

A sintaxe da linguaxe de programación Arduino é unha versión simplificada de C/C++ e ten algunhas diferenzas respecto de Processing. Xa desde o punto de que Arduino esta baseado en C/C++ mentres que Processing baséase en Java. En canto á sintaxe de ambas as linguaxes e o modo en que se programan existen tamén varias diferenzas:

* **Arrays**

| Arduino | Processing |
| --- | --- |
| int bar[8];bar[0] = 1; | int[] bar = new int[8];bar[0] = 1; |
| int foo[] = { 0, 1, 2 }; | int foo[] = { 0, 1, 2 };ou benint[] foo = { 0, 1, 2 }; |

* **Bucles**

| Arduino | Processing |
| --- | --- |
| int i;for (i = 0; i < 5; i++) {... } | for (int i = 0; i < 5; i++) {... } |

* **Impresión de cadeas**

| Arduino | Processing |
| --- | --- |
| Serial.println("hello world"); | println("hello world"); |
| int i = 5;  Serial.println(i); | int i = 5;  println(i); |
| int i = 5;  Serial.print("i = ");  Serial.print(i);  Serial.println(); | int i = 5;  println("i = "+ i); |

As diferenzas son escasas polo que alguén que coñeza ben Processing terá moi poucos problemas á hora de programar en Arduino.

### Primeiro contacto: Ola Mundo en Arduino

O primeiro paso antes de comprobar que a instalación é correcta e empezar a traballar con Arduino é abrir algúns exemplos prácticos que veñen dispoñibles co dispositivo. É recomendable abrir o exemplo ?led\_blink? que atoparemos no menú File, Sketchbook, Examples, led\_blink. Este código crea unha intermitencia por segundo nun led conectado no pin 13. É cuestión de comprobar que o código é correcto, para iso, prememos o botón que é un triángulo (en forma de "play") e seguidamente faremos un "upload" (que é a frecha cara á dereita) para cargar o programa á placa. Se o led empeza a pestanexar, todo estará correcto.

Vexamos o código necesario para conseguilo:

```
# define LED\_PIN 13

void setup () {

 // Activamos o pin 13 para saída dixital

 pinMode (LED\_PIN, OUTPUT);

}

// Bucle infinito

void loop () {

 // Acendemos o led enviando un sinal alto

 digitalWrite (LED\_PIN, HIGH);

 // Esperamos un segundo (1000 ms)

 delay (1000);

 // Apagamos o led enviando un sinal baixo

 digitalWrite (LED\_PIN, LOW);

 // Esperamos un segundo (1000 ms)

 delay (1000);

}

```

A orde de execución será: Primeiro faise unha chamada á función init() que inicializa o programa, despois execútase a función setup() que configura diversos parámetros, e por último execútase un bucle while(1) que chama repetidamente á función loop. Todo iso execútase dentro de main() e podería indicarse explicitamente (no caso anterior encárgase o IDE de engadir o código que se ha omitido).

Bibliotecas en Arduino
----------------------

Para facer uso dunha biblioteca en Sketch (o IDE de Arduino), basta con facer clic sobre *"Import Library"* no menú, escoller unha biblioteca e engadirase o #include correspondente.

As bibliotecas estándar que ofrece Arduino son as seguintes:

### Serial

Lectura e escritura polo porto serie.

### EEPROM

Lectura e escritura no almacenamento permanente.

* read(), write()

### Ethernet

Conexión a Internet mediante *Arduino Ethernet Shield*. Pode funcionar como servidor que acepta peticións remotas ou como cliente. Permítense até catro conexións simultaneamente.

* Servidor: Server(), begin(), available(), write(), print(), println()
* Cliente: Client(), connected(), connect(), write(), print(), println(), available(), read(), flush(), stop()

### Firmata

Comunicación con aplicacións de computador utilizando o protocolo estándar do porto serie.

### LiquidCrystal

Control de LCDs con chipset Hitachi HD44780 ou compatibles. A biblioteca soporta os modos de 4 e 8 bits.

### Servo

Control de servo motores. A partir da versión 0017 de Arduino a biblioteca soporta até 12 motores na maioría de placas Arduino e 48 na Arduino Mega.

* attach(), write(), writeMicroseconds(), read(), attached(), detach()

O manexo da biblioteca é bastante sinxelo. Mediante attach(número de pin) engadimos un servo e mediante write podemos indicar os graos que queremos que teña o motor (habitualmente de 0 a 180).

### SoftwareSerial

Comunicación serie en pines dixitais. Por defecto Arduino inclúe comunicación só nos pines 0 e 1 pero grazas a esta biblioteca podemos realizar esta comunicación co resto de pines.

### Stepper

Control de motores paso a paso unipolares ou bipolares.

* Stepper(steps, pin1, pin2), Stepper(steps, pin1, pin2, pin3, pin4), setSpeed(rpm), step(steps)

O manexo é sinxelo. Basta con iniciar o motor mediante Stepper indicando os pasos que ten e os pines aos que esta asociado. Indícase a velocidade á que queiramos que vire en revolucións por minuto con setSpeed(rpm) e indícanse os pasos que queremos que avance con step(pasos).

### Wire

Envío e recepción de datos sobre unha rede de dispositivos ou sensores mediante Two Wire Interface (TWI/I2C).

Ademais as bibliotecas Matrix e Sprite de Wiring son totalmente compatibles con Arduino e serven para manexo de matrices de leds.

Tamén se ofrece información sobre diversas bibliotecas desenvolvidas por contribuidores diversos que permiten realizar moitas tarefas.

### Creación de bibliotecas

Ademais das bibliotecas base, as que son compatibles e as que achegaron outras persoas temos a posibilidade de escribir nosa propia biblioteca. Isto é moi interesante por varias razóns: permite dispor de código que pode reutilizarse noutros proxectos de forma cómoda; permítenos manter o código fonte principal separado das bibliotecas de forma que sexan mantenibles de forma separada; e a organización dos programas construídos é máis clara e elegante.

Vexamos un exemplo da creación dunha biblioteca que envía código Morse:

Creamos o ficheiro Morse.h que inclúe a definición da clase Morse que ten 3 funcións: un construtor (Morse()), unha función para enviar 1 punto (dot()) e unha función para enviar unha raia (dash()). A variable \_pin permite indicar o pin que imos utilizar.

```
/\*

 Morse.h - Library for flashing Morse code.

 Created by David A. Mellis, November 2, 2007.

 Released into the public domain.

\*/

# ifndef Morse\_h
# define Morse\_h
# include "WProgram.h"

class Morse

{

 public:

 Morse(int pin);

 void dot();

 void dash();

 private:

 int \_pin;

};
# endif

```

Ademais necesitaremos un ficheiro Morse.cpp co código das funcións declaradas. A continuación móstrase o código:

```
/\*

 Morse.cpp - Library for flashing Morse code.

 Created by David A. Mellis, November 2, 2007.

 Released into the public domain.

\*/

# include "WProgram.h"
# include "Morse.h"

Morse::Morse(int pin)

{

 pinMode(pin, OUTPUT);

 \_pin = pin;

}

void Morse::dot()

{

 digitalWrite(\_pin, HIGH);

 delay(250);

 digitalWrite(\_pin, LOW);

 delay(250);

}

void Morse::dash()

{

 digitalWrite(\_pin, HIGH);

 delay(1000);

 digitalWrite(\_pin, LOW);

 delay(250);

}

```

E con isto xa poderiamos utilizar a biblioteca mediante o correspondente #include. Se quixeramos enviar un SOS polo pin 13 bastaría con chamar a Morse(13) e executar

```
 morse.dot(); morse.dot(); morse.dot();
```

```
 morse.dash(); morse.dash(); morse.dash();
```

```
 morse.dot(); morse.dot(); morse.dot();
```

Instalación
-----------

### Windows

Interface da contorna de desenvolvemento Arduino S.Ou. Windows.
Para a instalación da placa Arduino no sistema operativo Windows convén seguir os seguintes pasos:

Coa placa desconectada:

* Descargar e instalar o Java Runtime Enviroment (J2RE).
* Descargar a última versión do IDE Arduino.

Nota: É recomendable descomprimir o ficheiro no directorio raíz (c:\) mantendo a estrutura orixinal.

* Entre todos os cartafol creados no directorio Arduino convén destacar as seguintes:

```
 c:\arduino-0012\hardware\bootloader:
```

Esta contén o software necesario para cargar o firmware no chip Atmega168, para traballar con Arduino. Só se utiliza se vos montastes vós mesmos a placa, ou no caso que se estragou o chip e comprásedes un novo.

```
 c:\arduino-0012\drivers:
```

Contén os drivers necesarios para o funcionamento da placa Arduino co PC con S.O. Windows: FTDI USB Drivers.

#### Instalar FTDI USB Drivers

Agora si, conectar a placa USB. Abrirase automaticamente o asistente de Windows para novo hardware atopado:

1. Seleccionar "Non polo momento" e premer "Seguinte".
2. Seleccionar "Instalar desde unha lista ou localización específica (avanzado)" e premer "Seguinte".
3. "Buscar o controlador máis adecuado nestas localizacións" preme "Examinar".Seleccionar o cartafol onde haxas descomprimido o driver e preme ?Seguinte?.

Se non houbo ningún problema o driver da placa estará instalado.

#### Abrir o IDE Arduino

Executamos o ficheiro Arduino.exe para abrir a interficie. Aquí configuramos o porto USB onde temos conectada a placa para empezar a traballar.

### GNU/Linux

Interface da contorna de desenvolvemento Arduino S.Ou. GNU/Linux.
Para instalar Arduino nun sistema GNU/Linux necesitamos os seguintes programas para resolver as dependencias:

* Sun Java runtime, jre.
* avr-gcc, compilador para a familia de microcontroladores avr de atmel.
* avr-libc, libc do compilador avr-gcc.

Para instalalos, podemos utilizar o xestor de paquetes ou o terminal de comandos:

```
 apt-get install sun-java5-jre gcc-avr avr-libc
```

Nalgunhas distribucións convén desinstalar, se non é necesario, o programa "brltty". Este encárgase de permitir o acceso ao terminal para persoas cegas a través dun dispositivo especial en braille.

```
 killall brltty
```

```
 apt-get remove brltty
```

Os dous síntomas deste problema son:

* Non aparece a opción `/dev/tty/USB0` no menú Tools, Serial Port.
* Se se observa o LED Rx da placa Arduino, este ilumínase de 3 a 5 veces cada 5 ó 6 segundos.

Por último, descargamos o framework de arduino. O descomprimimos no cartafol desexado e executámolo:

```
 ./arduino
```

Se todo ha ir ben xa o teremos en funcionamento.

### Mac

Dispoñible para 10.7 Lion ou superior. Debemos baixar o programa da páxina de Arduino e seguir as instrucións do instalador. Creará o acceso directo ao doc e permite instalar en aplicacións o programa.

Aplicacións
-----------

As aplicacións que nos ofrece Arduino son múltiples, e dependerá da nosa imaxinación. Mediante sensores podemos crear aplicacións sinxelas enfocadas á docencia para estudantes de electrónica, proxectos máis elaborados para a industria ou mesmo sistemas dirixidos simplemente ao lecer.

É moi utilizado tamén nas contornas artísticas para crear obras máis elaboradas, dada a súa facilidade de programación.

Equipo de desenvolvemento
-------------------------

O núcleo do equipo de desenvolvemento de Arduino esta formado por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, David Mellis e Nicholas Zambetti.

Pduino
------

Patch Pduino.
Pduino nace da fusión de Pure Data e Arduino. Ambos de Open Source permiten traballar o un do outro dunha maneira gráfica e intuitiva. Cargando o firmware de Pure Data (PD) á placa Arduino podemos acceder a ela mediante a linguaxe de programación gráfico. Pódese observar que temos todo o esquema físico da placa, cos portos, pines dixitais e analóxicos, entradas e saídas... nunha interface gráfica, grazas a PD.

Minibloq
--------

Minibloq screenshoot.
Minibloq é unha contorna gráfica de programación que pode xerar código nativo de Arduino e escribilo directamente na memoria flash da placa. Non necesita por tanto, nin dun firmware específico na placa Arduino nin de conexión en tempo de execución. Ten un modo onde permite visualizar o código xerado, o cal tamén pode ser copiado e pegado no Arduino-IDE, para os usuarios que tentan facer a pasaxe dunha ferramenta gráfica á programación en sintaxe C/C++. Minibloq é de uso libre e as súas fontes tamén están dispoñibles gratuitamente. Unha característica importante, é que pode correr tamén na XO (OLPC), mediante Wine.

Notas
-----

Minibloq + OLPC + Arduino.

1. ↑  "Interview with Casey Reas and Ben Fry".
2. ↑
3. 1 2  "Project homepage".
4. ↑  "Copia arquivada". Arquivado dende o orixinal o 06 de decembro de 2006. Consultado o 09 de xullo de 2012.
5. ↑  "Ars Electronica Archiv" (en alemán). Consultado o 18-02-2009. [*Ligazón morta*]
6. ↑  "Ars Electronica Archiv / ANERKENNUNG" (en alemán). Consultado o 18-02-2009. [*Ligazón morta*]
7. ↑  Chirgwin, Richard (2011-09-20). "Arduino to add ARM board this year". *The Register*. Consultado o September 20, 2011. Arduino [...] showed off the new version in time for the New York Maker’s Faire, with a 96 MHz clock speed, 256 KB of flash memory, 50 KB of SRAM, five SPI buses, two I2C interfaces, five UARTs and 16 12-bit analog interfaces.
8. ↑  "atmel.com". Arquivado dende o orixinal o 16 de outubro de 2019. Consultado o 27 de setembro de 2012.
9. ↑  atmel.com
10. ↑  "Interfacing Arduino to other languages", Proxecto Arduino.  Arquivado 24 de xullo de 2012 en Wayback Machine.
11. 1 2  "Language Reference (estendede)", Proxecto Arduino.
12. ↑  "Serial", Proxecto Arduino.
13. ↑  "Manipulación de portos", Proxecto Arduino.  Arquivado 09 de xullo de 2012 en Wayback Machine.
14. ↑  "AVR Code", Proxecto Arduino.  Arquivado 09 de xullo de 2012 en Wayback Machine.
15. ↑  "Arduino/Processing Language Comparison", Proxecto Arduino.  Arquivado 18 de xuño de 2012 en Wayback Machine.
16. ↑  "Processing Reference", Proxecto Processing.
17. ↑
18. ↑  "EEPROM Library", Proxecto Arduino.  Arquivado 11 de xullo de 2012 en Wayback Machine.
19. ↑  "Ethernet Library", Proxecto Arduino.  Arquivado 29 de xuño de 2012 en Wayback Machine.
20. ↑  "Firmata Library", Proxecto Arduino.  Arquivado 17 de xullo de 2012 en Wayback Machine.
21. ↑  "LiquidCrystal Library", Proxecto Arduino.  Arquivado 09 de xullo de 2012 en Wayback Machine.
22. ↑  "Servo Library", Proxecto Arduino.
23. ↑  "SoftwareSerial Library", Proxecto Arduino.  Arquivado 04 de xullo de 2012 en Wayback Machine.
24. ↑  "Stepper Library", Proxecto Arduino.  Arquivado 30 de xuño de 2012 en Wayback Machine.
25. ↑  "Wire Library", Proxecto Arduino.
26. ↑  "Writing a Library for Arduino", Proxecto Arduino.  Arquivado 30 de xuño de 2012 en Wayback Machine.

Véxase tamén
------------

|  |  |
| --- | --- |
|  | Wikimedia Commons ten máis contidos multimedia na categoría:  ***Arduino Modificar a ligazón no Wikidata*** |

### Bibliografía

* Oxer, Jonathan; Blemings, Hugh (28 de decembro de 2009). *Practical Arduino: Cool Projects for Open Source Hardware* (1ª ed.). Apress. p. 500. ISBN 1430224770. Arquivado dende o orixinal o 05 de decembro de 2010. Consultado o 09 de xullo de 2012.
* Nobre, Joshua (15 de xullo de 2009). *Programming Interactivity: A Designer's Guide to Processing, Arduino, and openFramework* (1ª ed.). Ou'Reilly Media. p. 768. ISBN 0596154143.
* Banzi, Massimo (24 de marzo de 2009). *Getting Started with Arduino* (1ª ed.). Make Books. p. 128. ISBN 0596155514. Arquivado dende o orixinal o 07 de outubro de 2011. Consultado o 09 de xullo de 2012.

### Outros artigos

* Wiring
* Processing
* Fritzing

### Ligazóns externas

* Sitio web Proxecto Arduino *(en inglés)*.
* Sitio web Proxecto Arduino (en español con menos contidos).
* Algúns proxectos con arduino paso a paso (exemplos con vídeos).
* DuinOS: Sistema operativo multitarea para Arduino desenvolvido por RobotGroupArquivado 10 de febreiro de 2013 en Wayback Machine.
* Recompilación de proxectos Arduino para facer en casa  *(en castelán)*.
* Contorna gráfica de programación para Arduino
* Scada para Arduino
* Arduino The Documentary (2010) Spanish HD vídeo en Vimeo sobre a historia de Arduino.

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q175957
* BNE: XX5232439
* BNF: 165329562
* FAST: 1892754
* GEC: 0522614
* GND: 7692236-4
* LCCN: sh2011005402
* MAG: 136501162
* NKC: ph809013
* SUDOC: 154841862

 |