Preneur de multi-photo automatique (Photobooth Style) (8 / 10 étapes)

Étape 8: Le Code de l’Arduino

Notre classe avait quelques codes distincts d’Arduino pour rendre les choses plus facile pour certaines commandes.
Garder ces fichier sur dans votre bibliothèque :

-------------------------------
Wire.h
-------------------------------
/*
TwoWire.h - Bibliothèque de TWI/I2C pour Arduino & câblage
Copyright (c) 2006 Nicholas Zambetti. Tous droits réservés.

Cette bibliothèque est un logiciel libre ; vous pouvez le redistribuer et/ou
modifier selon les termes de la GNU Lesser Grand Public
License telle que publiée par la Free Software Foundation ; ou l’autre
version 2.1 de la licence, ou (à votre choix) toute version ultérieure.

Cette bibliothèque est distribuée dans l’espoir qu’il sera utile,
mais sans aucune garantie ; sans même la garantie implicite de
Qualité marchande ou ADEQUATION a un usage particulier. Voir la GNU
Lesser General Public License pour plus de détails.

Vous devriez avoir reçu une copie de la GNU Lesser Grand Public
License along with this library ; Si tel n’est pas le cas, écrivez à la Free Software
Foundation, Inc., 51 Franklin St, 5ème étage, Boston, MA 02110-1301 USA

Mis à jour le 2012 de Todd Krein (todd pour mettre en œuvre les démarrages répétés
*/

#ifndef TwoWire_h
#define TwoWire_h

#include
#include « Stream.h »

#define BUFFER_LENGTH 32

Class TwoWire : public Stream
{
privé :
uint8_t statique rxBuffer [;]
rxBufferIndex uint8_t statique ;
rxBufferLength uint8_t statique ;

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

uint8_t statique transmettant ;
public static void (* user_onRequest)(void) ;
public static void (* user_onReceive)(int) ;
public static void onRequestService(void) ;
' public static void onReceiveService (uint8_t *, int) ;
public :
TwoWire() ;
void begin() ;
void begin(uint8_t) ;
void begin(int) ;
void beginTransmission(uint8_t) ;
void beginTransmission(int) ;
uint8_t endTransmission(void) ;
uint8_t endTransmission(uint8_t) ;
uint8_t requestFrom (uint8_t, uint8_t) ;
uint8_t requestFrom (uint8_t, uint8_t, uint8_t) ;
uint8_t requestFrom (int, int) ;
uint8_t requestFrom (int, int, int) ;
size_t virtuel write(uint8_t) ;
écriture de size_t virtuel (const uint8_t *, 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)) ;

Inline size_t écrire (unsigned long n) {return write((uint8_t)n);}
Inline size_t écriture (long n) {return write((uint8_t)n);}
Inline size_t écrire (unsigned int n) {return write((uint8_t)n);}
Inline size_t write(int n) {return write((uint8_t)n);}
à l’aide de Print::write ;
};

extern TwoWire fil ;

-----------------------------
Adafruit_MCP2307.h
-----------------------------
/***************************************************
Il s’agit d’une bibliothèque pour l’extension de port i2c MCP23017

Ces écrans utilisent I2C pour communiquer, les 2 goupilles sont tenus de
interface
Adafruit investit temps et ressources fournissant ce code source ouvert,
Merci de soutenir Adafruit et open source hardware en achetant
produits de Adafruit !

Écrit par Limor Fried/Ladyada Adafruit industries.
La licence BSD, tout le texte qui précède doit être incluse dans toute redistribution
****************************************************/

#include
#include
#include « Adafruit_MCP23017.h »

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

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

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

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

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

Wire.Begin() ;

définir les valeurs par défaut !
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(MCP23017_IODIRA) ;
wiresend(0xFF) ; toutes les entrées sur le port A
Wire.endTransmission() ;

Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(MCP23017_IODIRB) ;
wiresend(0xFF) ; toutes les entrées sur le port 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 ;

seulement 16 bits !
Si (p > 15)
retour ;

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

lire la IODIR actuelle
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(iodiraddr) ;
Wire.endTransmission() ;

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

mettre la goupille et la direction
Si (d == INPUT) {}
iodir | = 1 << p ;
} else {}
iodir & = ~ (1 << p) ;
}

écrire la nouvelle IODIR
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(iodiraddr) ;
wiresend(iodir) ;
Wire.endTransmission() ;
}

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

