Hola chicos, por si les sirve aquí les dejo un link donde muestran como hacer unos botones tactiles muy sencillos :). saludos

http://www.youtube.com/watch?v=zjZEEJaL-40

Serial Peripheral Interface (SPI)

Registrada por Motorola, es un protocolo serie para comunicarse con otros microcontroladores o periféricos, por ejemplo EEPROM, conversores A/D, y D/A, potenciometros digitales, etc, Permite la transmisión y la recepción simultanea de forma sincrónica, o sea es Full Duplex y Sincrónico. Intervienen dos o más nodos, uno de los cuales es el maestro y el resto son los esclavos, por lo que se considera Multipunto. se destaca por su simplicidad y normalmente la velocidad de comunicación no supero los 5Mbps. una se sus ventajas es la facilidad con que se realiza el aislamiento galvánico de sus líneas utilizando optoacopladores.

Intervienen 4 señales que son: Serial Data Out (DO o SDO), Serial Data In (DI o SDI), Serial Clock (CK) y Chip Select (CS) o Slave Select (SS), cuya forma de conexión se muestra en la Figura 1:

Figura 1.- Señales en el protocolo SPI, entre un Maestro y un Esclavo (a), o varios Esclavos (b).

El direccionamiento del esclavo se hace mediante la señal CS, por lo que tiene, una por esclavo. el Maestro genera la señal CK y controla las señales CS y DI, por lo que es el único que puede inicial la comunicación . la señal CK controla la velocidad de comunicación, permitiendo hacer pausas o tiempos de espera en la misma.

Es importante señalar que el SPI es un protocolo de intercambio de datos, por lo que se plantea que no existen dispositivos solamente transmisores o solamente receptores. Cuando se envía datos también se reciben datos, incluso si estos no son útiles a nuestra aplicación. los datos entrantes deben leerse antes de intentar transmitir nuevamente, sino se perderán. 

La señal CS activa o selecciona el dispositivo esclavo con el cual el maestro intercambiará datos. en caso de un solo esclavo el CS puede obviarse, aunque puede ser útil para provocar el reinicio del módulo SPI del esclavo.

Adentrandonos un poco más en los módulo SPI de estos dispositivos, posemos en la Figura 2, que el tener activo un esclavo se forma un lazo entre entre ambos dispositivos. Mientras que el maestro esta generando la señal de CK, se estarán desplazando los datos contenidos en cada registro y a su vez entre la salida de un registro y la entrada del otro. Es por ello que cada vez que se transmitan una cantidad de datos igual al tamaño del registro, se recibirá una cantidad igual que debe ser leída del búfer para no perderla. El búfer de datos también actúa como registro de escritura, y aal emplearlo como tal sobreescribimos su contenido.

Figura 2. Lazo entre dos dispositivos SPI

Si analizamos este proceso paso a paso, de forma general y cíclica, ocurriría como sigue:

1.- El maestro escribe en su búfer de datos.

2.- El maestro comienza a general CK y el esclavo escribe en su búfer de datos.

3.- El contenido del búfer del maestro se transfiere al registro de desplazamiento del maestro, y el del esclavo al registro de desplazamiento del esclavo.

4.- Maestro y esclavo intercambian una cantidad igual al tamaño de los registros de desplazamiento.

5.- El nuevo contenido de ambos registros de desplazamiento se transfiere a los respectivos búferes de datos.

6.- El dato es leído de los búferes de datos.

De esta misma forma se explica la conexión en cascada mostrada en la figura 3, que reduce notablemente la cantidad de líneas en el circuito impreso, pero que solo es posible con determinados dispositivos, por ejemplo potenciómetros digitales.

Figura 3.- Conexión en cascada de un Maestro y varios Esclavos

Normalmente los registros SPI son de 8 bits, aunque algunos dispositivos necesitan transmitir mayor cantidad de datos, en esos casos se realizan varias transferencias de 8 bits hasta completar todos los datos. Durante este tiempo al esclavo debe mantenerse activo.

