Automatische multi foto nemer (Photobooth stijl) (8 / 10 stap)

Stap 8: De Code van de Arduino

Onze klas had een paar aparte Arduino codes om dingen te maken gemakkelijker voor bepaalde opdrachten.
Houd deze op bestand in uw MEDIABIBLIOTHEEK:

-------------------------------
Wire.h
-------------------------------
/*
TwoWire.h - TWI/I2C library voor Arduino & bedrading
Copyright (c) 2006 Nicholas Zambetti. Alle rechten voorbehouden.

Deze bibliotheek is vrije software; je kunt het herdistribueren en/of
aanpassen onder de voorwaarden van de GNU Lesser algemene openbare
Licentie zoals gepubliceerd door de Free Software Foundation; beide
versie 2.1 van de licentie, of (naar uw keuze) een latere versie.

Deze bibliotheek wordt verspreid in de hoop dat het bruikbaar,
maar zonder enige garantie; zelfs zonder de impliciete garantie van
VERKOOPBAARHEID of geschiktheid voor een bepaald doel. Zie GNU
Lesser General Public License voor meer details.

U moet hebt ontvangen een kopie van de GNU Lesser algemene openbare
License along with this library; Als dit niet het geval is, schrijven aan de Vrije Software
Foundation, Inc., 51 Franklin St, vijfde verdieping, Boston, MA 02110-1301 USA

Gemodificeerde 2012 door Todd Krein (todd om herhaalde begint
*/

#ifndef TwoWire_h
#define TwoWire_h

#include
#include "Stream.h"

#define BUFFER_LENGTH 32

klasse TwoWire: openbare Stream
{
privé:
statische uint8_t rxBuffer [];
statische uint8_t rxBufferIndex;
statische uint8_t rxBufferLength;

statische uint8_t txAddress;
statische uint8_t txBuffer [];
statische uint8_t txBufferIndex;
statische uint8_t txBufferLength;

statische uint8_t overbrengen;
statische leegte (* user_onRequest)(void);
statische leegte (* user_onReceive)(int);
statische nietig onRequestService(void);
statische nietige onReceiveService (uint8_t *, int);
publiek:
TwoWire();
nietig begin();
nietig begin(uint8_t);
nietig begin(int);
nietig beginTransmission(uint8_t);
nietig beginTransmission(int);
uint8_t endTransmission(void);
uint8_t endTransmission(uint8_t);
uint8_t Europese (uint8_t, uint8_t);
uint8_t Europese (uint8_t uint8_t, uint8_t);
uint8_t Europese (int, int);
uint8_t Europese (int, int, int);
virtuele size_t de write(uint8_t);
virtuele size_t schrijven (const uint8_t *, size_t);
virtuele int available(void);
virtuele int read(void);
virtuele int peek(void);
virtuele nietig flush(void);
VOID onReceive (void (*)(int));
VOID onRequest (void (*)(void));

inline size_t schrijven (niet-ondertekende lange n) {return write((uint8_t)n);}
inline size_t schrijven (lange n) {return write((uint8_t)n);}
inline size_t schrijven (unsigned int n) {return write((uint8_t)n);}
inline size_t write(int n) {return write((uint8_t)n);}
met behulp van Print::write;
};

externe TwoWire draad;

-----------------------------
Adafruit_MCP2307.h
-----------------------------
/***************************************************
Dit is een bibliotheek voor de MCP23017 i2c poort expander

I2C deze schermen gebruiken om te communiceren, zijn 2 pinnen verplicht te
Interface
Adafruit investeert tijd en middelen verstrekken van dit open source-code,
u kan ondersteunen Adafruit en open-source hardware door de aankoop van
producten van Adafruit!

Geschreven door Limor Fried/Ladyada voor Adafruit industrieën.
BSD-licentie, alle bovenstaande tekst moet worden opgenomen in eventuele herverdeling
****************************************************/

#include
#include
#include "Adafruit_MCP23017.h"

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

minihelper
statische inline nietig wiresend(uint8_t x) {}
#if ARDUINO > = 100
Wire.write((uint8_t)x);
#else
Wire.send(x);
#endif
}

inline statische uint8_t wirerecv(void) {}
#if ARDUINO > = 100
Return Wire.read();
#else
Return Wire.receive();
#endif
}

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

VOID Adafruit_MCP23017::begin (uint8_t addr) {}
Als (addr > 7) {}
addr = 7;
}
i2caddr = addr;

Wire.begin();

