Tomador de fotos múltiples automático (estilo Photobooth) (8 / 10 paso)

Paso 8: El código de Arduino

Nuestra clase tenía algunos códigos separados de Arduino para hacer las cosas más fácil para ciertos comandos.
Conservar estas en archivo de la biblioteca:

-------------------------------
Wire.h
-------------------------------
/*
TwoWire.h - biblioteca de TWI/I2C Arduino & cableado
Copyright (c) 2006 Nicholas Zambetti. Todos los derechos reservados.

Esta biblioteca es software libre; Usted puede redistribuirlo y/o
modificar bajo los términos de la GNU menor General pública
Licencia publicada por la Free Software Foundation; cualquiera de los dos
versión 2.1 de la licencia o (a su opción) cualquier versión posterior.

Esta biblioteca se distribuye con la esperanza de que sea útil,
pero sin ninguna garantía; ni siquiera la garantía implícita de
COMERCIABILIDAD o aptitud para un propósito PARTICULAR. Ver la GNU
Lesser General Public License para más detalles.

Usted debe han recibido una copia de la GNU menor General pública
Licencia junto con esta biblioteca; Si no, escriba a la Free Software
Foundation, Inc., 51 Franklin St, quinto piso, Boston, MA 02110-1301 USA

2012 modificado por Todd Krein (todd implementar arranques repetidos
*/

#ifndef TwoWire_h
#define TwoWire_h

#include
#include "Stream.h"

#define BUFFER_LENGTH 32

clase bifilar: flujo de público
{
privado:
estática uint8_t [de rxBuffer];
rxBufferIndex de uint8_t estática;
rxBufferLength de uint8_t estática;

txAddress de uint8_t estática;
estática uint8_t [de txBuffer];
txBufferIndex de uint8_t estática;
txBufferLength de uint8_t estática;

transmisión de uint8_t estática;
Static void (* user_onRequest)(void);
Static void (* user_onReceive)(int);
Static void onRequestService(void);
Static void onReceiveService (uint8_t *, int);
público:
TwoWire();
begin() vacío;
void begin(uint8_t);
void begin(int);
void beginTransmission(uint8_t);
void beginTransmission(int);
endTransmission(void) de uint8_t;
endTransmission(uint8_t) de uint8_t;
requestFrom de uint8_t (uint8_t, uint8_t);
requestFrom de uint8_t (uint8_t, uint8_t, uint8_t);
requestFrom de uint8_t (int, int);
requestFrom de uint8_t (int, int, int);
size_t virtual write(uint8_t);
escritura virtual size_t (uint8_t const *, size_t);
virtual int available(void);
virtual int read(void);
virtual int peek(void);
virtual void flush(void);
void onReceive (void (*)(int));
void onRequest (void (*)(void));

size_t en línea escriba (sin firmar largo n) {vuelta write((uint8_t)n);}
en línea size_t escritura (tiempo n) {return write((uint8_t)n);}
en línea size_t escribir (unsigned int n) {vuelta write((uint8_t)n);}
en línea size_t write(int n) {return write((uint8_t)n);}
utilizando Print::write;
};

externo cable bifilar;

-----------------------------
Adafruit_MCP2307.h
-----------------------------
/***************************************************
Esta es una librería para el expansor de puertos i2c MCP23017

Estas pantallas utilizan I2C para comunicar, 2 pins están obligados a
interfaz de
Adafruit invierte tiempo y recursos que este código de fuente abierto,
por favor apoye Adafruit y hardware de código abierto mediante la compra de
productos de Adafruit.

Escrito por Limor Fried/Ladyada para industrias Adafruit.
La licencia BSD, todo el texto anterior debe incluirse en cualquier redistribución
****************************************************/

#include
#include
#include "Adafruit_MCP23017.h"

#if ARDUINO > = 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

minihelper
Static inline void wiresend(uint8_t x) {}
#if ARDUINO > = 100
Wire.Write((uint8_t)x);
#else
Wire.Send(x);
#endif
}

en línea estática uint8_t wirerecv(void) {}
#if ARDUINO > = 100
volver Wire.read();
#else
volver Wire.receive();
#endif
}

////////////////////////////////////////////////////////////////////////////////