lire les loquets de sortie GPIO actuels
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(MCP23017_GPIOA) ;
Wire.endTransmission() ;

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

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

seulement 16 bits !
Si (p > 15)
retour ;

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

lire les loquets de sortie GPIO actuels
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(olataddr) ;
Wire.endTransmission() ;

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

mettre la goupille et la direction
Si (d == HIGH) {}
GPIO | = 1 << p ;
} else {}
GPIO & = ~ (1 << p) ;
}

écrire la nouvelle 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 ;

seulement 16 bits !
Si (p > 15)
retour ;

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

lire l’ensemble de résistance pullup actuel
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(gppuaddr) ;
Wire.endTransmission() ;

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

mettre la goupille et la direction
Si (d == HIGH) {}
GPPU | = 1 << p ;
} else {}
GPPU & = ~ (1 << p) ;
}

écrire la nouvelle GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(gppuaddr) ;
wiresend(GPPU) ;
Wire.endTransmission() ;
}

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

seulement 16 bits !
Si (p > 15)
return 0 ;

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

lire l’actuel GPIO
Wire.beginTransmission(MCP23017_ADDRESS | i2caddr) ;
wiresend(gpioaddr) ;
Wire.endTransmission() ;

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

------------------------------------
Adafruit_RGBLCDShield.h
------------------------------------
/***************************************************
Il s’agit d’une bibliothèque pour le bouclier de LCD Adafruit RGB 16 x 2
Un pick up à la boutique Adafruit !
---> http://http:// www.adafruit.com/products/714

Le bouclier utilise I2C pour communiquer, les 2 goupilles sont tenus de
interface
Adafruit investit temps et ressources fournissant ce code source ouvert,
Merci de soutenir Adafruit et open source hardware en achetant
produits de Adafruit !

Écrit par Limor Fried/Ladyada Adafruit industries.
La licence BSD, tout le texte qui précède doit être incluse dans toute redistribution
****************************************************/

#include « Adafruit_RGBLCDShield.h »

#include
#include
#include
#include

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

Lorsque l’écran s’allume, il est configuré comme suit :
//
// 1. Affichage clair
// 2. Jeu de fonctions :
DL = 1 ; données 8 bits interface
N = 0 ; affichage de 1-ligne
F = 0 ; police de caractères dot 5 x 8
// 3. Afficher commande marche/arrêt :
D = 0 ; Afficher hors
C = 0 ; Curseur hors
B = 0 ; Clignotant hors
// 4. La valeur de mode d’entrée :
J’AI / D = 1 ; Incrément de 1
S = 0 ; Pas de changement
//
Notez, cependant, que la réinitialisation de l’Arduino n’est pas réinitialiser l’écran LCD, donc nous
ne peut pas supposer que son dans cet État au démarrage d’un croquis (et de la
RGBLCDShield constructeur est appelé).

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

_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS ;

le brochage d’expander I/O
_rs_pin = 15 ;
_rw_pin = 14 ;
_enable_pin = 13 ;
_data_pins [0] = 12 ; vraiment d4
_data_pins [1] = 11 ; vraiment d5
_data_pins [2] = 10 ; vraiment d6
_data_pins [3] = 9 ; vraiment d7

_button_pins [0] = 0 ;
_button_pins [1] = 1 ;
_button_pins [2] = 2 ;
_button_pins [3] = 3 ;
_button_pins [4] = 4 ;
Nous ne pouvons begin() encore:(
}

void Adafruit_RGBLCDShield::init (uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, d1 uint8_t, 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 = activer ;

_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, sortie) ;
Nous pouvons sauver 1 broche en n’utilisant ne pas de RW. Indiquer en passant 255 au lieu de broche
Si (_rw_pin! = 255) {}
_pinMode (_rw_pin, sortie) ;
}
_pinMode (_enable_pin, sortie) ;

Si (fourbitmode)
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS ;
d’autre
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS ;

commencer (16, 1) ;
}

void Adafruit_RGBLCDShield::begin (uint8_t CLO, lignes uint8_t, uint8_t dotsize) {}
vérifier si i2c
Si (_i2cAddr! = 255) {}
_i2c.Begin(_i2cAddr) ;
Wire.Begin() ;
_i2c.Begin() ;

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

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

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

pour (uint8_t i = 0; i < 5; i ++) {}
_i2c.pinMode (_button_pins [i], entrée) ;
_i2c.pullUp (_button_pins [i], 1) ;
}
}

