applet/Intervalometer.cpp

   1 #include "WProgram.h"
   2 /*
   3  *  Arduino Intervalometer
   4  *  Tim Horton, 2008
   5  */
   6
   7 /*
   8  *  Pin Assignment
   9  */
  10
  11 #define INTERVAL         0
  12 #define BULB             1
  13 #define INTERVALBULB 2
  14 #define TRIGGER          3
  15
  16 void pulsePin(int pin, int value);
  17 void lcdCommandWrite(int value);
  18 void lcdDataWrite(int value);
  19 void lcdNumberWrite(int nr);
  20 void lcdHome(int row);
  21 void lcdClear();
  22 void lcdInit();
  23 void encoderInit();
  24 void buttonInit();
  25 void setup (void);
  26 void incrementValue();
  27 void decrementValue();
  28 void updateEncoderValue();
  29 void switchModes();
  30 void switchSelected();
  31 void toggleRunning();
  32 void drawTimecode(int secs, int rep);
  33 int timecodeLength(int secs, int rep);
  34 void loop(void);
  35 int buttonA =           0; // Left pushbutton
  36 int buttonB =           1; // Right pushbutton
  37
  38 int inputTrigger =  2; // Input trigger interrupt
  39
  40 int encoderButton =     3;
  41 int encoderPinA =       4;
  42 int encoderPinB =       5;
  43
  44 int lcdEnable =         6;
  45 int lcdDataBus[] =      { 7, 8, 9, 10 };
  46 int lcdDataClock =      11;
  47 int lcdDataInt =        12;
  48
  49 int cameraTrigger = 13; // Pulse low for shutter release
  50
  51 /////////////////////////////
  52
  53 int currentMode = INTERVAL, selected = 0;
  54 int running = 0;
  55 unsigned long lastToggleRunning = 0;
  56 unsigned long lastModeUpdate = 0;
  57 unsigned long lastSelectedUpdate = 0;
  58 unsigned long lastShutter = 0;
  59
  60
  61 int updateHeader = 1, updateEncoder = 1;
  62 int exposureTime = 0, lapseTime = 0;
  63 int exposureRepresentation = 0, lapseRepresentation = 0;
  64 int encoderPinALast = LOW;
  65 int n = LOW;
  66
  67 /*
  68  *  Higher level hardware functions
  69  */
  70
  71 void pulsePin(int pin, int value)
  72 {
  73         digitalWrite(pin, !value);
  74         delay(1);
  75         digitalWrite(pin, value);
  76         delay(1);
  77         digitalWrite(pin, !value);
  78         delay(1);
  79 }
  80
  81 /*
  82  *  lcd Control Functions
  83  */
  84
  85 void lcdCommandWrite(int value)
  86 {
  87         int i = 0;
  88         int value1 = value;
  89
  90         value1 >>= 4;
  91
  92         for (i = lcdDataBus[0]; i <= lcdDataInt; i++)
  93         {
  94                 digitalWrite(i,value1 & 01);
  95                 value1 >>= 1;
  96         }
  97
  98         pulsePin(lcdEnable, HIGH);
  99         delay(1);
 100
 101         for (i = lcdDataBus[0]; i <= lcdDataBus[3]; i++)
 102         {
 103                 digitalWrite(i, value & 01);
 104                 value >>= 1;
 105         }
 106
 107         value >>= 4;
 108
 109         for (i = lcdDataClock; i <= lcdDataInt; i++)
 110         {
 111                 digitalWrite(i, value & 01);
 112                 value >>= 1;
 113         }
 114
 115         pulsePin(lcdEnable, HIGH);
 116 }
 117
 118 void lcdDataWrite(int value)
 119 {
 120         int i = 0;
 121         int value1 = value;
 122
 123         digitalWrite(lcdDataInt, HIGH);
 124         digitalWrite(lcdDataClock, LOW);
 125
 126         value1 >>= 4;
 127
 128         for (i=lcdDataBus[0]; i <= lcdDataBus[3]; i++)
 129         {
 130                 digitalWrite(i,value1 & 01);
 131                 value1 >>= 1;
 132         }
 133
 134         pulsePin(lcdEnable, HIGH);
 135         delay(1);
 136
 137         digitalWrite(lcdDataInt, HIGH);
 138         digitalWrite(lcdDataClock, LOW);
 139
 140         for (i=lcdDataBus[0]; i <= lcdDataBus[3]; i++)
 141         {
 142                 digitalWrite(i,value & 01);
 143                 value >>= 1;
 144         }
 145
 146         pulsePin(lcdEnable, HIGH);
 147 }
 148
 149 void lcdNumberWrite(int nr)
 150 {
 151         // We don't need negatives, but if you do:
 152         /*if(nr < 0)
 153         {
 154                 lcdCommandWrite(557);
 155                 nr = abs(nr);
 156         }
 157         else
 158         {
 159                 lcdCommandWrite(544);
 160         }*/
 161
 162         int n1 = nr/100;
 163         int n2 = (nr - n1 * 100) / 10;
 164
 165         if(n2)
 166                 lcdCommandWrite(560 + n2);
 167
 168         nr = nr - n1 * 100 - n2 * 10;
 169         lcdCommandWrite(560 + nr);
 170 }
 171
 172 void lcdHome(int row)
 173 {
 174         lcdCommandWrite(0x02);
 175
 176         delay(4);
 177
 178         if(row == 1)
 179                 lcdCommandWrite(0xC0);
 180
 181         delay(1);
 182 }
 183
 184 void lcdClear()
 185 {
 186         lcdCommandWrite(0x01);
 187         delay(4);
 188 }
 189
 190 /*
 191  *  Hardware initialization functions
 192  */
 193
 194 void lcdInit()
 195 {
 196         int i = 0;
 197
 198         for (i = lcdEnable; i <= lcdDataInt; i++)
 199                 pinMode(i, OUTPUT);
 200
 201         lcdCommandWrite(0x03); delay(64);
 202         lcdCommandWrite(0x03); delay(50);
 203         lcdCommandWrite(0x03); delay(50);
 204         lcdCommandWrite(0x02); delay(50);
 205         lcdCommandWrite(0x2C); delay(20);
 206         lcdCommandWrite(0x06); delay(20);
 207         lcdCommandWrite(0x0C); delay(20);
 208         lcdCommandWrite(0x01); delay(100);
 209         lcdCommandWrite(0x80); delay(30);
 210 }
 211
 212 void encoderInit()
 213 {
 214         pinMode (encoderPinA, INPUT);
 215         digitalWrite(encoderPinA, HIGH);
 216         pinMode (encoderPinB, INPUT);
 217         digitalWrite(encoderPinB, HIGH);
 218 }
 219
 220 void buttonInit()
 221 {
 222         pinMode(buttonA, INPUT);
 223         digitalWrite(buttonA, HIGH);
 224         pinMode(buttonB, INPUT);
 225         digitalWrite(buttonB, HIGH);
 226
 227         pinMode(encoderButton, INPUT);
 228         digitalWrite(encoderButton, HIGH);
 229 }
 230
 231
 232 void setup (void)
 233 {
 234         pinMode(cameraTrigger, OUTPUT);
 235         digitalWrite(cameraTrigger, HIGH);
 236
 237         lcdInit();
 238         encoderInit();
 239         buttonInit();
 240 }
 241
 242 void incrementValue()
 243 {
 244         if(selected == 0)
 245         {
 246                 if(lapseRepresentation == 0)
 247                         lapseTime++;
 248                 else
 249                         lapseTime += 60;
 250         }
 251         else
 252         {
 253                 if(exposureRepresentation == 0)
 254                         exposureTime++;
 255                 else
 256                         exposureTime += 60;
 257
 258                 if(exposureTime > lapseTime)
 259                         lapseTime = exposureTime;
 260         }
 261 }
 262
 263 void decrementValue()
 264 {
 265         if(selected == 0)
 266         {
 267                 if(lapseRepresentation == 0)
 268                         lapseTime--;
 269                 else
 270                         lapseTime -= 60;
 271         }
 272         else
 273         {
 274                 if(exposureRepresentation == 0)
 275                         exposureTime--;
 276                 else
 277                         exposureTime -= 60;
 278         }
 279 }
 280
 281 void updateEncoderValue()
 282 {
 283         n = digitalRead(encoderPinA);
 284         if ((encoderPinALast == LOW) && (n == HIGH))
 285         {
 286                 if (digitalRead(encoderPinB) == LOW)
 287                         decrementValue();
 288                 else
 289                         incrementValue();
 290
 291                 if(lapseTime < 0)
 292                         lapseTime = 0;
 293                 if(exposureTime < 0)
 294                         exposureTime = 0;
 295
 296                 if(lapseTime >= 60)
 297                         lapseRepresentation = 1;
 298                 else
 299                         lapseRepresentation = 0;
 300
 301                 if(exposureTime >= 60)
 302                         exposureRepresentation = 1;
 303                 else
 304                         exposureRepresentation = 0;
 305
 306                 updateEncoder = 1;
 307         }
 308         encoderPinALast = n;
 309 }
 310
 311 void switchModes()
 312 {
 313         unsigned long diff = (millis() - lastModeUpdate);
 314
 315         if(diff < 300) // careful about the overflow...
 316         {
 317                 lastModeUpdate = millis();
 318                 return;
 319         }
 320         else
 321                 lastModeUpdate = millis();
 322
 323         currentMode++;
 324         if(currentMode > 3)
 325                 currentMode = 0;
 326
 327         if(currentMode == BULB)
 328                 selected = 1;
 329         else
 330                 selected = 0;
 331
 332         updateHeader = 1;
 333 }
 334
 335 void switchSelected()
 336 {
 337         if(currentMode == INTERVALBULB)
 338         {
 339                 unsigned long diff = (millis() - lastSelectedUpdate);
 340
 341                 if(diff < 300) // careful about the overflow...
 342                 {
 343                         lastSelectedUpdate = millis();
 344                         return;
 345                 }
 346                 else
 347                         lastSelectedUpdate = millis();
 348
 349                 selected = !selected;
 350         }
 351
 352         updateEncoder = 1;
 353 }
 354
 355 void toggleRunning()
 356 {
 357         unsigned long diff = (millis() - lastToggleRunning);
 358         if(diff < 300) // careful about the overflow...
 359         {
 360                 lastToggleRunning = millis();
 361                 return;
 362         }
 363         else
 364                 lastToggleRunning = millis();
 365
 366         running = !running;
 367 }
 368
 369 void drawTimecode(int secs, int rep)
 370 {
 371         if(rep == 0)
 372         {
 373                 lcdNumberWrite(secs);
 374                 lcdDataWrite('"');
 375         }
 376         else
 377         {
 378                 lcdNumberWrite(secs/60);
 379                 lcdDataWrite('\'');
 380         }
 381 }
 382
 383 int timecodeLength(int secs, int rep)
 384 {
 385         int count = 2;
 386
 387         if(rep)
 388                 secs = secs/60;
 389
 390         int n1 = secs/100;
 391         int n2 = (secs - n1 * 100) / 10;
 392
 393         if(n2)
 394                 count++;
 395
 396         return count;
 397 }
 398
 399 char *modeHeader[4] = {"Interval", "            Bulb", "Interval    Bulb", "Trigger"};
 400
 401 void loop(void)
 402 {
 403         if(updateHeader)
 404         {
 405                 lcdHome(0);
 406
 407                 int count;
 408                 for (count = 0; modeHeader[currentMode][count] != 0; count++)
 409                         lcdDataWrite(modeHeader[currentMode][count]);
 410                 for (; count < 16; count++)
 411                         lcdDataWrite(544);
 412
 413                 updateHeader = 0;
 414                 updateEncoder = 1;
 415         }
 416
 417         if(updateEncoder)
 418         {
 419                 lcdHome(1);
 420
 421                 if(currentMode != BULB)
 422                         drawTimecode(lapseTime, lapseRepresentation);
 423
 424                 int width = 0;
 425
 426                 if(currentMode != BULB)
 427                         width += timecodeLength(lapseTime, lapseRepresentation);
 428                 if(currentMode != INTERVAL && currentMode != TRIGGER)
 429                         width += timecodeLength(exposureTime, exposureRepresentation);
 430
 431                 for(int i = 16; i > width; i--)
 432                         lcdDataWrite(' ');
 433
 434                 if(currentMode != INTERVAL && currentMode != TRIGGER)
 435                         drawTimecode(exposureTime, exposureRepresentation);
 436
 437                 updateEncoder = 0;
 438         }
 439
 440         if(digitalRead(buttonA) == LOW)
 441                 toggleRunning();
 442
 443         if(running)
 444         {
 445                 if(currentMode == TRIGGER)
 446                 {
 447                         // do special trigger stuff
 448                         return;
 449                 }
 450
 451                 unsigned long diff = millis() - lastShutter;
 452
 453                 int adjustedLapseTime = lapseTime;
 454                 if(currentMode != INTERVAL)
 455                         adjustedLapseTime -= exposureTime;
 456
 457                 if(diff > (adjustedLapseTime * 1000)) // careful about the overflow...
 458                 {
 459                         digitalWrite(cameraTrigger, LOW);
 460
 461                         if(currentMode == INTERVAL)
 462                                 delay(100);
 463                         else
 464                                 delay(exposureTime * 1000); //delay for length of exposure
 465
 466                         digitalWrite(cameraTrigger, HIGH);
 467                         lastShutter = millis();
 468
 469                         if(currentMode == BULB)
 470                                 running = 0;
 471                 }
 472         }
 473         else
 474         {
 475                 updateEncoderValue();
 476
 477                 if(digitalRead(buttonB) == LOW)
 478                         switchModes();
 479
 480                 if(digitalRead(encoderButton) == LOW)
 481                         switchSelected();
 482         }
 483 }
 484
 485 int main(void)
 486 {
 487         init();
 488
 489         setup();
 490
 491         for (;;)
 492                 loop();
 493
 494         return 0;
 495 }
 496