void Adafruit_MCP23017::begin (uint8_t addr) {}
Si (addr > 7) {}
addr = 7;
}
i2caddr = addr;

Wire.Begin();

establecer valores predeterminados!
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_IODIRA);
wiresend(0xFF); todas las entradas en Puerto A
Wire.endTransmission();

Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_IODIRB);
wiresend(0xFF); todas las entradas en el puerto B
Wire.endTransmission();
}

void Adafruit_MCP23017::begin(void) {}
begin(0);
}

void Adafruit_MCP23017::pinMode (uint8_t p, uint8_t d) {}
iodir uint8_t;
iodiraddr de uint8_t;

solamente 16 pedacitos!
Si (p > 15)
retorno;

Si (p < 8)
iodiraddr = MCP23017_IODIRA;
Else {}
iodiraddr = MCP23017_IODIRB;
-p = 8;
}

leer el actual IODIR
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(iodiraddr);
Wire.endTransmission();

Wire.requestFrom (MCP23017_ADDRESS | i2caddr, 1);
iodir = wirerecv();

configurar el pin y la dirección
Si (d == entrada) {}
iodir | = 1 << p;
} else {}
iodir & = ~ (1 << p);
}

Escriba el nuevo IODIR
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(iodiraddr);
wiresend(iodir);
Wire.endTransmission();
}

uint16_t Adafruit_MCP23017::readGPIOAB() {}
ba uint16_t = 0;
uint8_t;

leer los seguros actuales de salida GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_GPIOA);
Wire.endTransmission();

Wire.requestFrom (MCP23017_ADDRESS | i2caddr, 2);
un = wirerecv();
BA = wirerecv();
BA << = 8;
BA | = a;

volver ba;
}

void Adafruit_MCP23017::writeGPIOAB (uint16_t ba) {}
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_GPIOA);
wiresend (ba & 0xFF);
wiresend (ba >> 8);
Wire.endTransmission();
}

void Adafruit_MCP23017::digitalWrite (uint8_t p, uint8_t d) {}
gpio de uint8_t;
uint8_t gpioaddr, olataddr;

solamente 16 pedacitos!
Si (p > 15)
retorno;

Si (p < 8) {}
olataddr = MCP23017_OLATA;
gpioaddr = MCP23017_GPIOA;
} else {}
olataddr = MCP23017_OLATB;
gpioaddr = MCP23017_GPIOB;
-p = 8;
}

leer los seguros actuales de salida GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(olataddr);
Wire.endTransmission();

Wire.requestFrom (MCP23017_ADDRESS | i2caddr, 1);
GPIO = wirerecv();

configurar el pin y la dirección
Si (d == HIGH) {}
GPIO | = 1 << p;
} else {}
GPIO & = ~ (1 << p);
}

Escriba el nuevo GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gpioaddr);
wiresend(GPIO);
Wire.endTransmission();
}

void Adafruit_MCP23017::pullUp (uint8_t p, uint8_t d) {}
gppu de uint8_t;
gppuaddr de uint8_t;

solamente 16 pedacitos!
Si (p > 15)
retorno;

Si (p < 8)
gppuaddr = MCP23017_GPPUA;
Else {}
gppuaddr = MCP23017_GPPUB;
-p = 8;
}

leer el conjunto actual de resistencia de pullup
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gppuaddr);
Wire.endTransmission();

Wire.requestFrom (MCP23017_ADDRESS | i2caddr, 1);
gppu = wirerecv();

configurar el pin y la dirección
Si (d == HIGH) {}
gppu | = 1 << p;
} else {}
gppu & = ~ (1 << p);
}

Escriba el nuevo GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gppuaddr);
wiresend(gppu);
Wire.endTransmission();
}

{de uint8_t (uint8_t p) de Adafruit_MCP23017::digitalRead
gpioaddr de uint8_t;

solamente 16 pedacitos!
Si (p > 15)
return 0;

Si (p < 8)
gpioaddr = MCP23017_GPIOA;
Else {}
gpioaddr = MCP23017_GPIOB;
-p = 8;
}

leer el actual GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gpioaddr);
Wire.endTransmission();

Wire.requestFrom (MCP23017_ADDRESS | i2caddr, 1);
volver (wirerecv() >> p) & 0 x 1;
}