Si (lignes > 1) {}
_displayfunction | = LCD_2LINE ;
}
_numlines = lignes ;
_currline = 0 ;

pour certains écrans de la 1 ligne, vous pouvez sélectionner une police forte de 10 pixels
Si ((dotsize! = 0) & & (lignes == 1)) {}
_displayfunction | = LCD_5x10DOTS ;
}

VOIR PAGE 45/46 FOR INITIALIZATION SPÉCIFICATION !
selon la feuille de données, nous avons besoin au moins de 40ms après que puissance dépasse de 2, 7V
avant d’envoyer des commandes. Arduino peut allumer de façon befer 4.5V donc nous allons attendre 50
delayMicroseconds(50000) ;
Maintenant nous tirez sur les RS et R/W bas d’abord les commandes
_digitalWrite (_rs_pin, basse) ;
_digitalWrite (_enable_pin, basse) ;
Si (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, basse) ;
}

mettre l’écran LCD en mode 4 bits ou 8 bits
if (!. (_displayfunction & LCD_8BITMODE)) {
Cela est conforme à l’hitachi HD44780 datasheet
Figure 24, pg 46

Nous commençons en mode 8 bit, essayez de définir le mode 4 bit
write4bits(0x03) ;
delayMicroseconds(4500) ; attendre min 4.1ms

deuxième essai
write4bits(0x03) ;
delayMicroseconds(4500) ; attendre min 4.1ms

troisième rendez-vous !
write4bits(0x03) ;
delayMicroseconds(150) ;

Enfin, la valeur de 8-bit interface
write4bits(0x02) ;
} else {}
Cela est conforme à l’hitachi HD44780 datasheet
figure page 45 23

Envoyer la séquence de commandes public function set
Command(LCD_FUNCTIONSET | _displayfunction) ;
delayMicroseconds(4500) ; attendre plus de 4.1ms

deuxième essai
Command(LCD_FUNCTIONSET | _displayfunction) ;
delayMicroseconds(150) ;

troisième rendez-vous
Command(LCD_FUNCTIONSET | _displayfunction) ;
}

Enfin, la valeur # lignes, la taille de police, etc..
Command(LCD_FUNCTIONSET | _displayfunction) ;

Allumez l’écran sans curseur ou défaut clignotant
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF ;
Display() ;

Il dégager outre
Clear() ;

Initialiser à l’orientation du texte par défaut (pour les langues romanes)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT ;
définir le mode d’entrée
Command(LCD_ENTRYMODESET | _displaymode) ;

}

/ *** commandes de haut niveau, pour l’utilisateur ! */
Sub Adafruit_RGBLCDShield::clear()
{
Command(LCD_CLEARDISPLAY) ; effacer l’écran, définir la position du curseur à zéro
delayMicroseconds(2000) ; Cette commande prend beaucoup de temps !
}

Sub Adafruit_RGBLCDShield::home()
{
Command(LCD_RETURNHOME) ; définir la position du curseur à zéro
delayMicroseconds(2000) ; Cette commande prend beaucoup de temps !
}

void Adafruit_RGBLCDShield::setCursor (col d’uint8_t, uint8_t row)
{
int row_offsets [] = {0 x 00, 0 x 40, 0 x 14, 0 x 54} ;
Si (ligne > _numlines) {}
ligne = _numlines-1 ; Nous comptons lignes en commençant les w/0
}

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

Activer/désactiver l’affichage de la (rapidement)
void Adafruit_RGBLCDShield::noDisplay() {}
_displaycontrol & = ~ LCD_DISPLAYON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}
void Adafruit_RGBLCDShield::display() {}
_displaycontrol | = LCD_DISPLAYON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}

Transforme le curseur de soulignement marche/arrêt
void Adafruit_RGBLCDShield::noCursor() {}
_displaycontrol & = ~ LCD_CURSORON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}
void Adafruit_RGBLCDShield::cursor() {}
_displaycontrol | = LCD_CURSORON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}

Activer et désactiver le curseur clignotant
void Adafruit_RGBLCDShield::noBlink() {}
_displaycontrol & = ~ LCD_BLINKON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}
void Adafruit_RGBLCDShield::blink() {}
_displaycontrol | = LCD_BLINKON ;
Command(LCD_DISPLAYCONTROL | _displaycontrol) ;
}

Ces commandes faites défiler l’écran sans changer la 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) ;
}