standaardwaarden instellen!
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_IODIRA);
wiresend(0xFF); alle ingangen op poort A
Wire.endTransmission();

Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_IODIRB);
wiresend(0xFF); alle ingangen op poort B
Wire.endTransmission();
}

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

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

uitsluitend 16-bits!
Als (p > 15)
terugkeer;

Als (p < 8)
iodiraddr = MCP23017_IODIRA;
else {}
iodiraddr = MCP23017_IODIRB;
p-= 8;
}

de huidige IODIR lezen
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(iodiraddr);
Wire.endTransmission();

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

de pin en richting instellen
Als (d == INPUT) {}
iodir | = 1 << p;
} else {}
iodir & = ~ (1 << p);
}

schrijven van de nieuwe IODIR
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(iodiraddr);
wiresend(iodir);
Wire.endTransmission();
}

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

Lees de huidige GPIO output sloten
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(MCP23017_GPIOA);
Wire.endTransmission();

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

retourneren van 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) {}
uint8_t gpio;
uint8_t gpioaddr, olataddr;

uitsluitend 16-bits!
Als (p > 15)
terugkeer;

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

Lees de huidige GPIO output sloten
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(olataddr);
Wire.endTransmission();

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

de pin en richting instellen
Als (d HIGH ==) {}
GPIO | = 1 << p;
} else {}
GPIO & = ~ (1 << p);
}

Schrijf de nieuwe GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gpioaddr);
wiresend(GPIO);
Wire.endTransmission();
}

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

uitsluitend 16-bits!
Als (p > 15)
terugkeer;

Als (p < 8)
gppuaddr = MCP23017_GPPUA;
else {}
gppuaddr = MCP23017_GPPUB;
p-= 8;
}

Lees de huidige pullup weerstand set
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gppuaddr);
Wire.endTransmission();

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

de pin en richting instellen
Als (d HIGH ==) {}
gppu | = 1 << p;
} else {}
gppu & = ~ (1 << p);
}

Schrijf de nieuwe GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gppuaddr);
wiresend(gppu);
Wire.endTransmission();
}

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

uitsluitend 16-bits!
Als (p > 15)
keren 0;

Als (p < 8)
gpioaddr = MCP23017_GPIOA;
else {}
gpioaddr = MCP23017_GPIOB;
p-= 8;
}

Lees de huidige GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr);
wiresend(gpioaddr);
Wire.endTransmission();

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

