Arkadian.eu

const int buttonPin = 2;     
const int ledPin =  13;      
int buttonState = 0;         
 
void setup() {
  Serial.begin(9600); 
  pinMode(ledPin, OUTPUT);      
  pinMode(buttonPin, INPUT);     
}
 
void loop(){
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {     
    digitalWrite(ledPin, HIGH);  
    Serial.print("a");
    delay(2000);
  }  
  else {
    digitalWrite(ledPin, LOW); 
  }
}

a:: 
Run "C:\Program Files\QuickTime\QuickTimePlayer.exe" "C:\your video path\Video_A.avi"
return

///////////////////////////////////////////////////
int swPin  =  5;  // 12-step switch
int ledPin = 13;  // Blue & pcb leds
int camPin = 12;  // Camera pin
 
int sw    = 0;  // 12-step resistance value
int stage = 1;  // 12-step stage (i.e. 1 - 12)
 
// this delay is specified by the rotary switch
int  delaySec;   
 
// this is the current second count
long currentSec = 0;   
 
// this is how long the shutter switch will be on
long shutterSec  = 100; 
 
///////////////////////////////////////////////////
void setup() {
 
  // declare the swPin & ledPin as an OUTPUTs
  pinMode(ledPin, OUTPUT);  
  pinMode(swPin,  OUTPUT);
 
// the serial is only used for debugging and for
// the calibration of the rotary switch  
//  Serial.begin(9600); 
 
}
 
///////////////////////////////////////////////////
// I 
void loop() {
  readSwitch();
  timeCheck();
 
// printLine is only used for debugging and for
// the calibration of the rotary switch
//  printLine(); 
}
 
///////////////////////////////////////////////////
///////////////////////////////////////////////////
void timeCheck(){
  if(delaySec<=currentSec){
 
    digitalWrite(ledPin, HIGH);  // turn the ledPin on
    digitalWrite(camPin, HIGH);  // turn the camPin on
 
    delay(shutterSec); // keep the led and the switch on
 
    digitalWrite(ledPin, LOW);   // turn the ledPin off
    digitalWrite(camPin, LOW);   // turn the camPin off
 
    delay(1000-shutterSec);
    currentSec = 0;
  }
 
  else{
    delay(1000);
    currentSec = currentSec + 1;
  }
}
///////////////////////////////////////////////////
void readSwitch(){
 
  // read the value from the sensor
  sw = analogRead(swPin);  
 
// the serial is only used for debugging and for
// the calibration of the rotary switch 
//  Serial.print(sw);
 
  if(sw>=0  && sw< 20) {
    stage =  1; 
    delaySec =   10;
  } // 10 secs
  if(sw>=20  && sw< 110) {
    stage =  2; 
    delaySec =   20;
  } // 20 secs
  if(sw>=110  && sw< 200) {
    stage =  3; 
    delaySec =   30;
  } // 30 secs
  if(sw>=200  && sw< 290) {
    stage =  4; 
    delaySec =   60;
  } // 1 min
  if(sw>=290  && sw< 380) {
    stage =  5; 
    delaySec =   90;
  } // 1.5 mins
  if(sw>=380  && sw< 480) {
    stage =  6; 
    delaySec =  120;
  } // 2 mins
  if(sw>=480  && sw< 570) {
    stage =  7; 
    delaySec =  180;
  } // 3 mins
  if(sw>=570  && sw< 660) {
    stage =  8; 
    delaySec =  300;
  } // 5 mins
  if(sw>=660  && sw<750) {
    stage =  9; 
    delaySec =  600;
  } // 10 mins
  if(sw>=750 && sw<850) {
    stage = 10; 
    delaySec =  900;
  } // 15 mins
  if(sw>=850 && sw<950) {
    stage = 11; 
    delaySec = 1200;
  } // 20 mins 
  if(sw>=950 && sw<1024) {
    stage = 12; 
    delaySec = 1800;
  } // 30 mins
}
///////////////////////////////////////////////////
void printLine(){
  Serial.print(" - Stage: ");
  Serial.print(stage);  
  Serial.print(" (");
  Serial.print(delaySec);    
  Serial.print(") - Next shot in: ");
  Serial.print(delaySec - currentSec);    
  Serial.println();
}
///////////////////////////////////////////////////

