Show Posts
Pages: [1]
1  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: May 05, 2013, 05:24:19 am
Isto é uma autêntica montanha para mim  smiley-eek uma coisa que parece tão simples,afinal é tão complexa  smiley-eek

No enxerto que meteste ainda falta configurar o menu da gota 2,certo?

Meti o código,mas diz-me que "TRUE" não está declarado...
2  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: May 05, 2013, 04:04:18 am
Eu bem tenho estudado,mas isto é muito complicado para alguém como eu que não tem bases nenhumas nisto...

Estive a tentar perceber quantos menus preciso e parece.me que bastam 3:

MENU ENTRADA
linha 1 -------------Gota_1
linha 2--------------Gota_2

MENU_1_Gota_1
linha 1--------------Tamanho(1º tempo da minha sequência_tempos)
linha 2--------------Tempo_Atraso(2º tempo da minha sequência_tempos)

MENU_2_Gota_2
linha 1--------------Tamanho(3º tempo da minha sequência_tempos)
linha 2--------------Tempo_Atraso(4º tempo da minha sequência_tempos)

Os outros tempos serão fixos depois dos ajustes iniciais...
Mas estou com extrema dificuldade em criar os menus e a navegação através das teclas,por mais que me esforce,parece-me uma tarefa impossível para mim.

Penso que a questão da definição das teclas consigo fazer,mas isso é só ir à biblioteca da minha Shield e copiar,a biblioteca está aqui: http://linksprite.com/wiki/index.php5?title=16_X_2_LCD_Keypad_Shield_for_Arduino

Eu não estou a conseguir passar disto:

Code:
/*--------------------------------------------------------------------------------------
  Includes
--------------------------------------------------------------------------------------*/
#include <LiquidCrystal.h>   // include LCD library
/*--------------------------------------------------------------------------------------
  Defines
--------------------------------------------------------------------------------------*/

// Pins in use
#define BUTTON_ADC_PIN           A0  // A0 is the button ADC input
#define LCD_BACKLIGHT_PIN         10  // D10 controls LCD backlight
// ADC readings expected for the 5 buttons on the ADC input
#define RIGHT_10BIT_ADC           0  // right
#define UP_10BIT_ADC            145  // up
#define DOWN_10BIT_ADC          329  // down
#define LEFT_10BIT_ADC          505  // left
#define SELECT_10BIT_ADC        741  // right
#define BUTTONHYSTERESIS         10  // hysteresis for valid button sensing window
//return values for ReadButtons()

#define BUTTON_NONE               0  //
#define BUTTON_RIGHT              1  //
#define BUTTON_UP                 2  //
#define BUTTON_DOWN               3  //
#define BUTTON_LEFT               4  //
#define BUTTON_SELECT             5  //
//some example macros with friendly labels for LCD backlight/pin control, tested and can be swapped into the example code as you like
#define LCD_BACKLIGHT_OFF()     digitalWrite( LCD_BACKLIGHT_PIN, LOW )
#define LCD_BACKLIGHT_ON()      digitalWrite( LCD_BACKLIGHT_PIN, HIGH )
#define LCD_BACKLIGHT(state)    { if( state ){digitalWrite( LCD_BACKLIGHT_PIN, HIGH );}else{digitalWrite( LCD_BACKLIGHT_PIN, LOW );} }
//Numero de Menus
#define Numero_de_Menus    3
/*--------------------------------------------------------------------------------------
  Variables
--------------------------------------------------------------------------------------*/
byte buttonJustPressed  = false;         //this will be true after a ReadButtons() call if triggered
byte buttonJustReleased = false;         //this will be true after a ReadButtons() call if triggered
byte buttonWas          = BUTTON_NONE;   //used by ReadButtons() for detection of button events
/*--------------------------------------------------------------------------------------
  Init the LCD library with the LCD pins to be used
--------------------------------------------------------------------------------------*/
LiquidCrystal lcd( 8, 9, 4, 5, 6, 7 );   //Pins for the freetronics 16x2 LCD shield. LCD: ( RS, E, LCD-D4, LCD-D5, LCD-D6, LCD-D7 )

//
unsigned long time;