Programación básica de arduino

La plataforma de programación de Arduino será la utilizada durante el curso de sensores y actuadores es por ello que es importante familiarizarse con el lenguaje de programación.

Funciones básicas y operadores

Arduino esta basado en C y soporta todas las funciones del estándar C y algunas de C++. A continuación se muestra un resumen con todas la estructura del lenguaje Arduino:

Sintaxis Básica

• Delimitadores: ;, {}
• Comentarios: //, /* */
• Cabeceras: #define, #include
• Operadores aritméticos: +, -, *, /, %
• Asignación: =
• Operadores de comparación: ==, !=, <, >, <=, >=
• Operadores Booleanos: &&, ||, !
• Operadores de acceso a punteros: *, &
• Operadores de bits: &, |, ^, ~, <<, >>
• Operadores compuestos:
  • Incremento/decremento de variables: ++, --
  • Asignación y operación: +=, -=, *=, /=, &=, |=

Estructuras de control

• Condicionales: if, if...else, switch case
• Bucles: for, while, do... while
• Bifurcaciones y saltos: break, continue, return, goto

Variables

En cuanto al tratamiento de las variables también comparte un gran parecido con el lenguaje C.

Constantes

• HIGH / LOW: niveles alto y bajo en pines. Los niveles altos son aquellos de 3 voltios o más.
• INPUT / OUTPUT: entrada o salida
• true / false

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 funciones reciben como argumento una variable de cualquier tipo y devuelven una variable convertida en el tipo deseado.

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

Cualificadores y ámbito de las variables

• static, volatile, const

Utilidades

• sizeof()

Funciones Básicas

En cuanto a las funciones básicas del lenguaje nos encontramos con las siguientes:

E/S Digital

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

E/S Analógica

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

E/S Avanzada

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

Tiempo

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

Matemáticas

• min(x, y), max(x, y), abs(x), constrain(x, a, b), map(valor, fromLow, fromHigh, toLow, toHigh), pow(base, exponente), sqrt(x)

Trigonometría

• sin(rad), cos(rad), tan(rad)

Números aleatorios

• randomSeed(semilla), long random(máx), long random(mín, máx)

Bits y Bytes

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

Interrupciones externas

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

Interrupciones

• interrupts(), noInterrupts()

Comunicación por puerto serie

Las funciones de manejo del puerto serie deben ir precedidas de "Serial." aunque no necesitan ninguna declaración en la cabecera del programa. Por esto se consideran funciones base del lenguaje.

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

Manipulación de puertos

Los registros de puertos permiten la manipulación a más bajo nivel y de forma más rápida de los pines de E/S del microcontrolador de las placas Arduino. Los pines de las placas Arduino están repartidos entre los registros B(0-7), C (analógicos) y D(8-13). Mediante las siguientes variables podemos ver y modificar su estado:

• DDR[B/C/D]: Data Direction Register (o dirección del registro de datos) del puerto B, C ó D. Sirve para especificar que pines queremos usar como de entrada y cuales de salida. Variable de Lectura/Escritura.
• PORT[B/C/D]: Data Register (o registro de datos) del puerto B, C ó D. Variable de Lectura/Escritura.
• PIN[B/C/D]: Input Pins Register (o registro de pines de entrada) del puerto B, C ó D. Variable de sólo lectura.

Por ejemplo, para especificar que queremos utilizar los pines 9 a 13 como salidas y el 8 como entrada (puesto que el puerto D usa los pines de la placa Arduino 8 al 13 digitales) bastaría utilizar la siguiente asignación:

 DDRD = B11111110;

Como se ha podido comprobar, si conocemos el lenguaje C, no tendremos dificultades para programar en Arduino puesto que se parecen enormemente. Tan sólo debemos aprender algunas funciones específicas de que dispone el lenguaje para manejar los diferentes parámetros de Arduino. Se pueden construir aplicaciones de cierta complejidad sin necesidad de muchos conceptos previos.