------------------------------------
Adafruit_RGBLCDShield.h
------------------------------------
/***************************************************
Esta es una librería para el protector de LCD de Adafruit RGB 16 x 2
Uno recoger en la tienda de Adafruit.
---> http://http :// www.adafruit.com/products/714

El escudo utiliza I2C para comunicar, 2 pins están obligados a
interfaz de
Adafruit invierte tiempo y recursos que este código de fuente abierto,
por favor apoye Adafruit y hardware de código abierto mediante la compra de
productos de Adafruit.

Escrito por Limor Fried/Ladyada para industrias Adafruit.
La licencia BSD, todo el texto anterior debe incluirse en cualquier redistribución
****************************************************/

#include "Adafruit_RGBLCDShield.h"

#include
#include
#include
#include

#if ARDUINO > = 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

Cuando la pantalla se enciende, se configura como sigue:
//
// 1. Mostrar la clara
// 2. Conjunto de la función:
DL = 1; interfaz de 8 bits de datos
N = 0; 1-línea de la pantalla
F = 0; fuente de carácter de 5 x 8 puntos
// 3. Pantalla de encendido:
D = 0; La exhibición de
C = 0; Cursor apagado
B = 0; Parpadeo de
// 4. Conjunto de modo de entrada:
I / D = 1; Incremento por 1
S = 0; Hay un cambio
//
Observe, sin embargo, que el Arduino no reajustando el LCD, así
no puede asumir que sus en ese estado cuando se inicia un dibujo (y el
RGBLCDShield se llama constructor).

{Adafruit_RGBLCDShield::Adafruit_RGBLCDShield()}
_i2cAddr = 0;

_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;

los pines de I/O expander
_rs_pin = 15;
_rw_pin = 14;
_enable_pin = 13;
_data_pins [0] = 12; realmente d4
_data_pins [1] = 11; realmente d5
_data_pins [2] = 10; realmente d6
_data_pins [3] = 9; realmente d7

_button_pins [0] = 0;
_button_pins [1] = 1;
_button_pins [2] = 2;
_button_pins [3] = 3;
_button_pins [4] = 4;
no podemos begin() aún :(
}

void Adafruit_RGBLCDShield::init (fourbitmode de uint8_t uint8_t rs, rw uint8_t, uint8_t habilitar,
uint8_t d0, d1 uint8_t, uint8_t d2, d3 uint8_t,
uint8_t d4, d5 uint8_t, uint8_t d6, d7 de uint8_t)
{
_rs_pin = rs;
_rw_pin = rw;
_enable_pin = habilitar;

_data_pins [0] = d0;
_data_pins [1] = d1;
_data_pins [2] = d2;
_data_pins [3] = d3;
_data_pins [4] = d4;
_data_pins [5] = d5;
_data_pins [6] = d6;
_data_pins [7] = d7;

_i2cAddr = 255;

_pinMode (_rs_pin, salida);
podemos ahorrar 1 pin por no usar RW. Indicar al pasar de 255 en lugar de pin #
Si (_rw_pin! = 255) {}
_pinMode (_rw_pin, salida);
}
_pinMode (_enable_pin, salida);

Si (fourbitmode)
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
otra cosa
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;

comenzar (16, 1);
}

void Adafruit_RGBLCDShield::begin (uint8_t cols, líneas de uint8_t, uint8_t dotsize) {}
Compruebe si i2c
Si (_i2cAddr! = 255) {}
_i2c.Begin(_i2cAddr);
Wire.Begin();
_i2c.Begin();

_i2c.pinMode (8, salida);
_i2c.pinMode (6, salida);
_i2c.pinMode (7, salida);
setBacklight(0x7);

Si (_rw_pin)
_i2c.pinMode (_rw_pin, salida);

_i2c.pinMode (_rs_pin, salida);
_i2c.pinMode (_enable_pin, salida);
para (uint8_t i = 0; i < 4; i ++)
_i2c.pinMode (_data_pins [i], salida);

para (uint8_t i = 0; i < 5; i ++) {}
_i2c.pinMode (_button_pins [i], entrada);
_i2c.pullUp (_button_pins [i], 1);
}
}