PFont myFont;
PFont myFont2;
 
float thisStage;
float nextStage;
 
float tp24 = TWO_PI/24;
 
void setup() {
  size(750, 1070);
  background(255);
 
  smooth();
  noStroke();
 
  float adj = -17 * tp24; 
  float space = TWO_PI/120;
  int diameter = 400;
 
  String[] stage = {    
    "10 s", "20 s", "30 s" , "1 m", 
    "1.5 m", "2 m", "3 m", "5 m", 
    "10 m", "15 m", "20 m", "30 m"  };
 
 
//remember to create the Arial-BoldMT-48 font
//otherwise this is not going to work...
  myFont = createFont("Arial-BoldMT-48", 18,true);
  myFont2 = createFont("Arial-BoldMT-48", 38,true);
 
  for (int i = 0; i < stage.length; i++){
 
    thisStage = (TWO_PI * i /12  - adj);
    nextStage = (TWO_PI *(i+1)/12 - adj);
 
    fill(0,50,100);
    noStroke();
    arc(width/2, 225, diameter, diameter, thisStage, nextStage);
    fill(255);
    arc(width/2, 225, diameter, diameter, nextStage  - space, nextStage);
    arc(width/2, 225, diameter, diameter, thisStage, thisStage + space);
 
    fill(150);
    stroke(150);
    textFont(myFont); 
 
    textAlign(CENTER,CENTER); 
    text(stage[i],(width/2) + diameter * 0.43 * cos( thisStage + tp24 ), 
225 + diameter * 0.43 *sin(thisStage + tp24 ));   
 
  }
 
  //this is the middle white circle
  fill(255);
  ellipse(width/2, 225, diameter * 0.6, diameter * 0.6);
 
  fill(0,50,100);
  noStroke();
  rect(0,0,150,150);
  rect(width-150,0,150,150);
  rect(0,450,width,150);
  rect(0,height-150,width,150);
 
  fill(0);
  stroke(0);
 
  textFont(myFont2); 
  textAlign(CENTER,CENTER); 
  text("Arduino-based Intervalometer 
\n for Fuji Digital SLRs", width/2,height -150 - (450/2) );   
 
  textFont(myFont); 
  textAlign(CENTER,CENTER); 
  text("www.arkadian.eu", width/2,height -200);   
 
  fill(0,50,100,100);
  noStroke();
  for(int x = 1; x < 30; x++){
    rect(int(random(0,width)),int(random(450,height-150)),20,20);
  }
  saveFrame("frame.png"); 
}

#include <EEPROM.h>
 
//RGB LED pins - These pins must be PWM
//here: 9 = redPin, 10 = greenPin, 11 = bluePin
int ledAnalogOne[] = {
  9, 10, 11}; 
 
// Push button, any free digital pin will do
int myButton = 7;
// I will fix pin 13 at HIGH at setup and use it as another voltage pin.
// It also lights the onboard led.
int my13 = 13;
 
// Reading the previous selection from the eeprom memory
int myOption = EEPROM.read(0);
 
int options = 15;
 
// these following are useful for debouncing
int mydelay = 10;
int reading = 0;
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 300;   // the debounce time; increase if the output flickers
 
//Defined Colors (different RGB (red, green, blue) values for colors
const byte RED[] =     {255, 0, 0}; 
const byte ORANGE[] =  {83, 4, 0}; 
const byte YELLOW[] =  {255, 255, 0}; 
const byte GREEN[] =   {0, 255, 0}; 
const byte BLUE[] =    {0, 0, 255}; 
const byte WHITE[] =   {255, 255, 255}; 
const byte BLACK[] =   {0, 0, 0}; 
const byte PINK[] =    {158, 4, 79}; 
const byte B2[] =      {0, 128, 255}; 
const byte G2[] =      {128, 255, 0}; 
const byte R2[] =      {255, 128, 0}; 
const byte B3[] =      {128, 0, 255}; 
const byte G3[] =      {0, 255, 128}; 
const byte R3[] =      {255, 0, 128}; 
 
byte myOldC[] = {255, 255, 255};
 
void setup(){
for(int i = 0; i < 3; i++){pinMode(ledAnalogOne[i], OUTPUT);}
setColor(ledAnalogOne, BLACK);       //Turn off led 1
pinMode(my13, OUTPUT);   
digitalWrite(my13, HIGH);
Serial.begin (9600);
}
 
void loop(){  
 
  readButton();
 
    if(myOption==0){
    mydelay = 15;
    randomC();
    }
 
    if(myOption==1){
    mydelay = 0;
    setColor(ledAnalogOne, RED);
    }    
 
    if(myOption==2){
    mydelay = 0;
    setColor(ledAnalogOne, BLUE);
    }       
 
    if(myOption==3){
    mydelay = 0;
    setColor(ledAnalogOne, GREEN);
    }  
 
    if(myOption==4){
    mydelay = 0;
    setColor(ledAnalogOne, YELLOW);
    }  
 
    if(myOption==5){
    mydelay = 0;
    setColor(ledAnalogOne, PINK);
    }    
 
    if(myOption==6){
    mydelay = 0;
    setColor(ledAnalogOne, ORANGE);
    } 
 
    if(myOption==7){
    mydelay = 0;
    setColor(ledAnalogOne, B2);
    }  
 
    if(myOption==8){
    mydelay = 0;
    setColor(ledAnalogOne, G2);
    }  
 
    if(myOption==9){
    mydelay = 0;
    setColor(ledAnalogOne, R2);
    }     
 
    if(myOption==10){
    mydelay = 0;
    setColor(ledAnalogOne, B3);
    }  
 
    if(myOption==11){
    mydelay = 0;
    setColor(ledAnalogOne, G3);
    }  
 
    if(myOption==12){
    mydelay = 0;
    setColor(ledAnalogOne, R3);
    }     
 
    if(myOption==13){
    mydelay = 0;
    setColor(ledAnalogOne, WHITE);
    }    
 
    if(myOption==14){
    mydelay = 0;
    setColor(ledAnalogOne, BLACK);
    } 
}
//////////////////////////////////////////////////////////////
 
void readButton(){
 
   reading = digitalRead(myButton);
   if ((millis() - lastDebounceTime) > debounceDelay && digitalRead(myButton)== HIGH) {
     // whatever the reading is at, it's been there for longer
     // than the debounce delay, so take it as the actual current state:
     lastDebounceTime = millis();
 
   myOption = (myOption + 1) % options;
   EEPROM.write(0, myOption);
//   Serial.print ("PRESSED - ");
//   Serial.println (myOption);
   }
}
 
 
//////////////////////////////////////////////////////////////
void randomC(){
 int tmp = int(random(0,12));
 byte myRandomC[] = {0,0,0};
 
  if(tmp == 0){for(int i = 0; i < 3; i++){myRandomC[i] = RED[i];}}
  if(tmp == 1){for(int i = 0; i < 3; i++){myRandomC[i] = ORANGE[i];}}
  if(tmp == 2){for(int i = 0; i < 3; i++){myRandomC[i] = YELLOW[i];}}
  if(tmp == 3){for(int i = 0; i < 3; i++){myRandomC[i] = GREEN[i];}}
  if(tmp == 4){for(int i = 0; i < 3; i++){myRandomC[i] = BLUE[i];}}
  if(tmp == 5){for(int i = 0; i < 3; i++){myRandomC[i] = B2[i];}}
  if(tmp == 6){for(int i = 0; i < 3; i++){myRandomC[i] = G2[i];}}
  if(tmp == 7){for(int i = 0; i < 3; i++){myRandomC[i] = R2[i];}}
  if(tmp == 8){for(int i = 0; i < 3; i++){myRandomC[i] = B3[i];}}
  if(tmp == 9){for(int i = 0; i < 3; i++){myRandomC[i] = G3[i];}}
  if(tmp ==10){for(int i = 0; i < 3; i++){myRandomC[i] = R3[i];}}
  if(tmp ==11){for(int i = 0; i < 3; i++){myRandomC[i] = WHITE[i];}}
  if(tmp ==12){for(int i = 0; i < 3; i++){myRandomC[i] = PINK[i];}}
 
    fadeToColor(ledAnalogOne, myOldC, myRandomC,  mydelay );     
 
    myOldC[0]= myRandomC[0];
    myOldC[1]= myRandomC[1];
    myOldC[2]= myRandomC[2];
}
 
//////////////////////////////////////////////////////////////
////////////// Functions from oomlout.co.uk.... //////////////
//////////////////////////////////////////////////////////////
/* Sets the color of the LED to any RGB Value
 led - (int array of three values defining the LEDs pins (led[0] = redPin, led[1] = greenPin, led[2] = bluePin))
 color - (byte array of three values defing an RGB color to display (color[0] = new Red value, color[1] = new Green value, color[2] = new Red value
 */
void setColor(int* led, byte* color){
  for(int i = 0; i < 3; i++){             //iterate through each of the three pins (red green blue)
    analogWrite(led[i], 255 - color[i]);  //set the analog output value of each pin to the input value (ie led[0] (red pin) to 255- color[0] (red input color)
    //we use 255 - the value because our RGB LED is common anode, this means a color is full on when we output analogWrite(pin, 0)
    //and off when we output analogWrite(pin, 255). 
  }
}
 
/* A version of setColor that takes a predefined color (neccesary to allow const int pre-defined colors */
void setColor(int* led, const byte* color){
  byte tempByte[] = {color[0], color[1], color[2]};
  setColor(led, tempByte);
}
 
/* Fades the LED from a start color to an end color at fadeSpeed
 led - (int array of three values defining the LEDs pins (led[0] = redPin, led[1] = greenPin, led[2] = bluePin))
 startCcolor - (byte array of three values defing the start RGB color (startColor[0] = start Red value, startColor[1] = start Green value, startColor[2] = start Red value
 endCcolor - (byte array of three values defing the finished RGB color (endColor[0] = end Red value, endColor[1] = end Green value, endColor[2] = end Red value
 fadeSpeed - this is the delay in milliseconds between steps, defines the speed of the fade
 */
void fadeToColor(int* led, byte* startColor, byte* endColor, int fadeSpeed){
  int changeRed = endColor[0] - startColor[0];                            //the difference in the two colors for the red channel
  int changeGreen = endColor[1] - startColor[1];                          //the difference in the two colors for the green channel 
  int changeBlue = endColor[2] - startColor[2];                           //the difference in the two colors for the blue channel
  int steps = max(abs(changeRed),max(abs(changeGreen), abs(changeBlue))); //make the number of change steps the maximum channel change
 
    for(int i = 0 ; i < steps; i++){                                       //iterate for the channel with the maximum change
    byte newRed = startColor[0] + (i * changeRed / steps);                 //the newRed intensity dependant on the start intensity and the change determined above
    byte newGreen = startColor[1] + (i * changeGreen / steps);             //the newGreen intensity
    byte newBlue = startColor[2] + (i * changeBlue / steps);               //the newBlue intensity
    byte newColor[] = {newRed, newGreen, newBlue};                         //Define an RGB color array for the new color
    setColor(led, newColor);    //Set the LED to the calculated value
    readButton();  
    if(myOption==0){delay(fadeSpeed);}  
  }
  setColor(led, endColor);                 //The LED should be at the endColor but set to endColor to avoid rounding errors
}
 
/* A version of fadeToColor that takes predefined colors (neccesary to allow const int pre-defined colors */
void fadeToColor(int* led, const byte* startColor, const byte* endColor, int fadeSpeed){
  byte tempByte1[] = {startColor[0], startColor[1], startColor[2]};
  byte tempByte2[] = {endColor[0], endColor[1], endColor[2]};
  fadeToColor(led, tempByte1, tempByte2, fadeSpeed);
}
//////////////////////////////////////////////////////////////