Welcome, %1$s. Please login or register. - Did you miss your activation email?

Login with username, password and session length
 

Author Topic: [How To - Arduino Nano] TMP Starfleet Starship Photon Torpedo Effect - Two LEDs  (Read 371 times)

Offline Gadgetron_3000

  • Admiral
  • *****
  • Posts: 1183
Hi, Everyone!

Here is another Arduino sketch.  This time for TMP Starfleet Starship Photon Torpedo Effect - Two LEDs.

First, if you need to install an Arduino board and the Arduino Software (IDE), you can check out my previous post for a guide: http://scifimodelaction.com/sfmaforum/index.php?topic=4793.msg64348#msg64348.

This Arduino sketch will have the Nano control two LEDs.  When a momentary switch is pressed and released, the corresponding LED ramps up to a certain level and then a brighter flash burst occurs just a bit afterwards.  When the momentary switch is held down, the LED effect loops until the switch is released.

The code allows one to change both the ramp up increment steps and the length of the burst rate.

This is intended for any TMP-era starship.  However, it can also be used for anything that requires this kind of effect.  I posted a demo video on YouTube: https://youtu.be/ETzkUzYfVHw.

Now onto programming the attached board...

1. Copy the following code:

Quote
/*
  TMP Starfleet Starship Photon Torpedo Effect - Two LEDs:

    - LED ramps up to a certain level and then a brighter flash burst
      moments later.

    - This particular version of the sketch supports two LEDs and two
      momentary switches (one per LED).

    - The momentary switches can use digital pins, but the LEDs need to
      be on PWM pins.
     
    - 1 second = 1000 milliseconds
   
    - Based on original Arduino sketch by 'STDummy'
      https://forum.arduino.cc/index.php?topic=353727.msg2439994#msg2439994 .

*/

// switchCall allocations
const byte switchPin = 2;               // Momentary switch #1 on pin 2 (digital)
boolean switchFlag = false;             // switch not triggered
byte oldSwitchState = HIGH;             // assume switch open because of pull-up resistor
const unsigned long debounceTime = 10;  // milliseconds debounce setting
unsigned long switchPressTime;          // when the switch last changed state
boolean reader = true;                  // switch blocker (switch routine not to be called during led flash)

const byte switchPin2 = 4;              // Momentary switch #2 on pin 4 (digital)
boolean switchFlag2 = false;            // switch not triggered
byte oldSwitchState2 = HIGH;            // assume switch open because of pull-up resistor
const unsigned long debounceTime2 = 10; // milliseconds debounce setting
unsigned long switchPressTime2;         // when the switch last changed state
boolean reader2 = true;                 // switch blocker (switch routine not to be called during led flash)

// rampUp allocations
const int ledPin = 3;                   // LED #1 on pin 3 (PWM)
boolean activate = false;               // ramp up not active
unsigned long currentTime;              // for tracking time
unsigned long loopTime;                 // during ramp up
int brightness = 0;                     // brightness during ramp up
int fadeAmount = 1;                     // increments to ramp up by

const int ledPin2 = 5;                  // LED #2 on pin 5 (PWM)
boolean activate2 = false;              // ramp up not active
unsigned long currentTime2;             // for tracking time
unsigned long loopTime2;                // during ramp up
int brightness2 = 0;                    // brightness during ramp up
int fadeAmount2 = 1;                    // increments to ramp up by

// flashLed allocations
const int interval = 150;               // 150ms flash time
static unsigned long previousMillis;    // flash time counter
static boolean firstRun = true;         // start of flash process

const int interval2 = 150;              // 150ms flash time
static unsigned long previousMillis2;   // flash time counter
static boolean firstRun2 = true;        // start of flash process

void setup ()
{
  pinMode (switchPin, INPUT_PULLUP);
  pinMode (ledPin, OUTPUT);
 
  pinMode (switchPin2, INPUT_PULLUP);
  pinMode (ledPin2, OUTPUT);
}  // end of setup

void loop ( )
{
  switchCall ();
  rampUp ();
  flashLed ();
 
  switchCall2 ();
  rampUp2 ();
  flashLed2 ();
}  // end of loop

void flashLed ()
{
  unsigned long currentMillis = millis();
  if (firstRun == true) {                           // If start of flash
    previousMillis = currentMillis;                 // advance timer
    firstRun = false;                               // flash now in progress
    reader = false;                                 // set switch blocking flag
  }
  if (currentMillis - previousMillis >= interval) { // If led has been HIGH for enough time
    previousMillis = currentMillis;                 // advance timer
    digitalWrite(ledPin, LOW);                      // switch off led
    firstRun = true;                                // reset flash process indicator
    brightness = 0;                                 // reset ready for next rampUp
    reader = true;                                  // unblock switch
  }
}

void rampUp ()
{
  if (switchFlag == true)                       // Has switch been pressed?
    activate = true; {                          // ramp up underway
    while (activate == true) {
      currentTime = millis();
      if (currentTime >= (loopTime + 20)) {     // while rampup underway, increment time
        analogWrite (ledPin, brightness);       // write current brightness
        brightness = (brightness + fadeAmount); // fadeup the led
        if (brightness < 50)
          activate = true;                      // still below 50?
        else {
          activate = false;                     // above 50 so reset flag and switch led on full
          digitalWrite (ledPin, HIGH);
        }
        loopTime = currentTime;                 // update time
      }
    }
  }
  activate = false;                             // process complete so reset flag
}