Si (líneas > 1) {}
_displayfunction | = LCD_2LINE;
}
_numlines = líneas;
_currline = 0;

algunas pantallas de la 1 línea se puede seleccionar una fuente alta de 10 píxeles
Si ((dotsize! = 0) & & (líneas == 1)) {}
_displayfunction | = LCD_5x10DOTS;
}

VEA PÁGINA 45/46 FOR INICIALIZACIÓN ESPECIFICACIÓN!
según hoja de datos, necesitamos por lo menos de 40ms después de energía se eleva por encima de 2.7V
antes de enviar comandos. Arduino puede activar modo befer 4.5V para esperaremos 50
delayMicroseconds(50000);
Ahora tiramos RS y R/W baja iniciar comandos
_digitalWrite (_rs_pin, bajo);
_digitalWrite (_enable_pin, bajo);
Si (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, bajo);
}

pone el LCD en modo de 4 bits o de 8 bits
if (!. (_displayfunction & LCD_8BITMODE)) {
Esto es de acuerdo a la hitachi HD44780 datasheet
Figura 24, pg 46

nos inicia en modo de 8 bits, trate de ajustar el modo de 4 bits
write4bits(0x03);
delayMicroseconds(4500); espera min 4.1ms

segundo intento
write4bits(0x03);
delayMicroseconds(4500); espera min 4.1ms

tercero ir!
write4bits(0x03);
delayMicroseconds(150);

Finalmente, se establece en la interfaz de 8 bits
write4bits(0x02);
} else {}
Esto es de acuerdo a la hitachi HD44780 datasheet
Figura página 45 23

Enviar función conjunto de secuencia de comandos
Command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(4500); esperar más de 4.1ms

segundo intento
Command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(150);

en tercer lugar ir
Command(LCD_FUNCTIONSET | _displayfunction);
}

por último, establecer líneas de #, tamaño de fuente, etc..
Command(LCD_FUNCTIONSET | _displayfunction);

encender la pantalla sin cursor ni parpadeando por defecto
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
Display();

claro de
Clear();

Inicializar a la dirección por defecto del texto (para lenguas romances)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
establecer el modo de entrada
Command(LCD_ENTRYMODESET | _displaymode);

}

/ *** comandos de alto niveles, para el usuario! */
void Adafruit_RGBLCDShield::clear()
{
Command(LCD_CLEARDISPLAY); borrar pantalla, establecer la posición del cursor a cero
delayMicroseconds(2000); Este comando toma mucho tiempo!
}

void Adafruit_RGBLCDShield::home()
{
Command(LCD_RETURNHOME); establecer la posición del cursor a cero
delayMicroseconds(2000); Este comando toma mucho tiempo!
}

void Adafruit_RGBLCDShield::setCursor (uint8_t col, fila de uint8_t)
{
int row_offsets [] = {0 x 00, 0 x 40, 0x14, 0x54};
Si (fila > _numlines) {}
fila = _numlines-1; contar filas a partir de w/0
}

Command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

Gire a la pantalla de encendido/apagado (rápidamente)
void Adafruit_RGBLCDShield::noDisplay() {}
_displaycontrol & = ~ LCD_DISPLAYON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void Adafruit_RGBLCDShield::display() {}
_displaycontrol | = LCD_DISPLAYON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

Convierte el cursor de subrayado de encendido/apagado
void Adafruit_RGBLCDShield::noCursor() {}
_displaycontrol & = ~ LCD_CURSORON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void Adafruit_RGBLCDShield::cursor() {}
_displaycontrol | = LCD_CURSORON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

Encender y apagar el cursor parpadeante
void Adafruit_RGBLCDShield::noBlink() {}
_displaycontrol & = ~ LCD_BLINKON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void Adafruit_RGBLCDShield::blink() {}
_displaycontrol | = LCD_BLINKON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

Estos comandos desplazarse la pantalla sin cambiar el RAM
void Adafruit_RGBLCDShield::scrollDisplayLeft(void) {}
Command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void Adafruit_RGBLCDShield::scrollDisplayRight(void) {}
Command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

