Telecomanduino, il telecomando multiuso programmabile costruito con Arduino

Sul numero di Gennaio 2016 di Fotografia Reflex potete trovare tutte le indicazione su come costruire il Telecomaduino, un telecomando multiuso programmabile costruito con Arduino.

Qui sotto potete vedere un video che mostra dal vivo il funzionamento del Telecomanduino:

Se volete avventurarvi nella programmazione, qui di seguito trovate riportato il codice utilizzato per far funzionare Telecomanduino:

/*
Telecomanduino è un telecomando universale per fotocamere capace di gestire il numero di scatti, il tempo dello scatto e la pausa tra gli scatti.
Permette di gestire anche la variazione del tempo di scatto (delta tempo) e della pausa tra gli scatti (delta pausa).
L’uso del seguente codice è libero e gratuito, purché venga sempre citato il nome dell’autore.
Il codice è stato sviluppato da Gianluca Bocci, sito web: www.gianlucabocci.it
Ultima revisione codice: 25/10/2014
*/

#include <Wire.h> //libreria necessaria per far funzionare componenti I2C
#include <LCD.h> //libreria necessaria per far funzionare il LCD
#include <LiquidCrystal_I2C.h> //libreria necessaria per far funzionare il LCD I2C
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // definizione parametri LCD I2C (Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity)

#define RELAY_ON 1
#define RELAY_OFF 0
#define Relay_1 1 // assegnazione PIN digitale I/O al primo relé o fotoaccoppiatore
#define Relay_2 2 // assegnazione PIN digitale I/O al secondo relé o fotoaccoppiatore

const int buttonPin = 0; //pin digitale assegnato alla pressione del joystick
int buttonState = 0; // variabile per leggere lo stato per pulsante del joystick

const int MicPin = 3; // pin digitale assegnato al modulo microfono
int MicState = 0; // variabile per leggere lo stato del modulo microfono

const int PIRPin = 4; // pin digitale assegnato al modulo di prossimità
int PIRState = 0; // variabile per leggere lo stato del modulo prossimità

int AsseX = A3;
int AsseY = A2;

int ValoreX = 0;
int ValoreY = 0;

unsigned int Scelta = 1; //scelta tra le varie opzioni di scatto
unsigned int NumScatti = 100; //numero di scatti da effettuare
long TempoScatto = 1000; //tempo minimo 1/10s = 100ms
long PausaScatto = 0; //tempo tra uno scatto e quello successivo
int DeltaTempo = 0; //eventuale variazione del tempo di scatto per adeguarsi all’aumentare o diminuire della luce ambiente
int DeltaPausa = 0; //eventuale variazione del tempo tra uno scatto e quello successivo per accelerare o decelerare il time lapse
long TempoAtt = 0; //durata dell’ultimo scatto
long PausaAtt = 0; //durata dell’ultima pausa
unsigned int ScattiRim = 0; //variabile per visualizzare gli scatti rimanenti
int Refresh = 100; //tempo di refresh, utile per regolare la velocità di variazione dei valori inseriti

void setup()
{
lcd.begin(16,2);
lcd.print(“TELECOMANDUINO”);
lcd.setCursor(0, 1);
lcd.print(“di G.Bocci 2014″);
delay(2000);

pinMode(Relay_1, OUTPUT); //imposta quali pin digitali siano impostati in input oppure in output
pinMode(Relay_2, OUTPUT);
pinMode(buttonPin, INPUT);
pinMode(MicPin, INPUT);
pinMode(PIRPin, INPUT);
}

void loop()
{
digitalWrite(Relay_1, RELAY_OFF); //inizializza i relé o fotoaccoppiatori impostandoli su spenti
digitalWrite(Relay_2, RELAY_OFF);

lcd.clear();
lcd.print(“…”);
delay(2000);

LeggiScelta(); // richiama la funzione che legge la scelta funzione
delay(1000);

switch (Scelta) {
case 1:
LeggiTempoScatto(); // richiama funzione che legge il numero di scatti
delay(1000);
LeggiPausaScatto(); // richiama funzione che legge la pausa prima dello scatto singolo o tra gli scatti intervallati
delay(1000);
Singolo();
break;
case 2:
LeggiNumScatti(); // richiama funzione che legge il numero di scatti
delay(1000);
LeggiTempoScatto(); // richiama funzione che legge il tempo di scatto
delay(1000);
LeggiDeltaTempo(); // richiama funzione che legge l’eventuale variazione del tempo di scatto
delay(1000);
LeggiPausaScatto(); // richiama funzione che legge la pausa prima dello scatto singolo o tra gli scatti intervallati
delay(1000);
LeggiDeltaPausa(); // richiama funzione che legge l’eventuale variazione della pausa tra gli scatti
delay(1000);
ScattiRim = NumScatti;
TempoAtt = TempoScatto;
PausaAtt = PausaScatto;
Intervallo(); // richiama funzione che gestice lo scatto ad intervallo
break;
case 3:
LeggiPausaScatto(); // richiama funzione che legge la pausa prima dello scatto singolo o tra gli scatti intervallati
delay(1000);
Microfono();
break;
case 4:
LeggiPausaScatto(); // richiama funzione che legge la pausa prima dello scatto singolo o tra gli scatti intervallati
delay(1000);
PIR();
break;

}
}