------------------------------------
Adafruit_RGBLCDShield.h
------------------------------------
/***************************************************
Dit is een bibliotheek voor het Adafruit RGB 16 x 2 LCD schild
Afhalen in de winkel van Adafruit!
---> http://http :// www.adafruit.com/products/714

I2C het schild gebruikt om te communiceren, zijn 2 pinnen verplicht te
Interface
Adafruit investeert tijd en middelen verstrekken van dit open source-code,
u kan ondersteunen Adafruit en open-source hardware door de aankoop van
producten van Adafruit!

#include "Adafruit_RGBLCDShield.h"

#include
#include
#include
#include

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

Wanneer de display inschakelt, wordt het als volgt geconfigureerd:
//
// 1. Duidelijk weergeven
// 2. Functie set:
DL = 1; 8-bit interface-gegevens
N = 0; 1-regelige display
F = 0; 5 x 8 dot lettertype
// 3. Aan/uit controle weergeven
D = 0; Weer af
C = 0; Cursor uitschakelen
B = 0; Knippert af
// 4. Modus voor gegevensinvoer instellen:
IK / D = 1; Aanwas door 1
S = 0; Geen verschuiving
//
Merk echter op dat opnieuw instellen van de Arduino niet opnieuw de LCD, dus instellen we
kan niet veronderstellen dat de in die staat als een schets wordt gestart (en van de
RGBLCDShield constructor wordt genoemd).

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

_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;

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

_button_pins [0] = 0;
_button_pins [1] = 1;
_button_pins [2] = 2;
_button_pins [3] = 3;
_button_pins [4] = 4;
We kunnen niet begin() nog :(
}

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

_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, OUTPUT);
1 pin kunnen we besparen door RW niet te gebruiken. Geven door het passeren van 255 in plaats van pin #
Als (_rw_pin! = 255) {}
_pinMode (_rw_pin, OUTPUT);
}
_pinMode (_enable_pin, OUTPUT);

Als (fourbitmode)
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
anders
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;

beginnen (16, 1);
}

VOID Adafruit_RGBLCDShield::begin (uint8_t cols, uint8_t lijnen, uint8_t dotsize) {}
Controleerinderegel i2c
Als (_i2cAddr! = 255) {}
_i2c.begin(_i2cAddr);
Wire.begin();
_i2c.begin();

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

Als (_rw_pin)
_i2c.pinMode (_rw_pin, OUTPUT);

_i2c.pinMode (_rs_pin, OUTPUT);
_i2c.pinMode (_enable_pin, OUTPUT);
voor (uint8_t ik = 0; ik < 4; i ++)
_i2c.pinMode (_data_pins [i], OUTPUT);

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

Als (lijn > 1) {}
_displayfunction | = LCD_2LINE;
}
_numlines = lijnen;
_currline = 0;

voor sommige beeldschermen 1 lijn kunt u een 10 pixels hoog lettertype selecteren
Als ((dotsize! = 0) & & (lijnen == 1)) {}
_displayfunction | = LCD_5x10DOTS;
}

ZIE PAGINA 45/46 FOR INITIALISATIE SPECIFICATIE!
Volgens gegevensblad moeten we ten minste 40ms nadat macht boven 2.7V stijgt
voordat u opdrachten verzendt. Arduino kunt inschakelen, manier befer 4.5V zodat we 50 wachten
delayMicroseconds(50000);
Nu trekken we zowel de RS en R/W laag om te beginnen van opdrachten
_digitalWrite (_rs_pin, laag);
_digitalWrite (_enable_pin, laag);
Als (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, laag);
}

Zet de LCD in 4 bits of 8-bits modus
if (!. (_displayfunction & LCD_8BITMODE)) {
Dit is volgens de hitachi HD44780 gegevensblad
Figuur 24, pg 46

We starten in 8-bits modus, probeer om 4 bit modus
write4bits(0x03);
delayMicroseconds(4500); min 4.1ms wachten

tweede poging
write4bits(0x03);
delayMicroseconds(4500); min 4.1ms wachten

Ten derde gaan!
write4bits(0x03);
delayMicroseconds(150);

Ten slotte ingesteld op 8-bit interface
write4bits(0x02);
} else {}
Dit is volgens de hitachi HD44780 gegevensblad
bladzijde 45 figuur 23

Stuur functie set commando 's
Command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(4500); wachten meer dan 4.1ms

tweede poging
Command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(150);

Ten derde gaan
Command(LCD_FUNCTIONSET | _displayfunction);
}

tot slot stel # lijnen, tekengrootte, enz.
Command(LCD_FUNCTIONSET | _displayfunction);

de weergave inschakelen zonder cursor of knipperende standaard
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display ();

Schakel het uit
Clear();

Initialiseren om de richting van de tekst van de standaard (voor Romaanse talen)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
Stel de modus voor gegevensinvoer
Command(LCD_ENTRYMODESET | _displaymode);

}

/ *** hoog niveau opdrachten, voor de gebruiker! */
VOID Adafruit_RGBLCDShield::clear()
{
Command(LCD_CLEARDISPLAY); Schakel weergeven, cursorpositie ingesteld op nul
delayMicroseconds(2000); deze opdracht neemt een lange tijd!
}

VOID Adafruit_RGBLCDShield::home()
{
Command(LCD_RETURNHOME); cursorpositie ingesteld op nul
delayMicroseconds(2000); deze opdracht neemt een lange tijd!
}

VOID Adafruit_RGBLCDShield::setCursor (uint8_t col, uint8_t rij)
{
int row_offsets [] = {0x00, 0x40, 0x14, 0x54};
Als (rij > _numlines) {}
rij = _numlines-1; We rekenen rijen beginnen w/0
}

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

Draai het scherm aan/uit (snel)
VOID Adafruit_RGBLCDShield::noDisplay() {}
_displaycontrol & = ~ LCD_DISPLAYON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
VOID Adafruit_RGBLCDShield::display() {}
_displaycontrol | = LCD_DISPLAYON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

Verandert de cursor onderstrepen in-/ uitschakelen
VOID Adafruit_RGBLCDShield::noCursor() {}
_displaycontrol & = ~ LCD_CURSORON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
VOID Adafruit_RGBLCDShield::cursor() {}
_displaycontrol | = LCD_CURSORON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

En van het knipperen curseur aanzetten
VOID Adafruit_RGBLCDShield::noBlink() {}
_displaycontrol & = ~ LCD_BLINKON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}
VOID Adafruit_RGBLCDShield::blink() {}
_displaycontrol | = LCD_BLINKON;
Command(LCD_DISPLAYCONTROL | _displaycontrol);
}