#define PASSOS     8


const char pushButtonPin = 29;  //botão de inicio ligado ao pinp 13
const char cameraPin = 25;   //shutter da máquina ligado ao pino 10
const char valvulaPin = 27;  //válvula ligada ao pino 11
const char flashPin = 23;    //flash ligado ao pino 12

//sequências...
/*
As sequências são definidas por bits. cada unsigned char tem 8 bits.
Estados                     0    1    2    3    4    5    6    7

bit 0 - valvulaPin          1 -- 0 -- 1 -- 0 -- 0 -- 0 -- 0 -- 0
bit 1 - cameraPin           0 -- 0 -- 0 -- 0 -- 1 -- 1 -- 1 -- 0
bit 2 - flashPin            0 -- 0 -- 0 -- 0 -- 0 -- 1 -- 0 -- 0

*/
unsigned char sequencia_pinos[7]; //imagine que a sequência tem 8 estados
unsigned long sequencia_tempos[7]; //tempos entre sequências...

void executa_sequencia(unsigned long start) {
   unsigned char seq_counter = 0;
   
   for (int i = 0; i < PASSOS; i++) { //percorre as sequencias
      do {
          digitalWrite(valvulaPin, (sequencia_pinos[i] & 0x1));
          digitalWrite(cameraPin, (sequencia_pinos[i] >> 1) & 0x1);
          digitalWrite(flashPin, (sequencia_pinos[i] >> 2) & 0x1);
         
      }while (millis() - start <= sequencia_tempos[i]); 
      start = millis(); //reinicializa temporizacção
   }//end for   
       
}

void setup()
{


   //button adc input
   pinMode( BUTTON_ADC_PIN, INPUT );         //ensure A0 is an input
   digitalWrite( BUTTON_ADC_PIN, LOW );      //ensure pullup is off on A0
   //lcd backlight control
   digitalWrite( LCD_BACKLIGHT_PIN, HIGH );  //backlight control pin D3 is high (on)
   pinMode( LCD_BACKLIGHT_PIN, OUTPUT );     //D3 is an output
   //set up the LCD number of columns and rows:
   lcd.begin( 16, 2 );
   //Print some initial text to the LCD.
   lcd.setCursor( 0, 0 );   //top left
   //          1234567890123456
   lcd.print( "Ola" );
   //
   lcd.setCursor( 0, 1 );   //bottom left
   //          1234567890123456
   lcd.print( "Pedro" );

 
//inicializa sequencia de pinos.
   sequencia_pinos[0] = 0b0000001;
   sequencia_pinos[1] = 0b0000000;
   sequencia_pinos[2] = 0b0000001;
   sequencia_pinos[3] = 0b0000000;
   sequencia_pinos[4] = 0b0000010;
   sequencia_pinos[5] = 0b0000110;
   sequencia_pinos[6] = 0b0000010;
   sequencia_pinos[7] = 0b0000000;

//inicializa sequencia de tempo. 
   sequencia_tempos[0] = 200; //tamanho gota 1
   sequencia_tempos[1] = 1000; //tempo que demora gota 1 cair
   sequencia_tempos[2] = 400; //tamanho gota 2
   sequencia_tempos[3] = 700; //tempo que demora gota 2 colidir com gota 1
   sequencia_tempos[4] = 200; //atraso entre abertura obturador e disparo do flash
   sequencia_tempos[5] = 10; //tempo de disparo do flash
   sequencia_tempos[6] = 100; //atraso fecho obturador depois do flash disparar

   pinMode(pushButtonPin,INPUT);    //inicia o botão como input
   pinMode(cameraPin,OUTPUT);    //inicia o shutter como output
   pinMode(valvulaPin,OUTPUT);   //inicia a válvula como output
   pinMode(flashPin,OUTPUT);     //inicia o flash como output

     
 }

 
 void loop() {
    if (digitalRead(pushButtonPin) == 1) { //carregaste no botão
        executa_sequencia(millis());
    }


 }


Preciso mesmo de um grande empurrão,se puderes ajudar,agradeço!
3  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: May 04, 2013, 04:56:32 am
... depois é uma questão de adicionar o LCD. Isso será o mais complicado. :\ LOL