C’est pour le texte que les flux de gauche à droite
void Adafruit_RGBLCDShield::leftToRight(void) {}
_displaymode | = LCD_ENTRYLEFT ;
Command(LCD_ENTRYMODESET | _displaymode) ;
}

C’est pour le texte qui coule de droite à gauche
void Adafruit_RGBLCDShield::rightToLeft(void) {}
_displaymode & = ~ LCD_ENTRYLEFT ;
Command(LCD_ENTRYMODESET | _displaymode) ;
}

Ce sera « aligné à droite » texte du curseur
void Adafruit_RGBLCDShield::autoscroll(void) {}
_displaymode | = LCD_ENTRYSHIFTINCREMENT ;
Command(LCD_ENTRYMODESET | _displaymode) ;
}

Ce texte sera "cadrer à gauche' du curseur
void Adafruit_RGBLCDShield::noAutoscroll(void) {}
_displaymode & = ~ LCD_ENTRYSHIFTINCREMENT ;
Command(LCD_ENTRYMODESET | _displaymode) ;
}

Permet de remplir les 8 premiers emplacements CGRAM
avec les caractères personnalisés
void Adafruit_RGBLCDShield::createChar (emplacement d’uint8_t, uint8_t charmap[]) {}
emplacement & = 0 x 7 ; Nous n’avons que 8 emplacements 0-7
Command(LCD_SETCGRAMADDR | (emplacement << 3)) ;
pour (int i = 0; i < 8; i ++) {}
Write(charmap[i]) ;
}
Command(LCD_SETDDRAMADDR) ; Malheureusement rétablit l’emplacement 0,0
}

/ *** mi niveau de commandes, pour envoyer des données/cmds * /

Inline void {Adafruit_RGBLCDShield::command (valeur uint8_t)
Envoyer (valeur, faible) ;
}

#if ARDUINO > = 100
Inline size_t Adafruit_RGBLCDShield::write (valeur uint8_t) {}
Envoyer (valeur, HIGH) ;
Return 1 ;
}
#else
Inline void {Adafruit_RGBLCDShield::write (valeur uint8_t)
Envoyer (valeur, HIGH) ;
}
#endif

/ *** données à faible niveau en poussant les commandes *** /

petit wrapper pour les écritures d’e/s
void Adafruit_RGBLCDShield::_digitalWrite (uint8_t p, uint8_t d) {}
Si (_i2cAddr! = 255) {}
une commande i2c
_i2c.digitalWrite (p, d) ;
} else {}
Straightup IO
digitalWrite (p, d) ;
}
}

Permet de régler le rétro-éclairage, si le sac à dos de l’écran LCD est utilisé
void Adafruit_RGBLCDShield::setBacklight (État uint8_t) {}
vérifier si i2c ou SPI
_i2c.digitalWrite (8, ~ (statut >> 2) & 0 x 1) ;
_i2c.digitalWrite (7, ~ (statut >> 1) & 0 x 1) ;
_i2c.digitalWrite (6, ~ statut & 0 x 1) ;
}

petit wrapper pour instructions d’e/s
void Adafruit_RGBLCDShield::_pinMode (uint8_t p, uint8_t d) {}
Si (_i2cAddr! = 255) {}
une commande i2c
_i2c.pinMode (p, d) ;
} else {}
Straightup IO
pinMode (p, d) ;
}
}

écrire des données, avec sélection automatique de 4/8 bits soit commande
void Adafruit_RGBLCDShield::send (uint8_t valeur, uint8_t mode) {}
_digitalWrite (_rs_pin, mode) ;

s’il y a une goupille RW indiquée, affectez-lui la faible écriture
Si (_rw_pin! = 255) {}
_digitalWrite (_rw_pin, basse) ;
}

Si (_displayfunction & LCD_8BITMODE) {}
write8bits(value) ;
} else {}
write4bits (valeur >> 4) ;
write4bits(value) ;
}
}

void Adafruit_RGBLCDShield::pulseEnable(void) {}
_digitalWrite (_enable_pin, basse) ;
delayMicroseconds(1) ;
_digitalWrite (_enable_pin, HIGH) ;
delayMicroseconds(1) ; permettre à impulsion doit être > 450ns
_digitalWrite (_enable_pin, basse) ;
delayMicroseconds(100) ; nécessité de commandes > 37us à régler
}

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

sortir = _i2c.readGPIOAB() ;