Deze opdrachten scroll het display zonder te wijzigen van de 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);
}

Dit is voor tekst dat stromen van links naar rechts
VOID Adafruit_RGBLCDShield::leftToRight(void) {}
_displaymode | = LCD_ENTRYLEFT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Dit is voor tekst die van rechts naar links loopt
VOID Adafruit_RGBLCDShield::rightToLeft(void) {}
_displaymode & = ~ LCD_ENTRYLEFT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Dit zal 'rechts rechtvaardigen' tekst vanaf de cursor
VOID Adafruit_RGBLCDShield::autoscroll(void) {}
_displaymode | = LCD_ENTRYSHIFTINCREMENT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Deze zal 'links uitvullen' tekst vanaf de cursor
VOID Adafruit_RGBLCDShield::noAutoscroll(void) {}
_displaymode & = ~ LCD_ENTRYSHIFTINCREMENT;
Command(LCD_ENTRYMODESET | _displaymode);
}

Laat ons toe om het invullen van de eerste 8 CGRAM-locaties
met aangepaste tekens
VOID Adafruit_RGBLCDShield::createChar (uint8_t locatie, uint8_t charmap[]) {}
Locatie & = 0x7; Wij hebben slechts 8 locaties 0-7
Command(LCD_SETCGRAMADDR | (locatie << 3));
for (int i = 0; ik < 8; i ++) {}
Write(charmap[i]);
}
Command(LCD_SETDDRAMADDR); Helaas de locatie 0,0 worden hersteld
}

/ *** midden niveau opdrachten voor het verzenden van gegevens/cmds * /

inline void Adafruit_RGBLCDShield::command (uint8_t waarde) {}
verzenden (waarde, laag);
}

#if ARDUINO > = 100
inline size_t Adafruit_RGBLCDShield::write (uint8_t waarde) {}
verzenden (waarde, hoog);
return 1;
}
#else
inline void Adafruit_RGBLCDShield::write (uint8_t waarde) {}
verzenden (waarde, hoog);
}
#endif

/ *** lage niveau gegevens duwen opdrachten *** /

kleine wrapper voor i/o-schrijfbewerkingen
VOID Adafruit_RGBLCDShield::_digitalWrite (uint8_t p, uint8_t d) {}
Als (_i2cAddr! = 255) {}
een i2c-opdracht
_i2c.digitalWrite (p, d);
} else {}
straightup IO
digitalWrite (p, d);
}
}

Kunt u de achtergrondverlichting, als de LCD-rugzak wordt gebruikt
VOID Adafruit_RGBLCDShield::setBacklight (uint8_t status) {}
Controleerinderegel i2c of SPI
_i2c.digitalWrite (8, ~ (status >> 2) & 0x1);
_i2c.digitalWrite (7, ~ (status >> 1) & 0x1);
_i2c.digitalWrite (6, ~ status & 0x1);
}

kleine wrapper voor een i/o-Routebeschrijving
VOID Adafruit_RGBLCDShield::_pinMode (uint8_t p, uint8_t d) {}
Als (_i2cAddr! = 255) {}
een i2c-opdracht
_i2c.pinMode (p, d);
} else {}
straightup IO
pinMode (p, d);
}
}

schrijven van de opdracht of gegevens, met automatische 4/8-bit selectie
VOID Adafruit_RGBLCDShield::send (uint8_t waarde, uint8_t modus) {}
_digitalWrite (_rs_pin, modus);

Als er een RW-pin aangegeven, het laag ingesteld te schrijven
Als (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, laag);
}

Als (_displayfunction & LCD_8BITMODE) {}
write8bits(Value);
} else {}
write4bits (waarde >> 4);
write4bits(Value);
}
}

VOID Adafruit_RGBLCDShield::pulseEnable(void) {}
_digitalWrite (_enable_pin, laag);
delayMicroseconds(1);
_digitalWrite (_enable_pin, hoge);
delayMicroseconds(1); inschakelen pols moet > 450ns
_digitalWrite (_enable_pin, laag);
delayMicroseconds(100); noodzaak opdrachten > 37us te regelen
}

VOID Adafruit_RGBLCDShield::write4bits (uint8_t waarde) {}
Als (_i2cAddr! = 255) {}
uint16_t uit = 0;

uit = _i2c.readGPIOAB();