A.V.R. Libc

Los programas compilados con Arduino (salvo en las placas con CorteX M3) se enlazan contra AVR Libc por lo que tienen acceso a algunas de sus funciones. AVR Libc es un proyecto de software libre con el objetivo de proporcionar una  C de alta calidad para utilizarse con el compilador GCC sobre microcontroladores Atmel AVR. Se compone de 3 partes:

• avr-binutils
• avr-gcc
• avr-libc

La mayoría del lenguaje de programación Arduino está escrita con constantes y funciones de AVR y ciertas funcionalidades sólo se pueden obtener haciendo uso de AVR.

Interrupciones

Para desactivar las interrupciones:

 cli(); // desactiva las interrupciones globales

Para activarlas:

 sei(); // activa las interrupciones

Esto afectará al temporizador y a la comunicación serie. La función delayMicroseconds() desactiva las interrupciones cuando se ejecuta.

Temporizadores

La función delayMicroseconds() crea el menor retardo posible del lenguaje Arduino que ronda los 2μs.
Para retardos más pequeños se debe utilizar la llamada de ensamblador 'nop' (no operación). Cada sentencia 'nop' se ejecutará en un ciclo de máquina (16 Mhz): unos 62.5ns. Se haría de la siguiente manera:

 __asm__("nop\n\t");

Manipulación de puertos

La manipulación de puertos con código AVR es más rápida que utilizar la función digitalWrite() de Arduino.

Establecer Bits en variables

cbi y sbi son mecanismos estándar (AVR) para establecer o limpiar bits en PORT y otras variables.
Será necesario utilizar las siguientes cabeceras para poder utilizarlos:

# 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 utilizarlas hay que pasarles como argumento la variable PORT y un pin para establecerlo o limpiarlo.
Gracias a estos pequeños hacks tendremos la posibilidad de mejorar los tiempos de ejecución de ciertas tareas críticas o de aquellas que se repitan muchas veces obteniendo mejores resultados. No obstante el código fuente que escribamos resultará probablemente menos legible si los utilizamos por lo que habrá que sopesarlo en función de nuestras necesidades.

Primer contacto: Hola Mundo en Arduino

El primer paso antes de comprobar que la instalación es correcta y empezar a trabajar con Arduino es abrir algunos ejemplos prácticos que vienen disponibles con el dispositivo. Es recomendable abrir el ejemplo “led_blink” que encontraremos en el menú File, Sketchbook, Examples, led_blink. Este código crea una intermitencia por segundo en un led conectado en el pin 13. Es cuestión de comprobar que el código es correcto, para eso, presionamos el botón que es un triángulo (en forma de "play") y seguidamente haremos un "upload" (que es la flecha hacia la derecha) para cargar el programa a la placa. Si el led empieza a parpadear, todo estará correcto.
Veamos el código necesario para conseguirlo:

# define LED_PIN 13void setup () {
 // Activamos el pin 13 para salida digital
 pinMode (LED_PIN, OUTPUT);}// Bucle infinitovoid loop () {
 // Encendemos el led enviando una señal alta
 digitalWrite (LED_PIN, HIGH);
 // Esperamos un segundo (1000 ms)
 delay (1000);
 // Apagamos el led enviando una señal baja
 digitalWrite (LED_PIN, LOW);
 // Esperamos un segundo (1000 ms)
 delay (1000);}

El orden de ejecución será: Primero se hace una llamada a la función init() que inicializa el programa, después se ejecuta la función setup() que configura diversos parámetros, y por último se ejecuta un bucle while(1) que llama repetidamente a la función loop. Todo ello se ejecuta dentro de main() y podría haberse indicado explícitamente (en el caso anterior se encarga el IDE de añadir el código que se ha omitido).

Bibliotecas en Arduino

Para hacer uso de una biblioteca en Sketch (el IDE de Arduino), basta con hacer clic sobre “Import Library” en el menú, escoger una biblioteca y se añadirá el #include correspondiente. Las bibliotecas estándar que ofrece Arduino son las siguientes:

Serial

Lectura y escritura por el puerto serie.

EEPROM

Lectura y escritura en el almacenamiento permanente.

• read(), write()

Ethernet

Conexión a Internet mediante “Arduino Ethernet Shield“. Puede funcionar como servidor que acepta peticiones remotas o como cliente. Se permiten hasta cuatro conexiones simultaneas.

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

Firmata

Comunicación con aplicaciones de ordenador utilizando el protocolo estándar del puerto serie.

LiquidCrystal

Control de LCDs con chipset Hitachi HD44780 o compatibles. La biblioteca soporta los modos de 4 y 8 bits.

Servo

Control de servo motores. A partir de la versión 0017 de Arduino la biblioteca soporta hasta 12 motores en la mayoría de placas Arduino y 48 en la Arduino Mega.

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

El manejo de la biblioteca es bastante sencillo. Mediante attach(número de pin) añadimos un servo y mediante write podemos indicar los grados que queremos que tenga el motor (habitualmente de 0 a 180).

SoftwareSerial

Comunicación serie en pines digitales. Por defecto Arduino incluye comunicación sólo en los pines 0 y 1 pero gracias a esta biblioteca podemos realizar esta comunicación con el resto de pines.

Stepper

Control de motores paso a paso unipolares o bipolares.

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

El manejo es sencillo. Basta con iniciar el motor mediante Stepper indicando los pasos que tiene y los pines a los que esta asociado. Se indica la velocidad a la que queramos que gire en revoluciones por minuto con setSpeed(rpm) y se indican los pasos que queremos que avance con step(pasos).

Wire

Envío y recepción de datos sobre una red de dispositivos o sensores mediante Two Wire Interface (TWI/I2C).
Además las bibliotecas Matrix y Sprite de Wiring son totalmente compatibles con Arduino y sirven para manejo de matrices de leds.
También se ofrece información sobre diversas bibliotecas desarrolladas por contribuidores diversos que permiten realizar muchas tareas.

Creación de biblioteca

Además de las bibliotecas base, las que son compatibles y las que han aportado otras personas tenemos la posibilidad de escribir nuestra propia biblioteca.Esto es muy interesante por varias razones: permite disponer de código que puede reutilizarse en otros proyectos de forma cómoda; nos permite mantener el código fuente principal separado de las bibliotecas de forma que sean mantenibles de forma separada; y la organización de los programas construidos es más clara y elegante.
Veamos un ejemplo de la creación de una biblioteca que envía código Morse:
Creamos el fichero Morse.h que incluye la definición de la clase Morse que tiene 3 funciones: un constructor (Morse()), una función para enviar 1 punto (dot()) y una función para enviar una raya (dash()). La variable _pin permite indicar el pin que vamos a 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

Además necesitaremos un fichero Morse.cpp con el código, es decir con la implementación de los métodos declarados:

/*
  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);}

Y con esto ya podríamos utilizar la biblioteca mediante el correspondietne #include. Si quisieramos enviar un SOS por el pin 13 bastaría con llamar a Morse(13) y ejecutar

 morse.dot(); morse.dot(); morse.dot();
 morse.dash(); morse.dash(); morse.dash();
 morse.dot(); morse.dot(); morse.dot();

La plataforma arduino incluye algunos ejemplos demostrativos los cuales ayudan al usuario a familiarizarse con el lenguaje, en el siguiente enlace se encuentran los diferentes ejemplos que se encuentran en diche plataforma
http://arduino.cc/es/Tutorial/HomePage

Teensy 3.0

El Teensy 3.0 de PJRC es increíblemente pequeño: 3.5 x 1.7 cm solamente. Pero es muy potente con un procesador ARM Cortex M4 48 MHz MK20DX128 microcontrolador de 32 bits con 128 KB de Flash y 16 KB de RAM. 

Esta placa fue financiada a través de un proyecto KickStarte.

Placa de la Teensy 3.0

El entorno de desarrollo integrado o IDE se deriva de Arduino 1.0 y se ejecuta en Windows, Mac OS X o Linux. En realidad, el IDE es el IDE Arduino con un directorio adicional para las tarjetas Teensy. 
La junta Teensy 3.0 con el apoyo de la plantilla Xcode embedXcode.

(Interfaz de programación del Teensy 3.0)

La carga utiliza una utilidad adicional con una interfaz amigable, llamada Teensyduino.

¿Por qué utilizar Teensy 3.0?

En primer lugar, Teensy 3.0 se trata de llevar mucho más capacidad para el entorno Arduino, a un precio muy asequible, y en un tamaño más pequeño que funciona muy bien para diferentes proyectos. Numerosas placas ARM de 32 bits han aparecido en el mercado en el último año, pero la mayoría son muy difíciles de usar, o sólo funcionan con el software muy caro. Teensyduino apoyará a Teensy 3.0 de Arduino, que se ejecuta en Windows, Macintosh y Linux, con la misma facilidad de uso como Teensy 2.0.

Un procesador de 32 bits y más memoria son sólo el comienzo de los beneficios de hardware Teensy 3.0. El chip tiene un convertidor A / D de 16 bits (13 bits son utilizables), para una mejor resolución de entrada analógica que cualquier placa Arduino compatibles. Hay una interfaz I ² S, que puede ser utilizado para conectar dispositivos de audio digital juntos.

Además de 10 pines con capacidad PWM, el chip cuenta con 4 temporizadores y 4 temporizadores de retardo, que no entran en conflicto con los canales de PWM, lo que abre la posibilidad para que las bibliotecas que logren sus características especiales de tiempo sin desactivar los pines PWM, como es común con casi todas las librerías de Arduino hoy.

Las características del puerto USB dedicado DMA (acceso directo a memoria).Teensyduino proporcionará una pila USB que aprovecha esta característica para permitir una mejor utilización USB. También hay otros 4 canales DMA que pueden ser utilizados por los demás periféricos, para permitir la transferencia de datos rápida y sin alentar la CPU. No sólo es el procesador más rápido y 32 bits, si no que cuenta con periféricos de mayor ancho de banda los cuales son mucho más eficientes.

Como una plataforma independiente, o junto con un ordenador portátil o Raspberry Pi (donde Teensy 3.0 maneja momento crítico de E / S y las señales analógicas), Teensy 3.0 tiene por objeto permitir a todo tipo de proyectos de electrónica, con excepcional facilidad de uso, y a un precio muy asequible.

Especificaciones Téncicas:

• 32 Arm Cortex-M4 48 bits CPU MHz (M4=DSP extensiones).
• Memoria Flash 128K, 16K RAM, EEPROM 2K.
• *14 entradas analógicas de alta resolución (13 bits, 16 bits Hardware usables).
• *34 pines E/S digitales (10 compartido con entradas analógicas).
• 10 salidas PWM.
• 8 Temporizadoes de intervalor /retrasos, separadas de los PWM
• USB con memoria de transferencia DMA
•  3 UART (puerto serie).
• SPI, I2C, I2S, IR modulador.
• I2S (para la interfaz de audio de alta calidad).
• Reloj en tiempo real.
• 4 canales DMA para fines generales (separada de USB).
• Entradas para sensores Touch.

(Pinout del Teensy 3.0)

Todos los pines tienen capacidad de interrupción.

* 14 pines Analógico / Digital y sólo 10 son accesibles por el exterior de Teensy 3.0, y está disponible cuando se utiliza en un circuito. 10 pins de entrada solo Digital, y 4 pines más sólo de entrada analógica.

El chip principal es "Kinetis" K-series PK20DX128VLH5 de Freescale (primer grupo) o MK20DX128VLH5 (posteriores lotes). Freescale ha confirmado la matriz de silicio no se ha modificado, sólo un movimiento de bajo volumen de pruebas de alto volumen se denota por "PK" a "MK".