void switchCall ()
{
  if (reader == true) {                                  // Has previous FlashLed activation completed?
    byte switchState = digitalRead (switchPin);          // see if switch is open or closed
    if (switchState != oldSwitchState) {                 // has it changed since last time?
      if (millis () - switchPressTime >= debounceTime) { // debounce
        switchPressTime = millis ();                     // when we closed the switch
        oldSwitchState =  switchState;                   // remember for next time
        if (switchState == LOW)
          switchFlag = true;                             // end if switchState is LOW
        else
          switchFlag = false;                            // end if switchState is HIGH
      }                                                  // end if debounce time up
    }                                                    // end of state change
  }                                                      // end of function
}

void flashLed2 ()
{
  unsigned long currentMillis2 = millis();
  if (firstRun2 == true) {                             // If start of flash
    previousMillis2 = currentMillis2;                  // advance timer
    firstRun2 = false;                                 // flash now in progress
    reader2 = false;                                   // set switch blocking flag
  }
  if (currentMillis2 - previousMillis2 >= interval2) { // If led has been HIGH for enough time
    previousMillis2 = currentMillis2;                  // advance timer
    digitalWrite(ledPin2, LOW);                        // switch off led
    firstRun2 = true;                                  // reset flash process indicator
    brightness2 = 0;                                   // reset ready for next rampUp
    reader2 = true;                                    // unblock switch
  }
}

void rampUp2 ()
{
  if (switchFlag2 == true)                         // Has switch been pressed?
    activate2 = true; {                            // ramp up underway
    while (activate2 == true) {
      currentTime2 = millis();
      if (currentTime2 >= (loopTime2 + 20)) {      // while rampup underway, increment time
        analogWrite (ledPin2, brightness2);        // write current brightness
        brightness2 = (brightness2 + fadeAmount2); // fadeup the led
        if (brightness2 < 50)
          activate2 = true;                        // still below 50?
        else {
          activate2 = false;                       // above 50 so reset flag and switch led on full
          digitalWrite (ledPin2, HIGH);
        }
        loopTime2 = currentTime2;                  // update time
      }
    }
  }
  activate2 = false;                               // process complete so reset flag
}

void switchCall2 ()
{
  if (reader2 == true) {                                   // Has previous FlashLed activation completed?
    byte switchState2 = digitalRead (switchPin2);          // see if switch is open or closed
    if (switchState2 != oldSwitchState2) {                 // has it changed since last time?
      if (millis () - switchPressTime2 >= debounceTime2) { // debounce
        switchPressTime2 = millis ();                      // when we closed the switch
        oldSwitchState2 =  switchState2;                   // remember for next time
        if (switchState2 == LOW)
          switchFlag2 = true;                              // end if switchState is LOW
        else
          switchFlag2 = false;                             // end if switchState is HIGH
      }                                                    // end if debounce time up
    }                                                      // end of state change
  }                                                        // end of function
}

2. Replace the existing code in the Arduino software window with the copied code.
3. Save the sketch.  NOTE: for your reference, saved Arduino sketches are located in the C:\Users\<Windows user name>\Documents\Arduino folder.
4. Click the 'Verify' check-mark icon to allow the Arduino software to compile the code and check for issues.  When finished, the software status bar will say 'Done compiling.'
5. Click the 'Upload' right-arrow icon to allow the Arduino software to program the Nano.  When finished, the software status bar will say 'Done uploading.'

And that's it!  Easy!

Here is a pin diagram picture that will show where to make all your connections:



Don't forget to use resistors for your setup!  You should be able to use a 9- or 12-volt power supply.  For the purposes of my testing, I used a 5-volt "power bank" external rechargeable battery.

:)
« Last Edit: May 24, 2017, 04:07:05 am by Gadgetron_3000 »
"They've done studies, you know.  60% of the time, it works every time."

-----

Google+: https://plus.google.com/109660073537038906328

Offline texastony1946

  • Ensign
  • *
  • Posts: 24
Thanks for the code. I will try this one. I have used a 555 chip in the past to do this. This will certainly make it easier.

Offline Plaztek

  • Lieutenant
  • **
  • Posts: 86
  • This is about saving the future of humanity!
Awesome, thanks posting this. I really have to start getting into using these.
I'm sorry, I didn't mean to interrupt your little quest. Captain Ahab has to go hunt his whale!

Offline whb64

  • Captain
  • ****
  • Posts: 394
Can this also be used for NAV lights and strobes on the same board?

Offline whb64

  • Captain
  • ****
  • Posts: 394
Can this also be used for NAV lights and strobes on the same board?
found the answer to this :)

Offline whb64

  • Captain
  • ****
  • Posts: 394
Quick question to Gadgetron or anyone who can answer...

This is the effect I am looking for, but can it be done with just one switch that fires both torpedo launcher sequentially?  Everything would function the same except instead of two switches it would be controlled by one.

 




Enterprise © Bloc