versnellen voor i2c sinds zijn traag
for (int i = 0; ik < 4; i ++) {}
buiten & = ~ _BV(_data_pins[i]);
uit | = ((waarde >> i) & 0x1) << _data_pins [i];
}

Zorg ervoor dat enable is laag
buiten & = ~ _BV(_enable_pin);

_i2c.writeGPIOAB(out);

Pulse inschakelen
delayMicroseconds(1);
uit | = _BV(_enable_pin);
_i2c.writeGPIOAB(out);
delayMicroseconds(1);
buiten & = ~ _BV(_enable_pin);
_i2c.writeGPIOAB(out);
delayMicroseconds(100);

} else {}
for (int i = 0; ik < 4; i ++) {}
_pinMode (_data_pins [i], OUTPUT);
_digitalWrite (_data_pins [i], (waarde >> i) & 0x01);
}
pulseEnable();
}
}

VOID Adafruit_RGBLCDShield::write8bits (uint8_t waarde) {}
for (int i = 0; ik < 8; i ++) {}
_pinMode (_data_pins [i], OUTPUT);
_digitalWrite (_data_pins [i], (waarde >> i) & 0x01);
}

pulseEnable();
}

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

voor (uint8_t ik = 0; ik < 5; i ++) {}
antwoord & ~((_i2c.digitalRead(_button_pins[i])) = << ik);
}
retourneren van antwoord;
}

----------------------------------------
PhotoBooth Code (dit is degene die u daadwerkelijk wilt gebruiken)
----------------------------------------

#include
#include
#include

Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

De kleur van de achtergrondverlichting instellen
#define RED 0x1
#define gele 0x3
#define groen 0x2
#define TEAL 0x6 gemaakt
#define BLUE 0x4
#define VIOLET 0x5
#define WHITE 0x7

int shutterPin = 5; digitale 5 die verbinding maakt met de camera sluiter
int pirPin = 6; digitale 6
int intMotion = 0;
int intNoMotion = 0;

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

Booleaanse buttonselect;

VOID Setup {}
Serial.begin(9600);
pinMode (pirPin, INPUT);
LCD.begin (16, 2);
int tijd = millis();
tijd = millis() - tijd;

pinMode (greenLED, OUTPUT);
pinMode (blueLED, OUTPUT);
pinMode (redLED, OUTPUT);
pinMode (shutterPin, OUTPUT);
}

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

if(pirVal == low) {//was bewegingsdetectie
Serial.println ("bewegingsdetectie");
delay(1000);
intMotion = intMotion + 1;
if(intMotion>3) {}
lcd.setBacklight(VIOLET);
lcd.setCursor (0, 0);
LCD.Print ("CHLOE 'S CAMERA");
lcd.setCursor (0,1);
LCD.Print ("Take tilllate.com!");
delay(2000);
lcd.setCursor(0,0);
LCD.Print ("SELECT voor PIC!");
lcd.setCursor(0,1);
LCD.Print ("voor sprong!");
delay(3000);
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("links: 2 rechts: 4");
lcd.setCursor(0,1);
LCD.Print ("DOWN: 3 foto's:)" ");
delay(1000);
}
}

Als (knoppen) {}
LCD.Clear();
lcd.setCursor(0,0);
Selecteer knop--> neemt 1 foto
Als (knoppen & BUTTON_SELECT) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("fotograferen!");
lcd.setBacklight(YELLOW);
delay(1000);
LCD.Clear();

RGBtest();

digitalWrite (shutterPin, hoge);
delay(500);
digitalWrite (shutterPin, laag);
}

KNOP omhoog--> neemt springen schoten--3 opeenvolgende schoten
Als (knoppen & BUTTON_UP) {}
intMotion = 0;
RGBjump();
}

KNOP links--> 2 foto 's
Als (knoppen & BUTTON_LEFT) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("nemen 2 foto's!!");
lcd.setBacklight(YELLOW);
delay(1000);
LCD.Clear();

RGBtest();

digitalWrite (shutterPin, hoge);
delay(500);
digitalWrite (shutterPin, laag);
delay(100);
LCD.Clear();

RGBtest();
digitalWrite (shutterPin, hoge);
delay(500);
digitalWrite (shutterPin, laag);
}

-KNOP ingedrukt > 3 foto 's
Als (knoppen & BUTTON_DOWN) {}
intMotion = 0;

LCD.Clear();
LCD.Print ("nemen 3 foto's!!");
lcd.setBacklight(YELLOW);
delay(1000);
LCD.Clear();

RGBtest();