Esto es para el texto que fluye de izquierda a derecha
void Adafruit_RGBLCDShield::leftToRight(void) {}
_displaymode | = LCD_ENTRYLEFT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Esto es para el texto que fluye de derecha a izquierda
void Adafruit_RGBLCDShield::rightToLeft(void) {}
_displaymode & = ~ LCD_ENTRYLEFT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Este 'derecho justifique' texto desde el cursor
void Adafruit_RGBLCDShield::autoscroll(void) {}
_displaymode | = LCD_ENTRYSHIFTINCREMENT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Esta voluntad 'izquierda justificar' texto desde el cursor
void Adafruit_RGBLCDShield::noAutoscroll(void) {}
_displaymode & = ~ LCD_ENTRYSHIFTINCREMENT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Nos permite completar los 8 primeros lugares de CGRAM
con caracteres personalizados
void Adafruit_RGBLCDShield::createChar (uint8_t ubicación, uint8_t charmap[]) {}
Ubicación & = 0x7; sólo tenemos 8 ubicaciones 0-7
Command(LCD_SETCGRAMADDR | (ubicación << 3));
para (int i = 0; i < 8; i ++) {}
Write(charmap[i]);
}
Command(LCD_SETDDRAMADDR); Desafortunadamente, se restablece la ubicación 0,0
}

/ *** mediados comandos de nivel, para el envío de datos/cmds * /

Inline void Adafruit_RGBLCDShield::command (uint8_t valor) {}
enviar (valor bajo);
}

#if ARDUINO > = 100
en línea size_t Adafruit_RGBLCDShield::write (uint8_t valor) {}
enviar (valor, HIGH);
retorno 1;
}
#else
Inline void Adafruit_RGBLCDShield::write (uint8_t valor) {}
enviar (valor, HIGH);
}
#endif

/ *** datos de nivel bajo empujando comandos *** /

pequeño contenedor para la entrada-salida escribe
void Adafruit_RGBLCDShield::_digitalWrite (uint8_t p, uint8_t d) {}
Si (_i2cAddr! = 255) {}
un comando i2c
_i2c.digitalWrite (p, d);
} else {}
straightup IO
digitalWrite (p, d);
}
}

Permite para ajustar la luz de fondo, si se usa la mochila de LCD
void Adafruit_RGBLCDShield::setBacklight (uint8_t status) {}
Compruebe si i2c o SPI
_i2c.digitalWrite (8, ~ (estado >> 2) & 0 x 1);
_i2c.digitalWrite (7, ~ (estado >> 1) & 0 x 1);
_i2c.digitalWrite (6, ~ estado & 0 x 1);
}

pequeño contenedor para direcciones de entrada-salida
void Adafruit_RGBLCDShield::_pinMode (uint8_t p, uint8_t d) {}
Si (_i2cAddr! = 255) {}
un comando i2c
_i2c.pinMode (p, d);
} else {}
straightup IO
pinMode (p, d);
}
}

escribir comandos o datos, con selección automática de 4/8 bits
void Adafruit_RGBLCDShield::send (valor de uint8_t, uint8_t modo) {}
_digitalWrite (_rs_pin, modo);

Si hay un pin RW indicado, ajustado bajo escritura
Si (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, bajo);
}

Si (_displayfunction & LCD_8BITMODE) {}
write8bits(Value);
} else {}
write4bits (valor >> 4);
write4bits(Value);
}
}

void Adafruit_RGBLCDShield::pulseEnable(void) {}
_digitalWrite (_enable_pin, bajo);
delayMicroseconds(1);
_digitalWrite (_enable_pin, HIGH);
delayMicroseconds(1); activar pulso debe ser > 450ns
_digitalWrite (_enable_pin, bajo);
delayMicroseconds(100); necesidad de comandos > 37us para resolver
}

void Adafruit_RGBLCDShield::write4bits (uint8_t valor) {}
Si (_i2cAddr! = 255) {}
uint16_t a = 0;

a = _i2c.readGPIOAB();

acelerar para i2c desde su lenta
para (int i = 0; i < 4; i ++) {}
out & = ~ _BV(_data_pins[i]);
a | = ((valor >> i) & 0 x 1) << _data_pins [i];
}

Asegúrese de que habilitar está bajo
out & = ~ _BV(_enable_pin);

_i2c.writeGPIOAB(out);