void LeggiScelta()
{
buttonState = digitalRead(buttonPin);

while(buttonState == HIGH) {

switch (Scelta) {
case 1:
lcd.setCursor(0, 0);
lcd.print(“1:SING* 2:INTE “);
lcd.setCursor(0, 1);
lcd.print(“3:MICR 4:PROS “);
break;
case 2:
lcd.setCursor(0, 0);
lcd.print(“1:SING 2:INTE* “);
lcd.setCursor(0, 1);
lcd.print(“3:MICR 4:PROS “);
break;
case 3:
lcd.setCursor(0, 0);
lcd.print(“1:SING 2:INTE “);
lcd.setCursor(0, 1);
lcd.print(“3:MICR* 4:PROS “);
break;
case 4:
lcd.setCursor(0, 0);
lcd.print(“1:SING 2:INTE “);
lcd.setCursor(0, 1);
lcd.print(“3:MICR 4:PROS* “);
break;
}

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (Scelta < 4) {
Scelta = Scelta+1;
}
}
if (ValoreX < 200) {
if (NumScatti > 1) {
Scelta = Scelta-1;
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (Scelta < 4) {
Scelta = Scelta+1;
}
}
if (ValoreY > 800) {
if (Scelta > 1) {
Scelta = Scelta-1;
}
}

delay(Refresh);

buttonState = digitalRead(buttonPin);

}
}

void LeggiNumScatti()
{
buttonState = digitalRead(buttonPin);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Numero Scatti:”);
lcd.setCursor(0, 1);
lcd.print(NumScatti);

while(buttonState == HIGH) {

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (NumScatti <= 9999) {
NumScatti = NumScatti+1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(NumScatti);

}
}
if (ValoreX < 200) {
if (NumScatti >= 1) {
NumScatti = NumScatti-1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(NumScatti);
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (NumScatti <= 9989) {
NumScatti = NumScatti+10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(NumScatti);
}
}
if (ValoreY > 800) {
if (NumScatti >= 11) {
NumScatti = NumScatti-10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(NumScatti);
}
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}

void LeggiTempoScatto()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Tempo di Scatto:”);
lcd.setCursor(0, 1);
lcd.print(TempoScatto);
lcd.setCursor(13, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (TempoScatto <= 999000) {
TempoScatto = TempoScatto+100;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(TempoScatto);
}
}
if (ValoreX < 200) {
if (TempoScatto >= 200) {
TempoScatto = TempoScatto-100;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(TempoScatto);
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (TempoScatto <= 998000) {
TempoScatto = TempoScatto+1000;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(TempoScatto);
}
}
if (ValoreY > 800) {
if (TempoScatto >= 1100) {
TempoScatto = TempoScatto-1000;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(TempoScatto);
}
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}

void LeggiDeltaTempo()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Delta Tempo:”);
lcd.setCursor(0, 1);
lcd.print(DeltaTempo);
lcd.setCursor(13, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (DeltaTempo <= 99998) {
DeltaTempo = DeltaTempo+1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaTempo);
}
}
if (ValoreX < 200) {
if (DeltaTempo >= -99998) {
DeltaTempo = DeltaTempo-1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaTempo);
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (DeltaTempo <= 99989) {
DeltaTempo = DeltaTempo+10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaTempo);
}
}
if (ValoreY > 800) {
if (DeltaTempo >= -99989) {
DeltaTempo = DeltaTempo-10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaTempo);
}
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}

void LeggiPausaScatto()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Pausa/Ritardo:”);
lcd.setCursor(0, 1);
lcd.print(PausaScatto);
lcd.setCursor(13, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (PausaScatto <= 999000) {
PausaScatto = PausaScatto+10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(PausaScatto);
}
}
if (ValoreX < 200) {
if (PausaScatto >= 10) {
PausaScatto = PausaScatto-10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(PausaScatto);
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (PausaScatto <= 998000) {
PausaScatto = PausaScatto+1000;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(PausaScatto);
}
}
if (ValoreY > 800) {
if (PausaScatto >= 1100) {
PausaScatto = PausaScatto-1000;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(PausaScatto);
}
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}

void LeggiDeltaPausa()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Delta Pausa:”);
lcd.setCursor(0, 1);
lcd.print(DeltaPausa);
lcd.setCursor(13, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {

ValoreX = analogRead(AsseX);
if (ValoreX > 800) {
if (DeltaPausa <= 99998) {
DeltaPausa = DeltaPausa+1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaPausa);
}
}
if (ValoreX < 200) {
if (DeltaPausa >= -99998) {
DeltaPausa = DeltaPausa-1;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaPausa);
}
}