Olá  smiley

Estive a ver onde conseguia chegar na configuração e nos menus do lcd,mas não me safo  smiley-eek é mesmo complicado para mim,podes abrir um pouco o caminho?Sozinho está visto que não vou lá!
4  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 29, 2013, 11:40:45 am
Não fiques assim... o teu código também funciona, mas não é muito flexível por causa dos delays.

Este é um pouco mais complexo, mas após compreenderes o objectivo torna-se simples.

Reparei que a parte da sequência estava desalinhada, se meteres alinhado talvez consigas ver melhor.
Os bits são vistos da direita para a esquerda, ou seja, o bit mais à direita é o zero, o seguinte à o um, etc... Esses bits indicam o estado das luzes ou válvula em cada momento. Como podes ver, no primeiro estado a lampada externa (que ainda não tens no teu sistema) está ligada para tu preparares tudo. Depois o estado 1 diz-te que a lâmpada está apagada e a válvula e obturador estão abertos. Depois apenas o obturador, depois o obturador e a válvula.

No setup tens a definicão da sequencia. Onde eu escrevi a explicacão da sequencia, o numero do estado é o indice do vector sequencia_pinos e o valor que eu coloquei é visto por de cima para baixo. Ou seja:

estado zero - 0b00000001
estado um  - 0b00000110
estado dois - 0b00000100

... estás a ver a mecânica?

O vector estado_tempos indica o tempo que demora a passar de estado para estado.
Hoje talvez tenha algum tempo para ver isto por casa com uns leds e se a sequencia funciona (ontem usei um bocado de código semelhante para simular um encoder, por isso deve dar). 

AHH,da direita para a esquerda  smiley  era isso que me estava a fazer confusão pois estava a tentar ler ao contrário,assim já estou a ver melhor,mas aquele primeiro "0" da esquerda e o "b",o que significam?

Vou estar uns dias sem internet e em principio só posso continuar isto no fim de semana,mas volto aqui logo que possa  smiley-wink
5  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 28, 2013, 05:14:49 pm
Bem,acho que ando a puxar demais pela cabeça...ainda não consegui perceber como controlar as sequências com oito bits,consigo perceber a ideia de ver isto como sequências e estados que se vão repetindo,mas a sequência de pinos não consigo compreender...

Consegui por o código a compilar,mas não o compreendi e não consigo trabalhar com ele...

Code:
//
unsigned long time;

#define PASSOS     8

const char luz_exteriorPin = 9;
const char pushButtonPin = 13;  //botão de inicio ligado ao pinp 13
const char cameraPin = 10;   //shutter da máquina ligado ao pino 10
const char valvulaPin = 11;  //válvula ligada ao pino 11
const char flashPin = 12;    //flash ligado ao pino 12

//sequências...
/*
As sequências são definidas por bits. cada unsigned char tem 8 bits.
Estados                  0     1    2     3    4    5     6     7
bit 0 - Luz exterior     1 -- 0 -- 0 -- 0 -- 0 -- 0 -- 0 -- 1
bit 1 - válvula          0 -- 1 -- 0 -- 1 -- 0 -- 0 -- 0 -- 0
bit 2 - obturador        0 -- 1 -- 1 -- 1 -- 1 -- 1 -- 1 -- 0
bit 3 - flash.           0 -- 0 -- 0 -- 0 -- 0 -- 1 -- 0 -- 0

*/
unsigned char sequencia_pinos[8]; //imagine que a sequência tem 8 estados
unsigned long sequencia_tempos[8]; //tempos entre sequências...

void executa_sequencia(unsigned long start) {
   unsigned char seq_counter = 0;
   
   for (int i = 0; i < PASSOS; i++) { //percorre as sequencias
      do {
          digitalWrite(luz_exteriorPin, (sequencia_pinos[i] & 0x1));
          digitalWrite(valvulaPin, (sequencia_pinos[i] >> 1) & 0x1);
          digitalWrite(cameraPin, (sequencia_pinos[i] >> 2) & 0x1);
          digitalWrite(flashPin, (sequencia_pinos[i] >> 3) & 0x1);
      }while (millis() - start <= sequencia_tempos[i]); 
      start = millis(); //reinicializa temporizacção
   }//end for   
       
}