pulso activar
delayMicroseconds(1);
a | = _BV(_enable_pin);
_i2c.writeGPIOAB(out);
delayMicroseconds(1);
out & = ~ _BV(_enable_pin);
_i2c.writeGPIOAB(out);
delayMicroseconds(100);

} else {}
para (int i = 0; i < 4; i ++) {}
_pinMode (_data_pins [i], salida);
_digitalWrite (_data_pins [i], (valor >> i) & 0 x 01);
}
pulseEnable();
}
}

void Adafruit_RGBLCDShield::write8bits (uint8_t valor) {}
para (int i = 0; i < 8; i ++) {}
_pinMode (_data_pins [i], salida);
_digitalWrite (_data_pins [i], (valor >> i) & 0 x 01);
}

pulseEnable();
}

uint8_t Adafruit_RGBLCDShield::readButtons(void) {}
respuesta de uint8_t = 0x1F;

para (uint8_t i = 0; i < 5; i ++) {}
respuesta & = ~((_i2c.digitalRead(_button_pins[i])) << i);
}
volver a contestar;
}

----------------------------------------
Código de photobooth (este es el que va realmente a utilizar)
----------------------------------------

#include
#include
#include

Lcd de Adafruit_RGBLCDShield = Adafruit_RGBLCDShield();

Establecer color de fondo
#define rojo 0 x 1
#define amarillo 0x3
#define verde 0 x 2
#define verde azulado 0x6
#define azul 0x4
#define violeta 0x5
#define blanco 0x7

int shutterPin = 5; 5 digital que se conecta al obturador de la cámara
pirPin int = 6; 6 digital
int intMotion = 0;
int intNoMotion = 0;

greenLED int = 11;
blueLED int = 10;
int rojo = 13;

buttonselect Boolean;

void setup() {}
Serial.Begin(9600);
pinMode (pirPin, entrada);
LCD.Begin (16, 2);
int hora = millis();
tiempo = millis() - tiempo;

pinMode (greenLED, salida);
pinMode (blueLED, salida);
pinMode (rojo, salida);
pinMode (shutterPin, salida);
}

void loop() {}
botones de uint8_t = lcd.readButtons();
pirVal int = digitalRead(pirPin);

if(pirVal == Low) {//was movimiento detectado
Serial.println ("movimiento detectado");
Delay(1000);
intMotion = intMotion + 1;
if(intMotion>3) {}
lcd.setBacklight(VIOLET);
lcd.setCursor (0, 0);
LCD.Print ("cámara de CHLOE");
lcd.setCursor (0,1);
LCD.Print ("tomar una foto!");
Delay(2000);
lcd.setCursor(0,0);
LCD.Print ("SELECT foto!");
lcd.setCursor(0,1);
LCD.Print ("para arriba para salto!");
Delay(3000);
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("izquierda: derecho 2: 4");
lcd.setCursor(0,1);
LCD.Print ("abajo: 3 fotos:)" ");
Delay(1000);
}
}

Si {} (botones)
LCD.Clear();
lcd.setCursor(0,0);
Seleccione botón--> toma 1 foto
Si (botones & BUTTON_SELECT) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("tomar una foto!");
lcd.setBacklight(YELLOW);
Delay(1000);
LCD.Clear();

RGBtest();

digitalWrite (shutterPin, HIGH);
Delay(500);
digitalWrite (shutterPin, bajo);
}

BOTÓN--> toma tiros del salto--3 disparos consecutivos
Si (botones & BUTTON_UP) {}
intMotion = 0;
RGBjump();
}

BOTÓN izquierdo--> 2 fotos
Si (botones & BUTTON_LEFT) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("tomar 2 fotos!!!!");
lcd.setBacklight(YELLOW);
Delay(1000);
LCD.Clear();

RGBtest();

digitalWrite (shutterPin, HIGH);
Delay(500);
digitalWrite (shutterPin, bajo);
Delay(100);
LCD.Clear();

RGBtest();
digitalWrite (shutterPin, HIGH);
Delay(500);
digitalWrite (shutterPin, bajo);
}

BOTÓN--> 3 fotos
Si (botones & BUTTON_DOWN) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("tomar 3 fotos!!!!");
lcd.setBacklight(YELLOW);
Delay(1000);
LCD.Clear();

RGBtest();