ValoreY = analogRead(AsseY);
if (ValoreY < 200) {
if (DeltaPausa <= 99989) {
DeltaPausa = DeltaPausa+10;
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaPausa);
}
}
if (ValoreY > 800) {
if (DeltaPausa >= -99989) {
lcd.setCursor(0, 1);
lcd.print(” “);
lcd.setCursor(0, 1);
lcd.print(DeltaPausa);
DeltaPausa = DeltaPausa-10;
}
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}

void Singolo()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Tempo:”);
lcd.setCursor(6, 0);
lcd.print(TempoScatto);
lcd.setCursor(14, 0);
lcd.print(“ms”);
lcd.setCursor(0, 1);
lcd.print(“Pausa:”);
lcd.setCursor(6, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {
ValoreX = analogRead(AsseX);
ValoreY = analogRead(AsseY);
if (ValoreX > 800 || ValoreX < 200 || ValoreY < 200 || ValoreY > 800) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Scatto…”);
delay(PausaScatto);
digitalWrite(Relay_1, RELAY_ON);
digitalWrite(Relay_2, RELAY_ON);
delay(TempoScatto);
digitalWrite(Relay_1, RELAY_OFF);
digitalWrite(Relay_2, RELAY_OFF);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Tempo:”);
lcd.setCursor(6, 0);
lcd.print(TempoScatto);
lcd.setCursor(14, 0);
lcd.print(“ms”);
lcd.setCursor(0, 1);
lcd.print(“Pausa:”);
lcd.setCursor(6, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);
}
delay(Refresh);
buttonState = digitalRead(buttonPin);
}
}
void Microfono()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Microfono attivo”);
lcd.setCursor(0, 1);
lcd.print(“Ritardo:”);
lcd.setCursor(8, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {
MicState = digitalRead(MicPin);
if (MicState == LOW) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Scatto…”);
delay(PausaScatto);
digitalWrite(Relay_1, RELAY_ON);
digitalWrite(Relay_2, RELAY_ON);
delay(TempoScatto);
digitalWrite(Relay_1, RELAY_OFF);
digitalWrite(Relay_2, RELAY_OFF);
lcd.clear();
lcd.print(“Microfono attivo”);
lcd.setCursor(0, 1);
lcd.print(“Ritardo:”);
lcd.setCursor(8, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);
}

buttonState = digitalRead(buttonPin);
}
}

void PIR()
{
buttonState = digitalRead(buttonPin);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“PIR attivo”);
lcd.setCursor(0, 1);
lcd.print(“Ritardo:”);
lcd.setCursor(8, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);

while(buttonState == HIGH) {
PIRState = digitalRead(PIRPin);
if (PIRState == HIGH) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Scatto…”);
delay(PausaScatto);
digitalWrite(Relay_1, RELAY_ON);
digitalWrite(Relay_2, RELAY_ON);
delay(TempoScatto);
digitalWrite(Relay_1, RELAY_OFF);
digitalWrite(Relay_2, RELAY_OFF);
lcd.clear();
lcd.print(“PIR attivo”);
lcd.setCursor(0, 1);
lcd.print(“Ritardo:”);
lcd.setCursor(8, 1);
lcd.print(PausaScatto);
lcd.setCursor(14, 1);
lcd.print(“ms”);
delay(5000); //impedisce che vengano effettuati altri scatti prima di 5 secondi
}

buttonState = digitalRead(buttonPin);
}
}

void Intervallo()
{
for (int i=0; i < NumScatti; i++){
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“S:”);
lcd.setCursor(2, 0);
lcd.print(i);
lcd.setCursor(8, 0);
lcd.print(“T:”);
lcd.setCursor(10, 0);
lcd.print(TempoAtt);
lcd.setCursor(0, 1);
lcd.print(“R:”);
lcd.setCursor(2, 1);
lcd.print(ScattiRim);
lcd.setCursor(8, 1);
lcd.print(“P:”);
lcd.setCursor(10, 1);
lcd.print(PausaAtt);

digitalWrite(Relay_1, RELAY_ON);
digitalWrite(Relay_2, RELAY_ON);
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {
loop();
}
delay(TempoAtt);
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {
loop();
}
digitalWrite(Relay_1, RELAY_OFF);
digitalWrite(Relay_2, RELAY_OFF);
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {
loop();
}
delay(PausaAtt);
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) {
loop();
}
ScattiRim = ScattiRim-1;
TempoAtt = TempoAtt + DeltaTempo;
PausaAtt = PausaAtt + DeltaPausa;
}
}