accélérer pour i2c depuis son lent
pour (int i = 0; i < 4; i ++) {}
sortir & = ~ _BV(_data_pins[i]) ;
hors | = ((valeur >> i) & 0 x 1) << _data_pins [i] ;
}

Veillez à activer est faible
sortir & = ~ _BV(_enable_pin) ;

_i2c.writeGPIOAB(out) ;

impulsion enable
delayMicroseconds(1) ;
hors | = _BV(_enable_pin) ;
_i2c.writeGPIOAB(out) ;
delayMicroseconds(1) ;
sortir & = ~ _BV(_enable_pin) ;
_i2c.writeGPIOAB(out) ;
delayMicroseconds(100) ;

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

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

pulseEnable() ;
}

uint8_t Adafruit_RGBLCDShield::readButtons(void) {}
réponse d’uint8_t = 0x1F ;

pour (uint8_t i = 0; i < 5; i ++) {}
réponse & = ~((_i2c.digitalRead(_button_pins[i])) << j’ai) ;
}
renvoyer une réponse ;
}

----------------------------------------
Code de Photobooth (c’est celui que vous utilisez en fait)
----------------------------------------

#include
#include
#include

Lcd Adafruit_RGBLCDShield = Adafruit_RGBLCDShield() ;

Définir la couleur de rétro-éclairage
#define rouge 0 x 1
#define jaune 0 x 3
#define vert 0 x 2
#define TEAL 0 x 6
#define bleu 0 x 4
#define VIOLET 0 x 5
#define blanc 0 x 7

int shutterPin = 5 ; 5 numérique qui se connecte à l’obturateur de la caméra
int pirPin = 6 ; 6 numérique
int intMotion = 0 ;
int intNoMotion = 0 ;

Qu’int = 11 ;
int blueLED = 10 ;
int redLED = 13 ;

Boolean buttonselect ;

void setup() {}
Serial.Begin(9600) ;
pinMode (pirPin, entrée) ;
LCD.Begin (16, 2) ;
temps d’int = millis() ;
temps = millis() - temps ;

pinMode (que, sortie) ;
pinMode (blueLED, sortie) ;
pinMode (redLED, sortie) ;
pinMode (shutterPin, sortie) ;
}

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

if(pirVal == Low) //was motion {détectée
Serial.println ("mouvement détecté") ;
Delay(1000) ;
intMotion = intMotion + 1 ;
if(intMotion>3) {}
lcd.setBacklight(VIOLET) ;
lcd.setCursor (0, 0) ;
LCD.Print ("caméra de Chloé") ;
lcd.setCursor (0,1) ;
LCD.Print (« prendre une photo!!!") ;
Delay(2000) ;
lcd.setCursor(0,0) ;
LCD.Print ("SELECT pour PIC!") ;
lcd.setCursor(0,1) ;
LCD.Print (« pour JUMP! ») ;
Delay(3000) ;
LCD.Clear() ;
lcd.setCursor(0,0) ;
LCD.Print ("gauche : droite 2: 4") ;
lcd.setCursor(0,1) ;
LCD.Print ("DOWN: 3 photos : date") ;
Delay(1000) ;
}
}

Si {(boutons)
LCD.Clear() ;
lcd.setCursor(0,0) ;
Sélectionnez le bouton--> prend 1 PHOTO
Si (boutons & BUTTON_SELECT) {}
intMotion = 0 ;

LCD.Clear() ;
LCD.Print (« prendre une photo!!") ;
lcd.setBacklight(YELLOW) ;
Delay(1000) ;
LCD.Clear() ;

RGBtest() ;

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

TOUCHE UP--> prend coups de saut--3 coups consécutifs
Si (boutons & BUTTON_UP) {}
intMotion = 0 ;
RGBjump() ;
}

BOUTON gauche--> 2 photos
Si (boutons & BUTTON_LEFT) {}
intMotion = 0 ;

LCD.Clear() ;
LCD.Print ("prendre 2 photos!!") ;
lcd.setBacklight(YELLOW) ;
Delay(1000) ;
LCD.Clear() ;

RGBtest() ;

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

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

LE bouton--> 3 photos
Si (boutons & BUTTON_DOWN) {}
intMotion = 0 ;

LCD.Clear() ;
LCD.Print ("prendre 3 photos!!") ;
lcd.setBacklight(YELLOW) ;
Delay(1000) ;
LCD.Clear() ;

RGBtest() ;