void setup()
 {
//inicializa sequencia de pinos.
   sequencia_pinos[0] = 0b00000001;
   sequencia_pinos[1] = 0b00000000;
   sequencia_pinos[2] = 0;
   sequencia_pinos[3] = 0b00000010;
   sequencia_pinos[4] = 0b00000100;
   sequencia_pinos[5] = 0b00001100;
   sequencia_pinos[6] = 0b00000100;
   sequencia_pinos[0] = 0b00000001;

//inicializa sequencia de tempo. 
   sequencia_tempos[0] = 1000; //1000 para testar e ver se tudo funciona como deve ser.
   sequencia_tempos[1] = 1000;
   sequencia_tempos[2] = 1000;
   sequencia_tempos[3] = 1000;
   sequencia_tempos[4] = 1000;
   sequencia_tempos[5] = 1000;
   sequencia_tempos[6] = 1000;
   sequencia_tempos[7] = 1000;
   sequencia_tempos[8] = 1000;


   pinMode(pushButtonPin,INPUT);    //inicia o botão como input
   pinMode(cameraPin,OUTPUT);    //inicia o shutter como output
   pinMode(valvulaPin,OUTPUT);   //inicia a válvula como output
   pinMode(flashPin,OUTPUT);     //inicia o flash como output

     
 }

 
 void loop() {
    if (digitalRead(pushButtonPin) == 1) { //carregaste no botão
        executa_sequencia(millis());
    }


 }



Nota que isto tem bugs, mas é muito mais flexível pois podes aumentar o numero de saidas e tempos à sequência. Se perceberes como é feita a configuração das saídas com os tempos estás lançado. smiley
Tenta ver se compila e se faz o que pretendes (coloca uma sequência simples com alterações de luzes em todos os níveis para testar)
Se isto funcionar, depois é uma questão de adicionar o LCD. Isso será o mais complicado. :\ LOL


Se me puderes abrir os olhos ali na parte do void setup()  e na sequência de pinos talvez compreenda...
Adicionar o LCD é ainda mais complicado ainda?
Então acho que é melhor ficar por aqui,LOL
6  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 28, 2013, 07:28:00 am
Se queres ver a correspondência entre o pino que liga na máquina e o contacto do Jack usas um multimetro. A que te referes quando dizes ligar os fios directamente?
Em todo o caso, acho que não deves usar o jack e deves usar os fios directamente.

OK,já percebi,basta testar a continuidade dos fios.
Quanto a ligar os fios directamente,o que queria dizer era cortar o jack e fazer a ligação dos fios directamente no circuito ficando o cabo sempre ligado e depois era só ligar na máquina...não sei se me faço entender.


As fotos parecem-me todas iguais. Não leves a mal, mas não vejo distincão entre uma gota a bater na água e várias gotas. No entanto, isso são gostos e não importa para o proposito do projecto.


Acreditas que já tive a mesma opinião que tu?Tive mesmo e continuo a achar que fazer este tipo de imagens continuamente se torna monótono e não é isso que pretendo,o que quero é experimentar coisas novas na fotografia.

De qualquer forma para teres ideia da colisão entre gotas que falei vê estes vídeos: http://www.t-braeuning.de/index.php?ste=hsmv&lan=en


12V e pilhas são dois termos que não ligam muito bem... Podes ter problemas de corrente ao tentar activar a válvula. Até porque não vais ter o Arduino alimentado pelo computador (lembra-te que o computador emite luz que pode facilmente estragar a exposicão.


Então vou ter que procurar outra solução,talvez encontre uma fonte de alimentação barata...


O LCD shield é muito prático de utilizar e tem uma vantagem que é o controlo do backlight do LCD. Ao disparares uma sequência, podes desligar o backlight do LCD, esperar um pouco e iniciar tudo de seguida tendo garantido que estás em escuridão. Uma possibilidade, apesar de gastar mais hardware, até seria ter o Arduino a controlar todo o setup.
Ou seja, tinhas a válvula para soltar gotas, o controlo do flash, controlo do disparo e podias adicionar uma luz externa de 230V controlada por relé que era desligada sempre que quisesses bater a foto. Tu vais precisar duma boa luz para fazer o foco da foto, logo essa funcionalidade facilitaria o processo. Em vez de fazeres o setup, desligares a luz da sala e voltares a ligar depois de terminada a foto.


Parece-me que estou com um problema com o LCD Shield que comprei,é o modelo 'A' aqui: http://linksprite.com/wiki/index.php5?title=16_X_2_LCD_Keypad_Shield_for_Arduino

È o seguinte,depois de encaixar o LCD no Arduino fico sem acesso ás portas do mesmo...vou ter que encontrar uma solução para isto,tens alguma sugestão?

A ideia de adicionar uma luz externa ao setup é realmente muito bem pensado e interessante!


Se pesquisares na net sobre como ligares LEDs no Arduino, encontras imenso. Não precisas de muito, apenas uma resistência por LED.

Faz um bom plano do que pretendes antes de comecares o software para poderes dividir tudo por funcões.


Bem acho que está na hora de apresentar algum trabalho,estive a testar com leds e resistências e escrevi um código para ver se consigo aquilo que quero...de notar que nunca programei nenhum Arduino e há 3-4 semanas atrás nem sabia o que isso era,portanto o código que escrevi pode não fazer sentido nenhum,mas aparentemente pelo que observo no funcionamento dos leds,faz aquilo que pretendo.
Segue o código:

Code:
//
unsigned long time;

const int pushButton = 13;  //botão de inicio ligado ao pinp 13
const int cameraPin = 10;   //shutter da máquina ligado ao pino 10
const int valvulaPin = 11;  //válvula ligada ao pino 11
const int flashPin = 12;    //flash ligado ao pino 12

//

void setup()
 {
   pinMode(pushButton,INPUT);    //inicia o botão como input
   pinMode(cameraPin,OUTPUT);    //inicia o shutter como output
   pinMode(valvulaPin,OUTPUT);   //inicia a válvula como output
   pinMode(flashPin,OUTPUT);     //inicia o flash como output

    digitalWrite(pushButton,HIGH);   //inicia o programa ao pressionar o botão
    digitalWrite(cameraPin,HIGH);    //abre o obturador no modo bulb
    delay(10);                       //esta pausa é só para garantir que o obturador está completamente aberto
    digitalWrite(valvulaPin,HIGH);   //abre a vávula
    delay(200);                      //tameanho da gota 1
    digitalWrite(valvulaPin,LOW);    //fecha a válvula
    delay(360);                      //pausa para a gota um cair dentro do recipiente
    digitalWrite(valvulaPin,HIGH);   //abre novamente a válvula
    delay(50);                       //tamanho da gota 2
    digitalWrite(valvulaPin,LOW);    //fecha a válvula
    delay(400);                      //pausa pra gota 2 colidir com gota 1
    digitalWrite(flashPin,HIGH);     //dispara o flash
    delay(5);                        //muito pequena pausa
    digitalWrite(flashPin,LOW);      //deliga sinal para flash
    digitalWrite(cameraPin,LOW);     //fecha obturador
     
 }
 
 void loop()
 {
 Serial.print("Time: ");
 time = millis();
 Serial.println(time);
 delay(1000);
 }


Este até é um projecto que tem algum interesse para mim... mas não para fotografar gotas. Mais para apanhar os meus gatos... LOL

Muito bom o trocadilho,LOL
7  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 26, 2013, 12:15:49 pm
Multimetro... Eventualmente vais querer cortar o jack estéreo e usar os fios para garantir que não tens problemas de ligações.


Se ligar os fios directamente não há problema?


Ok... colisão entre duas gotas? Como assim?


Algo deste género,são colisões entre duas ou mais gotas: http://www.google.pt/search?hl=pt-PT&q=water+drop+collision&bav=on.2,or.r_qf.&bvm=bv.45645796,d.d2k&biw=1366&bih=606&um=1&ie=UTF-8&tbm=isch&source=og&sa=N&tab=wi&ei=Iqx6UfSgDKir7AaQx4HYDw


Sim, faz sentido. Se os números estiverem correctos. Mas então, para que queres controlar a máquina? A luz vai definir tudo com esta estratégia. Então apenas tens de controlar os flashs e a gota.


Vejo como vantagem poder controlar a máquina,o facto de poder ir apertando o tempo de exposição à medida que vou afinando o sistema e isso vai-me permitir trabalhar com mais luz ambiente.Outra vantagem é não ter que me preocupar em estar sempre com o comando na mão para abrir e fechar o obturador,o sistema fica mais autónomo,digámos.Mas é perfeitamente possível fazer o que quero sem controlar a máquina,o preço será trabalhar na escuridão.


Não gosto. :\


Gostos não se discutem,mas dá para ter uma ideia do que pretendo.

Sim, isso funciona para a válvula. Nota que a válvula não vai funcionar (ou dificilmente) com 5V do Arduino. Logo vais precisar duma fonte externa. Dito isto, se meteres um optoacoplador a activar a válvula será muito mais seguro.

Será uma válvula de 12V alimentada com pilhas...vou estudar a dica do optoacoplador  smiley-wink


Sim. Podes testar tudo com LEDs.

Algumas dicas:
NÃO USES O DELAY!!! ISSO NÃO SERVE PARA O QUE QUERES.
O millis ou micros talvez resultem... mas se usares os timers internos consegues resultados mais rápidos (pode não ser necessariamente o que pretendes).
Não uses o digitalWrite.
Pensa se pretendes ter um interface série ou um interface de botões e um LCD... Um interface série talvez seja mais simples de implementar... mas por outro lado é pior para usar. E tens de ter o computador por perto... o que estraga o plano da escuridão.

Com teclas ou uma espécie de encoder talvez seja simples de fazer isto. Uns quantos botões para escolher a variável que pretendes alterar... talvez diferentes modos de disparo...


Posso colocar um led no lugar da válvula para testar?Não estou a ver bem como fazer.

Sem dúvida que é muito mais prático poder operar o sistema através de um LCD com botões e esse será o caminho a seguir...Qual te parece melhor um LCD Shield  já com botões ou comprar LCD e botões separadamente e montar à posteriori?Por acaso já tenho um LCD Siheld 16x2...


Mas ainda falta muito para isso ficar pronto.

Acho que aqui dizes muita coisa  smiley-eek ainda tenho muita pedra para partir!

Obrigado pela tua disponibilidade em ajudar!
8  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 26, 2013, 08:57:39 am
Já tinha visto o pinout do conector que liga à máquina e o tal disparador remoto que tenho é igual ao do teu primeiro link do ebay,portanto não tenho dúvidas aí,só não estou a ver é como vou saber a correspondência correta do conector para a ficha jack estéreo macho,na outra ponta do cabo.

Tenho dois flah's,um Nikon SB-900 e um SB-700,mas como vou começar apenas com um,vou optar pelo SB-900 pelo facto de ter uma ficha PC Sync incorporada para ligar o cabo que o SB-700 não tem (este,além do cabo,é necessário um Hot Shoe com ficha PC Sync).

Quanto a deixar que a máquina controle o disparo do flash,não me parece a melhor solução porque fico muito limitado e talvez não consiga aquilo que pretendo,passo a explicar:a máquina só permite disparar o flash à primeira ou à segunda cortina,ou seja,logo após a abertura do obturador ou imediatamente antes do fecho do obturador,mas eu quero controlar o timing certo para que ele dispare (colisão entre duas gotas,por ex.) pois no fundo vai ser o clarão emitido pelo flash que vai congelar a acção e não o tempo de exposição (obturador aberto)

Isto pode parecer confuso,mas no fundo é uma questão de timing certo já que tudo se desenvolve num espaço de tempo na ordem dos milissegundos e mesmo utilizando a velocidade máxima que a minha (nossa  smiley-grin ) máquina permite (1/4 000 segundos) não é suficiente para congelar o movimento.

Acho que era preferível controlar apenas o flash e a válvula com o Arduino e fotografar ás escuras com a velocidade de obturador definida como Bulb (abre o obturador quando carregas no botão do obturador e só fecha quando largares) ou mesmo definir 2-3 segundos e deixar que o clarão emitido pelo flash congele o movimento no timing certo,isto com o SB-900 na potência mínima (é mesmo mínima) resulta num clarão que dura aproximadamente 1/40 000 segundos,uma velocidade 10x maior que a permitida pela máquina.
Para perceberes melhor isto das velocidades do flash,vê aqui: http://www.scantips.com/speed.html

O controlador da Cognysis (também têm um sistema para líquidos) é muito bom,mas também é muito caro e eu não ganho nada com a fotografia,antes pelo contrário  smiley-grin Com os teus conhecimentos podes meter mãos à obra e fazer um parecido  smiley

Concordo que fotografar uma simples gota de água não é nada de mais,mas eu queria elevar um pouco a fasquia...Já ouviste falar do Markus Reugels? Dá uma espreitadela: http://www.flickr.com/photos/maianer/

Resumindo,acho que tenho tudo o que preciso para meter mãos à obra menos os cabos e a válvula,por falar em válvula,que acham deste circuito:



Vou seguir o teu conselho e vou tentar montar o hardware com leds e começar a escrever código para ver no que dá e depois viro-me para a interface.Uma dúvida,como não tenho a válvula,posso testar o funcionamento do circuito com led?
9  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 26, 2013, 02:15:34 am
Olá,
Eu infelizmente sei mais de electrónica que fotografia (a julgar pelas minhas fotos pelo menos http://www.flickr.com/photos/99253632@N00/). Também tenho uma D90 parada lá por casa e não tenho ideia de como funciona o cabo de ligacão. Já tens um?

Assim de repente não tenho a certeza do funcionamento do flash (em tempos andei à ler sobre a D300 e as coisas ficaram confusas), mas sei que podes controlar o flash em avanco e atraso. Ou seja, quando tiras uma foto com tempos de exposicão longos, podes fazer com que o flash bata no inicio da exposicão ou no final. Isto dá o efeito de paragem no tempo... não consigo explicar melhor, só mesmo testando.

No entanto, no teu caso, tu queres tempos de exposicão curtos (daí o flash) para garantir que a foto sai bem focada e por isso acho que é preferível deixar a máquina controlar o flash e tu só controlas o disparo do sistema. Isto, claro está, se apenas usares um flash. Com um sistema coordenado, as coisas complicam exponencialmente.

Já viste isto?

http://arduino.cc/forum/index.php/topic,78336.0.html

Infelizmente creio que a marca era Canon. Mas dá para ver as possibilidades. Neste caso, o utilizador escolhe o delay entre a gota e fotografia para obter o melhor efeito.
Eu tenho ideia que houve mais um post aqui no fórum, mas não encontro. No entanto, isto já foi há mais de um ano. :\

O problema a meu ver é mais no hardware e ligacão do cabo à m´quina. O resto (software) é simples de fazer.

Olá,

Também não sou nenhum expert na fotografia,mas ainda assim sinto-me mais à vontade do que na electrónica  smiley-lol

Concordo contigo o hardware é uma parte importante para aquilo que quero fazer e preciso de ter a certeza que faço as coisas como deve ser,pois caso contrário corro o risco de fritar o equipamento.

Ainda não tenho o cabo que vai ligar a máquina ao sistema,mas tenho um disparador remoto que é praticamente igual,a única diferença é que em vez de ter uma ficha jack 3.5mm é de 2.5mm.

As fichas são estas:

Máquina


Saída jack 3.5


O problema é que não tenho 100% certeza se a pinagem para o jack é como mostra a figura.Pelo que pesquisei penso que sim,mas na Cannon por exemplo é diferente e estou confuso aí...ás tantas vou ter que abrir um cabo para me certificar.

Já tinha visto o post que referiste e a minha ideia é avançar para algo mais elaborado com 2-3 válvulas e 2-3 flash's (até porque neste momento tenho 2),mas quero começar com algo mais simples primeiro e quando me sentir mais à vontade,então sim,vou avançando aos poucos e talvez chegue a um controlador completo para fotografia de alta velocidade com vários sensores (som,infravermelho,impacto,válvulas solenoide),mas vamos com calma  smiley-lol para já o que quero é sincronizar uma válvula com máquina/flash.
10  International / Portugues / Re: Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 25, 2013, 12:43:03 pm
Ola bem vindo
Parece relativamente fácil de fazer, olhando para o teu circuito pra já só não estou a entender se na parte do flash, o Flash + é a alimentação a todo o flash ou apenas o sinal para fazer o flash disparar, algo como um sinal de comando e não de alimentação.Pergunto isto porque se a idea for desligar a alimentação do flash no foto-acoplador isso será de mais para ele pois ele apenas tolera uns mili-amperes.Necessitaras de um andar de potencia adicional.Se a ideia for apenas fazer o trigger do flash então parece me bem pra já.
Ja escreveste algum código?
Também não dizes o que o circuito tem de fazer em termos programa.


Obrigado HugoPT!

Na parte do flash é apenas para o fazer disparar quando eu quero,ele será alimentado normalmente pelas 4 pilhas e estará ligado ao Arduino através de um cabo de sincronismo.

Quanto ao código ainda não fiz nada e este nada é mesmo absoluto...nunca fiz nenhum código para Arduino!mas já tenho as pestanas queimadas de tanto estudar sobre o assunto.
Estou mesmo na fase inicial como disse,mas basicamente o que quero que o circuito faça é o seguinte:

1-Inicia o sistema,ainda não sei bem como,mas estou a pensar num botão ligado a um pino do Arduino (?)
   Ainda nesta fase também não sei se posso abrir o obturador através do Arduino (?) ou se vou ter que fotografar em Bulb
2-Válvula abre/fecha para que saia uma primeira gota
3-Pausa em milisegundos
4-Válvula abre/fecha novamente para que saia a segunda gota
5-Dispara o flash
6-Fecha o obturador

Olá Pedro. Se não se importar de me dizer, qual o modelo exato de sua DSLR?

Olá  smiley

Claro que não,é uma Nikon D90...

A máquina e o flash vão ligar ao circuito através dos respectivos cabos com fichas jack macho 3,5 mm...o flash é uma ficha mono e não tenho dificuldade em saber qual é o +,mas a máquina é uma ficha stereo,alguém me consegue dizer qual é o GND/Shutter/Autofocus (isto na ficha macho)

O cabo que a minha máquina utiliza é o Nikon MC-DC2
11  International / Portugues / Dúvida ligação máquina fotográfica DSLR ao Arduino on: April 25, 2013, 09:50:45 am
Olá pessoal,

O meu nome é Pedro,sou de Barcelos e tenho apenas os conhecimentos básicos de electrónica,que adquiri enquanto frequentei o curso de electrotecnia no secundário (já lá vão 15 anos  smiley-roll ) sem nunca ter trabalhado na área.

No entanto o bichinho da electrónica continua comigo e recentemente foi despertado por outra das minhas paixões:a fotografia!

Sou um fotografo entusiasta que se dedica sobretudo à macrofotografia e pretendo neste momento construir um sistema para fotografia de alta velocidade,nomeadamente para fotografar gotas de água!Só há relativamente pouco tempo tive conhecimento da existência do Arduino,mas desde aí já li bastante sobre o assunto e apesar de,como disse anteriormente,não ter muitos conhecimentos de electrónica e praticamente nulos de programação,sempre fui bastante autodidacta e sinto-me capaz de construir o tal controlador.

O que pretendo é um sistema baseado num Arduino que me permita controlar uma válvula solenoide,a máquina fotográfica e os flash's...neste momento ainda estou na fase inicial,já vi alguns esquemas eléctricos e já não tenho dúvidas quanto ao circuito para a válvula solenoide,mas ainda não sei muito bem como ligar os flash e a máquina (DSLR Nikon).Sei que tenho que usar optoacopoladores (dois no caso da máquina),mas ainda não vi nenhum circuito que me deixe 100% seguro daquilo que vou fazer.

Alguém me sabe dizer se o circuito que vou colocar a seguir está correcto?Ou sugerem outro?




Nota:Os optoacopoladores serão 4N25!

Um abraço,
Pedro

 
Pages: [1]